sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Scheduler/ ScheduleGroup.ts

import * as scheduler from "@distilled.cloud/aws/scheduler";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, createTagsList, diffTags, hasTags, tagRecord } from "alchemy/Tags";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";

export class ScheduleGroupConflict extends Data.TaggedError("ScheduleGroupConflict")<{
  readonly message: string;
  readonly cause?: unknown;
}> {}

export class ScheduleGroupUnexpectedResponse extends Data.TaggedError(
  "ScheduleGroupUnexpectedResponse",
)<{
  readonly message: string;
  readonly cause?: unknown;
}> {}

export interface ScheduleGroupProps {
  /**
   * Schedule group name. If omitted, Alchemy generates a deterministic name.
   */
  name?: string;
  /**
   * User-defined tags for the schedule group.
   */
  tags?: Record<string, string>;
}

/**
 * An EventBridge Scheduler schedule group.
 *
 * Schedule groups provide a namespace for schedules so higher-level helpers can
 * organize recurring jobs separately from one-shot or operational schedules.
 * ### Creating Schedule Groups
 * **Example:** Basic Group
 * ```typescript
 * const group = yield* ScheduleGroup("Operations", {
 *   tags: {
 *     domain: "ops",
 *   },
 * });
 * ```
 *
 * @resource
 */
export interface ScheduleGroup extends Resource<
  "AWS.Scheduler.ScheduleGroup",
  ScheduleGroupProps,
  {
    /**
     * ARN of the schedule group.
     */
    scheduleGroupArn: string;
    /**
     * Name of the schedule group.
     */
    scheduleGroupName: string;
    /**
     * Current state of the schedule group (`ACTIVE` or `DELETING`).
     */
    state: string | undefined;
    /**
     * Tags on the schedule group, as observed. Lets `alchemy drift` detect
     * out-of-band changes.
     */
    tags?: Record<string, string>;
  },
  never,
  Providers
> {}

export const ScheduleGroup = Resource<ScheduleGroup>("AWS.Scheduler.ScheduleGroup");

export const ScheduleGroupProvider = () =>
  Provider.effect(
    ScheduleGroup,
    Effect.gen(function* () {
      const toName = (id: string, props: ScheduleGroupProps) =>
        props.name ? Effect.succeed(props.name) : createPhysicalName({ id, maxLength: 64 });

      return {
        stables: ["scheduleGroupArn", "scheduleGroupName"],
        diff: Effect.fn(function* ({ id, olds, news }) {
          if (!isResolved(news)) return undefined;
          if ((yield* toName(id, olds)) !== (yield* toName(id, news as ScheduleGroupProps))) {
            return { action: "replace" } as const;
          }
        }),
        read: Effect.fn(function* ({ id, olds, output }) {
          const scheduleGroupName = output?.scheduleGroupName ?? (yield* toName(id, olds));
          const described = yield* scheduler
            .getScheduleGroup({
              Name: scheduleGroupName,
            })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));

          if (!described?.Arn || !described.Name) {
            return undefined;
          }

          const { Tags } = yield* scheduler
            .listTagsForResource({ ResourceArn: described.Arn })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.succeed({ Tags: [] })));
          return {
            scheduleGroupArn: described.Arn,
            scheduleGroupName: described.Name,
            state: described.State,
            tags: tagRecord(Tags),
          };
        }),
        reconcile: Effect.fn(function* ({ id, news, output, session }) {
          const scheduleGroupName = output?.scheduleGroupName ?? (yield* toName(id, news));
          const internalTags = yield* createInternalTags(id);
          const desiredTags = { ...internalTags, ...news.tags };

          // Observe — fetch live group; gracefully handle missing.
          let observed = yield* scheduler
            .getScheduleGroup({ Name: scheduleGroupName })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));

          // Ensure — create if missing. Tolerate `ConflictException` as a
          // race or adoption case: verify ownership via tags before
          // continuing.
          if (!observed?.Arn) {
            yield* scheduler
              .createScheduleGroup({
                Name: scheduleGroupName,
                Tags: createTagsList(desiredTags),
              })
              .pipe(
                Effect.catchTag("ConflictException", () =>
                  scheduler.getScheduleGroup({ Name: scheduleGroupName }).pipe(
                    Effect.flatMap((existing) =>
                      existing.Arn
                        ? scheduler.listTagsForResource({ ResourceArn: existing.Arn }).pipe(
                            Effect.filterOrFail(
                              ({ Tags }) => hasTags(internalTags, Tags),
                              () =>
                                new ScheduleGroupConflict({
                                  message: `ScheduleGroup '${scheduleGroupName}' already exists and is not managed by alchemy`,
                                }),
                            ),
                            Effect.asVoid,
                          )
                        : Effect.fail(
                            new ScheduleGroupConflict({
                              message: `ScheduleGroup '${scheduleGroupName}' already exists but could not be described`,
                            }),
                          ),
                    ),
                  ),
                ),
              );
            observed = yield* scheduler
              .getScheduleGroup({ Name: scheduleGroupName })
              .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
          }

          if (!observed?.Arn) {
            return yield* new ScheduleGroupUnexpectedResponse({
              message: `Failed to read created ScheduleGroup '${scheduleGroupName}'`,
            });
          }

          const groupArn = observed.Arn;

          // Sync tags — diff observed cloud tags against desired so
          // adoption rewrites ownership tags.
          const observedTagsResp = yield* scheduler
            .listTagsForResource({ ResourceArn: groupArn })
            .pipe(
              Effect.catchTag("ResourceNotFoundException", () =>
                Effect.succeed({ Tags: [] as scheduler.Tag[] }),
              ),
            );
          const observedTags = Object.fromEntries(
            (observedTagsResp.Tags ?? []).map((t) => [t.Key, t.Value]),
          );
          const { removed, upsert } = diffTags(observedTags, desiredTags);

          if (removed.length > 0) {
            yield* scheduler.untagResource({
              ResourceArn: groupArn,
              TagKeys: removed,
            });
          }
          if (upsert.length > 0) {
            yield* scheduler.tagResource({
              ResourceArn: groupArn,
              Tags: upsert,
            });
          }

          yield* session.note(groupArn);

          return {
            scheduleGroupArn: groupArn,
            scheduleGroupName,
            state: observed?.State,
            tags: desiredTags,
          };
        }),
        list: () =>
          Effect.gen(function* () {
            // Enumerate every schedule group in the account/region,
            // paginated.
            const summaries = yield* scheduler.listScheduleGroups.pages({}).pipe(
              Stream.runCollect,
              Effect.map((chunk) =>
                Array.from(chunk).flatMap((page) =>
                  (page.ScheduleGroups ?? []).filter(
                    (
                      g,
                    ): g is scheduler.ScheduleGroupSummary & {
                      Name: string;
                    } => g.Name != null,
                  ),
                ),
              ),
            );

            // Hydrate each summary via GetScheduleGroup into the exact
            // `read` shape. Skip groups deleted between list and get.
            const rows = yield* Effect.forEach(
              summaries,
              (summary) =>
                scheduler.getScheduleGroup({ Name: summary.Name }).pipe(
                  Effect.map((described) =>
                    described.Arn && described.Name
                      ? {
                          scheduleGroupArn: described.Arn,
                          scheduleGroupName: described.Name,
                          state: described.State,
                        }
                      : undefined,
                  ),
                  Effect.catchTag("ResourceNotFoundException", () => Effect.undefined),
                ),
              { concurrency: 10 },
            );

            return rows.filter((row): row is ScheduleGroup["Attributes"] => row !== undefined);
          }),
        delete: Effect.fn(function* ({ output }) {
          yield* scheduler
            .deleteScheduleGroup({
              Name: output.scheduleGroupName,
            })
            .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.void));
        }),
      };
    }),
  );