sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ FirebaseRules/ Ruleset.ts

import * as firebaserules from "@distilled.cloud/gcp/firebaserules_v1";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import { GcpEnvironment } from "../Environment.ts";
import { createInternalLabels } from "../Labels.ts";
import type { Providers } from "../Providers.ts";
import {
  findOwnedRuleset,
  getRuleset,
  listFullRulesets,
  listOwnedRulesets,
  ownedByAlchemy,
  projectParent,
  rulesetIdOf,
  sameText,
  sourceFingerprint,
  stampSource,
  toUserFiles,
  type RulesetFile,
  type RulesetSource,
} from "./internal.ts";

export type { RulesetFile, RulesetSource };

export type RulesetProps = {
  /**
   * Source files for this ruleset. Rulesets are immutable — changing
   * `source` replaces the ruleset. Firebase Rules has no labels field,
   * so Alchemy stamps ownership into a `// [alchemy …]` comment on the
   * first file and strips it from attributes.
   */
  source: RulesetSource;
  /**
   * Intended resource this ruleset should be released to, e.g.
   * `firestore.googleapis.com/projects/{project}/databases/(default)`.
   * May be left blank for the default release. Immutable — changing it
   * replaces the ruleset.
   */
  attachmentPoint?: string;
};

export type Ruleset = Resource<
  "GCP.FirebaseRules.Ruleset",
  RulesetProps,
  {
    /** Full resource name `projects/{project}/rulesets/{rulesetId}`. */
    name: string;
    /** Server-assigned ruleset id (last path segment). */
    rulesetId: string;
    /** Project id. */
    project: string;
    /** User source with the Alchemy ownership comment stripped. */
    source: RulesetSource;
    /** Services declared by this ruleset (`cloud.firestore`, …). */
    services: string[];
    /** Intended release attachment point, if set. */
    attachmentPoint: string | undefined;
    /** RFC3339 creation timestamp. */
    createTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * An immutable Firebase Security Rules ruleset.
 *
 * Rulesets have no labels field, so Alchemy stamps ownership into a
 * `// [alchemy …]` comment on the first source file for `list` / nuke.
 * Source and `attachmentPoint` are identity — changing either replaces
 * the ruleset. The ruleset id is assigned by the service.
 *
 * ### Creating a Ruleset
 * **Example:** Firestore rules
 * ```typescript
 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Firestore", {
 *   source: {
 *     files: [{
 *       name: "firestore.rules",
 *       content: "rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if false; } } }",
 *     }],
 *   },
 * });
 * ```
 *
 * **Example:** Storage rules with an attachment point
 * ```typescript
 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Storage", {
 *   attachmentPoint:
 *     "firebase.storage.googleapis.com/projects/my-project/buckets/my-bucket",
 *   source: {
 *     files: [{
 *       name: "storage.rules",
 *       content: "rules_version = '2'; service firebase.storage { match /b/{bucket}/o { match /{allPaths=**} { allow read, write: if false; } } }",
 *     }],
 *   },
 * });
 * ```
 *
 * ### Replacing a Ruleset
 * **Example:** New source (new ruleset id)
 * ```typescript
 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Firestore", {
 *   source: {
 *     files: [{
 *       name: "firestore.rules",
 *       content: "rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if request.auth != null; } } }",
 *     }],
 *   },
 * });
 * ```
 *
 * @resource
 * @category FirebaseRules
 */
export const Ruleset = Resource<Ruleset>("GCP.FirebaseRules.Ruleset");

export class RulesetNotResolved extends Data.TaggedError("GCP.FirebaseRules.RulesetNotResolved")<{
  resourceName: string;
}> {}

const toAttrs = (ruleset: firebaserules.Ruleset, project: string) => {
  const name = ruleset.name ?? "";
  return {
    name,
    rulesetId: rulesetIdOf(name),
    project,
    source: { files: toUserFiles(ruleset.source?.files) },
    services: [...(ruleset.metadata?.services ?? [])],
    attachmentPoint: ruleset.attachmentPoint,
    createTime: ruleset.createTime,
  };
};

export const RulesetProvider = () =>
  Provider.succeed(Ruleset, {
    stables: ["name", "rulesetId", "project", "createTime"],

    diff: Effect.fn(function* ({ news, output }) {
      if (!isResolved(news)) return undefined;
      if (output === undefined) return undefined;
      const sourceChanged =
        sourceFingerprint(news.source.files) !== sourceFingerprint(output.source.files);
      const attachmentChanged =
        news.attachmentPoint !== undefined &&
        (news.attachmentPoint ?? "") !== (output.attachmentPoint ?? "");
      if (!sourceChanged && !attachmentChanged) return undefined;
      return { action: "replace" as const, deleteFirst: false };
    }),

    read: Effect.fn(function* ({ id, output, previous }) {
      const env = yield* GcpEnvironment.current;
      let existing = yield* getRuleset(output?.name ?? "");
      if (existing === undefined) {
        existing = yield* findOwnedRuleset(yield* listFullRulesets(env.project), id, output?.name);
      }
      if (existing === undefined) return undefined;
      // A replacement creates a new ruleset under the same logical id: the one
      // it is replacing is not the replacement.
      if (output === undefined && existing.name === previous?.name) return undefined;
      const attrs = toAttrs(existing, env.project);
      return (yield* ownedByAlchemy(id, existing.source)) ? attrs : Unowned(attrs);
    }),

    list: () =>
      Effect.gen(function* () {
        const env = yield* GcpEnvironment.current;
        const rulesets = yield* listOwnedRulesets(env.project);
        return rulesets.map((ruleset) => toAttrs(ruleset, env.project));
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const env = yield* GcpEnvironment.current;
      const parent = projectParent(env.project);
      const ownership = yield* createInternalLabels(id);
      const desiredSource = stampSource(news.source, ownership);

      let current = yield* getRuleset(output?.name ?? "");
      if (current === undefined) {
        const found = yield* findOwnedRuleset(
          yield* listFullRulesets(env.project),
          id,
          output?.name,
        );
        // Replacement uses the same logical id as the old generation. Only
        // reuse a scanned ruleset when source matches (crash-after-create);
        // a different source must become a new ruleset.
        if (
          found !== undefined &&
          (output?.name === found.name ||
            (sourceFingerprint(found.source?.files) === sourceFingerprint(news.source.files) &&
              sameText(found.attachmentPoint, news.attachmentPoint)))
        ) {
          current = found;
        }
      }

      if (current === undefined) {
        const created = yield* firebaserules
          .createProjectsRulesets({
            name: parent,
            body: {
              source: desiredSource,
              attachmentPoint: news.attachmentPoint,
            },
          })
          .pipe(
            Effect.catchTag("Conflict", () =>
              listFullRulesets(env.project).pipe(
                Effect.flatMap((rulesets) => findOwnedRuleset(rulesets, id, undefined)),
              ),
            ),
          );
        current = created ?? undefined;
      }

      if (current === undefined) {
        return yield* new RulesetNotResolved({
          resourceName: output?.name ?? `${parent}/rulesets`,
        });
      }

      return toAttrs(current, env.project);
    }),

    delete: Effect.fn(function* ({ output }) {
      if (!output.name) return;
      yield* firebaserules.deleteProjectsRulesets({ name: output.name }).pipe(
        // A just-deleted release's reference to this ruleset lingers briefly.
        Effect.retry({
          while: (error) => error._tag === "Conflict" || error._tag === "RulesetInUse",
          times: 8,
          schedule: Schedule.spaced("2 seconds"),
        }),
        Effect.catchTag("NotFound", () => Effect.void),
      );
    }),
  });