sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ Composer/ EnvironmentsUserWorkloadsConfigMap.ts

import * as composer from "@distilled.cloud/gcp/composer_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 type { Providers } from "../Providers.ts";
import {
  dataKey,
  environmentParent,
  lastSegment,
  mapOf,
  parseWorkloadName,
  toPhysicalId,
} from "./internal.ts";

export type EnvironmentsUserWorkloadsConfigMapProps = {
  /**
   * Parent environment resource name
   * (`projects/{project}/locations/{location}/environments/{environment}`).
   * Immutable — changing it replaces the ConfigMap.
   */
  environmentName: string;
  /**
   * ConfigMap id (the last path segment). If omitted, a unique RFC1035
   * name is generated from the stack, stage, and logical id. Must start
   * with a lowercase letter, be 1-63 characters, and match
   * `[a-z]([-a-z0-9]*[a-z0-9])?`. Immutable — changing it replaces the
   * ConfigMap.
   */
  configMapId?: string;
  /**
   * Kubernetes ConfigMap data as key-value pairs. Stored exactly as
   * given: ConfigMaps have no labels, so Alchemy tracks them by name.
   */
  data?: Record<string, string>;
};

export type EnvironmentsUserWorkloadsConfigMap = Resource<
  "GCP.Composer.EnvironmentsUserWorkloadsConfigMap",
  EnvironmentsUserWorkloadsConfigMapProps,
  {
    /** Full resource name `{environment}/userWorkloadsConfigMaps/{configMapId}`. */
    name: string;
    /** ConfigMap id (last path segment). */
    configMapId: string;
    /** Parent environment resource name. */
    environmentName: string;
    /** Project id. */
    project: string;
    /** Region id (`us-central1`, …). */
    location: string;
    /** Parent environment id. */
    environmentId: string;
    /** ConfigMap data. */
    data: Record<string, string>;
  },
  never,
  Providers
>;

/**
 * A user workloads ConfigMap for Airflow tasks that run with the
 * Kubernetes executor or KubernetesPodOperator.
 *
 * Supported on Cloud Composer 3 (`composer-3-airflow-2` and newer).
 * ConfigMaps have no labels field, so Alchemy tracks them by name and
 * never adds keys to `data`. `environmentName` and `configMapId` are
 * identity — changing either replaces the ConfigMap.
 *
 * ### Creating a User Workloads ConfigMap
 * **Example:** Generated name
 * ```typescript
 * const airflow = yield* GCP.Composer.Environment("Airflow", {
 *   config: {
 *     environmentSize: "ENVIRONMENT_SIZE_SMALL",
 *     nodeConfig: {
 *       serviceAccount: "composer-env@my-project.iam.gserviceaccount.com",
 *     },
 *     softwareConfig: { imageVersion: "composer-3-airflow-2" },
 *   },
 * });
 * const config = yield* GCP.Composer.EnvironmentsUserWorkloadsConfigMap(
 *   "TaskConfig",
 *   {
 *     environmentName: airflow.name,
 *     data: { LOG_LEVEL: "INFO" },
 *   },
 * );
 * ```
 *
 * **Example:** Explicit id
 * ```typescript
 * const config = yield* GCP.Composer.EnvironmentsUserWorkloadsConfigMap(
 *   "TaskConfig",
 *   {
 *     environmentName: airflow.name,
 *     configMapId: "task-config",
 *     data: { LOG_LEVEL: "DEBUG", REGION: "us-central1" },
 *   },
 * );
 * ```
 *
 * ### Updating data
 * **Example:** Change ConfigMap values
 * ```typescript
 * const config = yield* GCP.Composer.EnvironmentsUserWorkloadsConfigMap(
 *   "TaskConfig",
 *   {
 *     environmentName: airflow.name,
 *     configMapId: "task-config",
 *     data: { LOG_LEVEL: "WARN" },
 *   },
 * );
 * ```
 *
 * @resource
 * @category Composer
 */
export const EnvironmentsUserWorkloadsConfigMap = Resource<EnvironmentsUserWorkloadsConfigMap>(
  "GCP.Composer.EnvironmentsUserWorkloadsConfigMap",
);

export class EnvironmentsUserWorkloadsConfigMapNotResolved extends Data.TaggedError(
  "GCP.Composer.EnvironmentsUserWorkloadsConfigMapNotResolved",
)<{
  resourceName: string;
}> {}

export class EnvironmentsUserWorkloadsConfigMapStillExists extends Data.TaggedError(
  "GCP.Composer.EnvironmentsUserWorkloadsConfigMapStillExists",
)<{
  resourceName: string;
}> {}

const resourceName = (environmentName: string, configMapId: string) =>
  `${environmentParent(environmentName)}/userWorkloadsConfigMaps/${configMapId}`;

const toAttrs = (configMap: composer.UserWorkloadsConfigMap, environmentName: string) => {
  const name = configMap.name ?? resourceName(environmentName, "");
  const parsed = parseWorkloadName(name);
  const parent = environmentParent(environmentName || name);
  return {
    name,
    configMapId: parsed.configMapId ?? lastSegment(name),
    environmentName: parent,
    project: parsed.project,
    location: parsed.location,
    environmentId: parsed.environmentId,
    data: mapOf(configMap.data),
  };
};

const getByName = (name: string) =>
  composer
    .getProjectsLocationsEnvironmentsUserWorkloadsConfigMaps({ name })
    .pipe(Effect.catchTag("NotFound", () => Effect.undefined));

const waitUntilGone = (name: string) =>
  getByName(name).pipe(
    Effect.flatMap((current) =>
      current === undefined
        ? Effect.void
        : Effect.fail(new EnvironmentsUserWorkloadsConfigMapStillExists({ resourceName: name })),
    ),
    Effect.retry({
      while: (error) => error._tag === "GCP.Composer.EnvironmentsUserWorkloadsConfigMapStillExists",
      times: 8,
      schedule: Schedule.spaced("2 seconds"),
    }),
  );

export const EnvironmentsUserWorkloadsConfigMapProvider = () =>
  Provider.succeed(EnvironmentsUserWorkloadsConfigMap, {
    stables: ["name", "configMapId", "environmentName", "project", "location", "environmentId"],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const previousId = olds?.configMapId ?? output?.configMapId;
      const idChanged =
        previousId !== undefined &&
        news.configMapId !== undefined &&
        news.configMapId !== previousId;
      const previousParent = olds?.environmentName ?? output?.environmentName;
      const parentChanged =
        previousParent !== undefined &&
        environmentParent(news.environmentName) !== environmentParent(previousParent);
      if (!idChanged && !parentChanged) return undefined;
      return { action: "replace" as const, deleteFirst: false };
    }),

    read: Effect.fn(function* ({ id, olds, output }) {
      const environmentName = olds?.environmentName ?? output?.environmentName;
      if (environmentName === undefined) return undefined;
      const configMapId = yield* toPhysicalId(id, olds?.configMapId, output?.configMapId);
      const name = output?.name ?? resourceName(environmentName, configMapId);
      const existing = yield* getByName(name);
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, environmentName);
      // No labels: a generated id embeds stack/stage/id, and a row we
      // created is in state. Only an explicit id found without state is
      // ambiguous.
      return output === undefined && olds?.configMapId !== undefined ? Unowned(attrs) : attrs;
    }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const configMapId = yield* toPhysicalId(id, news.configMapId, output?.configMapId);
      const parent = environmentParent(news.environmentName);
      const name = resourceName(parent, configMapId);
      const desiredData = mapOf(news.data);

      let current = yield* getByName(output?.name ?? name);

      if (current === undefined) {
        const created = yield* composer
          .createProjectsLocationsEnvironmentsUserWorkloadsConfigMaps({
            parent,
            body: {
              name,
              data: desiredData,
            },
          })
          .pipe(Effect.catchTag("Conflict", () => getByName(name)));
        current = created ?? undefined;
      }

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

      if (dataKey(current.data) !== dataKey(desiredData)) {
        current = yield* composer.updateProjectsLocationsEnvironmentsUserWorkloadsConfigMaps({
          name: current.name ?? name,
          body: {
            name: current.name ?? name,
            data: desiredData,
          },
        });
      }

      return toAttrs(current, parent);
    }),

    delete: Effect.fn(function* ({ output }) {
      yield* composer
        .deleteProjectsLocationsEnvironmentsUserWorkloadsConfigMaps({
          name: output.name,
        })
        .pipe(
          Effect.catchTag("NotFound", () => Effect.void),
          Effect.retry({
            while: (error) => error._tag === "Conflict",
            times: 8,
            schedule: Schedule.spaced("2 seconds"),
          }),
        );
      yield* waitUntilGone(output.name);
    }),
  });