sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ ParameterManager/ ParametersVersion.ts

import * as parametermanager from "@distilled.cloud/gcp/parametermanager_v1";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import { GcpEnvironment } from "../Environment.ts";
import type { Providers } from "../Providers.ts";
import {
  DEFAULT_LOCATION,
  ParameterNotResolved,
  ParameterVersionNotResolved,
  ParameterVersionPayloadRequired,
  desiredPayloadData,
  expandParameter,
  getParameter,
  getVersion,
  hasAlchemyLabelMap,
  lastSegment,
  listAlchemyParameters,
  listVersions,
  locationFromParameter,
  normalizeLocation,
  parseVersionName,
  samePayload,
  toPhysicalId,
  versionResourceName,
  waitUntilVersionGone,
} from "./internal.ts";

export type ParametersVersionProps = {
  /**
   * Parent parameter. Full name
   * `projects/{project}/locations/{location}/parameters/{parameter}`
   * or the parameter id (combined with `location`). Immutable —
   * changing it replaces the version.
   */
  parameter: string;
  /**
   * Parameter Manager location used when `parameter` is a bare id.
   * Immutable — changing it replaces the version. `GLOBAL` is accepted
   * and normalized to `global`.
   * @default "global"
   */
  location?: string;
  /**
   * Version id (the `{version}` segment of
   * `.../parameters/{parameter}/versions/{version}`). If omitted, a
   * unique name is generated from the stack, stage, and logical id.
   * Must be 1-63 characters, start with a letter, and match
   * `[a-zA-Z][a-zA-Z0-9_-]*`. Immutable — changing it replaces the
   * version.
   */
  parameterVersionId?: string;
  /**
   * UTF-8 payload. Alchemy base64-encodes this for the API. Ignored
   * when `payload.data` is set. Immutable — changing it replaces the
   * version.
   */
  data?: string;
  /**
   * Payload as stored by the API. `data` is standard base64. Takes
   * precedence over `data`. Immutable — changing it replaces the
   * version.
   */
  payload?: {
    data?: string;
  };
  /**
   * When true, the version is metadata-only: get always returns the
   * BASIC view and render fails. Mutable.
   * @default false
   */
  disabled?: boolean;
};

export type ParametersVersion = Resource<
  "GCP.ParameterManager.ParametersVersion",
  ParametersVersionProps,
  {
    /** Full resource name `projects/{project}/locations/{location}/parameters/{parameter}/versions/{version}`. */
    name: string;
    /** Version id (last path segment). */
    parameterVersionId: string;
    /** Parent parameter resource name. */
    parameter: string;
    /** Parent parameter id. */
    parameterId: string;
    /** Project id. */
    project: string;
    /** Location id (`us-central1`, `global`, …). */
    location: string;
    /** Standard-base64 payload, when the FULL view returned it. */
    payloadData: string | undefined;
    /** Whether the version is disabled. */
    disabled: boolean;
    /** CMEK key version used to encrypt this payload, if the parent uses CMEK. */
    kmsKeyVersion: string | undefined;
    /** RFC3339 creation timestamp. */
    createTime: string | undefined;
    /** RFC3339 last-update timestamp. */
    updateTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * A Parameter Manager parameter version — an immutable payload attached
 * to a {@link Parameter}. Versions have no labels field; `list` / nuke
 * find versions whose parent parameter carries Alchemy labels.
 *
 * Changing `parameterVersionId`, `parameter`, `location`, or the payload
 * replaces the version. `disabled` updates in place.
 *
 * ### Creating a ParametersVersion
 * **Example:** UTF-8 payload
 * ```typescript
 * const parameter = yield* GCP.ParameterManager.Parameter("AppConfig", {});
 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
 *   parameter: parameter.name,
 *   data: "host=api.example.com",
 * });
 * ```
 *
 * **Example:** JSON payload on a JSON parameter
 * ```typescript
 * const parameter = yield* GCP.ParameterManager.Parameter("AppConfig", {
 *   format: "JSON",
 * });
 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
 *   parameter: parameter.name,
 *   data: JSON.stringify({ host: "api.example.com" }),
 * });
 * ```
 *
 * ### Disabling a Version
 * **Example:** Keep metadata, hide payload
 * ```typescript
 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
 *   parameter: parameter.name,
 *   parameterVersionId: "v1",
 *   data: "host=api.example.com",
 *   disabled: true,
 * });
 * ```
 *
 * @resource
 * @category ParameterManager
 */
export const ParametersVersion = Resource<ParametersVersion>(
  "GCP.ParameterManager.ParametersVersion",
);

export { ParameterVersionNotResolved, ParameterVersionPayloadRequired };

const toAttrs = (version: parametermanager.ParameterVersion, project: string) => {
  const name = version.name ?? "";
  const parsed = parseVersionName(name);
  return {
    name,
    parameterVersionId: parsed.parameterVersionId,
    parameter: parsed.parameter,
    parameterId: lastSegment(parsed.parameter),
    project: parsed.project || project,
    location: parsed.location,
    payloadData: version.payload?.data,
    disabled: version.disabled === true,
    kmsKeyVersion: version.kmsKeyVersion,
    createTime: version.createTime,
    updateTime: version.updateTime,
  };
};

const createBody = (payloadData: string, disabled: boolean): parametermanager.ParameterVersion => ({
  payload: { data: payloadData },
  disabled,
});

export const ParametersVersionProvider = () =>
  Provider.succeed(ParametersVersion, {
    stables: [
      "name",
      "parameterVersionId",
      "parameter",
      "parameterId",
      "project",
      "location",
      "createTime",
    ],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const previousId = olds?.parameterVersionId ?? output?.parameterVersionId;
      const nextId = news.parameterVersionId ?? previousId;
      const previousParameter = lastSegment(olds?.parameter ?? output?.parameter ?? "");
      const nextParameter = lastSegment(news.parameter);
      const previousLocation = normalizeLocation(
        olds?.location ??
          output?.location ??
          locationFromParameter(olds?.parameter ?? output?.parameter, DEFAULT_LOCATION),
      );
      const nextLocation = normalizeLocation(
        news.location ?? locationFromParameter(news.parameter, previousLocation),
      );
      const previousPayload =
        olds?.payload?.data ??
        (olds?.data !== undefined ? yield* desiredPayloadData(olds) : output?.payloadData);
      const nextPayload = yield* desiredPayloadData(news);
      const idChanged = previousId !== undefined && nextId !== undefined && previousId !== nextId;
      const parentChanged = previousParameter.length > 0 && previousParameter !== nextParameter;
      const locationChanged = previousLocation !== nextLocation;
      const payloadChanged =
        nextPayload !== undefined &&
        previousPayload !== undefined &&
        !samePayload(previousPayload, nextPayload);
      if (!idChanged && !parentChanged && !locationChanged && !payloadChanged) {
        return undefined;
      }
      return {
        action: "replace" as const,
        deleteFirst:
          !idChanged &&
          !parentChanged &&
          !locationChanged &&
          payloadChanged &&
          previousId !== undefined &&
          nextId === previousId,
      };
    }),

    read: Effect.fn(function* ({ id, olds, output }) {
      const env = yield* GcpEnvironment.current;
      const location = normalizeLocation(
        olds?.location ??
          output?.location ??
          locationFromParameter(olds?.parameter ?? output?.parameter, DEFAULT_LOCATION),
      );
      const parameter = expandParameter(
        olds?.parameter ?? output?.parameter ?? "",
        env.project,
        location,
      );
      const parameterVersionId = yield* toPhysicalId(
        id,
        olds?.parameterVersionId,
        output?.parameterVersionId,
        "version",
      );
      const name = output?.name ?? versionResourceName(parameter, parameterVersionId);
      const existing = yield* getVersion(name);
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, env.project);
      const parent = yield* getParameter(attrs.parameter);
      return hasAlchemyLabelMap(parent?.labels) ? attrs : Unowned(attrs);
    }),

    list: () =>
      Effect.gen(function* () {
        const env = yield* GcpEnvironment.current;
        const parameters = yield* listAlchemyParameters(env.project);
        const versions = yield* Effect.forEach(
          parameters,
          (parameter) => listVersions(parameter.name ?? ""),
          { concurrency: 4 },
        );
        return versions.flat().map((version) => toAttrs(version, env.project));
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const env = yield* GcpEnvironment.current;
      const location = normalizeLocation(
        news.location ??
          output?.location ??
          locationFromParameter(news.parameter, DEFAULT_LOCATION),
      );
      const parameter = expandParameter(news.parameter, env.project, location);
      const parameterVersionId = yield* toPhysicalId(
        id,
        news.parameterVersionId,
        output?.parameterVersionId,
        "version",
      );
      const name = versionResourceName(parameter, parameterVersionId);
      const desiredDisabled = news.disabled === true;
      const desiredPayload = yield* desiredPayloadData(news);

      yield* getParameter(parameter).pipe(
        Effect.flatMap((parent) =>
          parent === undefined
            ? Effect.fail(new ParameterNotResolved({ resourceName: parameter }))
            : Effect.succeed(parent),
        ),
        Effect.retry({
          while: (error) => error._tag === "GCP.ParameterManager.ParameterNotResolved",
          times: 8,
          schedule: Schedule.spaced("1 second"),
        }),
      );

      let current = yield* getVersion(name);

      if (
        current !== undefined &&
        desiredPayload !== undefined &&
        !samePayload(current.payload?.data, desiredPayload)
      ) {
        yield* parametermanager
          .deleteProjectsLocationsParametersVersions({
            name: current.name ?? name,
          })
          .pipe(Effect.catchTag("NotFound", () => Effect.void));
        yield* waitUntilVersionGone(name);
        current = undefined;
      }

      if (current === undefined) {
        if (desiredPayload === undefined) {
          return yield* new ParameterVersionPayloadRequired({ resourceName: name });
        }
        const created = yield* parametermanager
          .createProjectsLocationsParametersVersions({
            parent: parameter,
            parameterVersionId,
            body: createBody(desiredPayload, desiredDisabled),
          })
          .pipe(
            Effect.retry({
              // The parent parameter may not be readable yet.
              while: (error): boolean => error._tag === "NotFound",
              times: 8,
              schedule: Schedule.spaced("1 second"),
            }),
            Effect.catchTag("Conflict", () => getVersion(name)),
          );
        current = (yield* getVersion(name)) ?? created ?? undefined;
      }

      if (current === undefined) {
        return yield* new ParameterVersionNotResolved({ resourceName: name });
      }

      if ((current.disabled === true) !== desiredDisabled) {
        yield* parametermanager.patchProjectsLocationsParametersVersions({
          name,
          updateMask: "disabled",
          body: {
            name,
            disabled: desiredDisabled,
          },
        });
        current = (yield* getVersion(name)) ?? current;
      }

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

    delete: Effect.fn(function* ({ output }) {
      yield* parametermanager.deleteProjectsLocationsParametersVersions({ name: output.name }).pipe(
        Effect.retry({
          while: (error) => error._tag === "Conflict",
          times: 8,
          schedule: Schedule.spaced("1 second"),
        }),
        Effect.catchTag(["NotFound", "BadRequest"], () => Effect.void),
      );
      yield* waitUntilVersionGone(output.name);
    }),
  });