sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ AppRunner/ AutoScalingConfiguration.ts

import * as apprunner from "@distilled.cloud/aws/apprunner";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";
import { isActiveStatus, readAppRunnerTags, syncAppRunnerTags, toWireTags } from "./internal.ts";

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

/**
 * Derive the revision-less "name partial" ARN
 * (`...:autoscalingconfiguration/{name}`) from any configuration ARN.
 * `DeleteAllRevisions` rejects revision-qualified ARNs (observed live:
 * "You cannot specify full auto scaling configuration ARN and
 * DeleteAllRevisions as true at same time").
 */
const toNamePartialArn = (arn: string): string =>
  // "arn:...:autoscalingconfiguration/{name}/{revision}/{uuid}" -> keep
  // everything up to and including {name}.
  arn.split("/").slice(0, 2).join("/");

export interface AutoScalingConfigurationProps {
  /**
   * Name of the auto scaling configuration. Must be 4-32 characters
   * (letters, digits, hyphens, underscores). If omitted, a deterministic
   * physical name is generated. Changing the name replaces the
   * configuration (all revisions of the old name are deleted).
   */
  autoScalingConfigurationName?: string;
  /**
   * Maximum number of concurrent requests an instance processes before
   * App Runner scales up.
   * @default 100
   */
  maxConcurrency?: number;
  /**
   * Minimum number of provisioned (warm) instances. Higher values spread
   * the service over more Availability Zones at a higher minimal cost.
   * @default 1
   */
  minSize?: number;
  /**
   * Maximum number of instances the service scales up to.
   * @default 25
   */
  maxSize?: number;
  /**
   * User-defined tags for the configuration.
   */
  tags?: Record<string, string>;
}

export interface AutoScalingConfiguration extends Resource<
  "AWS.AppRunner.AutoScalingConfiguration",
  AutoScalingConfigurationProps,
  {
    /**
     * Name of the auto scaling configuration.
     */
    autoScalingConfigurationName: string;
    /**
     * ARN of this auto scaling configuration revision.
     */
    autoScalingConfigurationArn: string;
    /**
     * Revision number of the configuration (revisions are immutable).
     */
    autoScalingConfigurationRevision: number;
    /**
     * Maximum concurrent requests per instance before scaling out.
     */
    maxConcurrency: number | undefined;
    /**
     * Minimum number of provisioned instances.
     */
    minSize: number | undefined;
    /**
     * Maximum number of instances the service may scale out to.
     */
    maxSize: number | undefined;
  },
  never,
  Providers
> {}

/**
 * An AWS App Runner auto scaling configuration.
 *
 * Auto scaling configurations are immutable revisions: changing
 * `maxConcurrency`, `minSize`, or `maxSize` creates a new revision under
 * the same name (the ARN and revision attributes change). A configuration
 * can be shared across multiple App Runner services.
 * ### Creating an Auto Scaling Configuration
 * **Example:** Basic Configuration
 * ```typescript
 * const scaling = yield* AppRunner.AutoScalingConfiguration("Scaling", {
 *   maxConcurrency: 50,
 *   minSize: 1,
 *   maxSize: 3,
 * });
 * ```
 *
 * ### Using with an App Runner Service
 * **Example:** Attach to a Service
 * ```typescript
 * const service = yield* AppRunner.Service("Api", {
 *   imageRepository: {
 *     imageIdentifier: "public.ecr.aws/aws-containers/hello-app-runner:latest",
 *     imageRepositoryType: "ECR_PUBLIC",
 *     port: "8000",
 *   },
 *   autoScalingConfigurationArn: scaling.autoScalingConfigurationArn,
 * });
 * ```
 *
 * @resource
 */
export const AutoScalingConfiguration = Resource<AutoScalingConfiguration>(
  "AWS.AppRunner.AutoScalingConfiguration",
);

export const AutoScalingConfigurationProvider = () =>
  Provider.effect(
    AutoScalingConfiguration,
    Effect.gen(function* () {
      const toName = (id: string, props: AutoScalingConfigurationProps) =>
        props.autoScalingConfigurationName
          ? Effect.succeed(props.autoScalingConfigurationName)
          : createPhysicalName({ id, maxLength: 32 });

      /** Find the latest ACTIVE revision of a configuration by name. */
      const findLatest = Effect.fn(function* (name: string) {
        const page = yield* apprunner.listAutoScalingConfigurations({
          AutoScalingConfigurationName: name,
          LatestOnly: true,
        });
        const summary = (page.AutoScalingConfigurationSummaryList ?? []).find(
          (s) =>
            s.AutoScalingConfigurationName === name &&
            isActiveStatus(s.Status) &&
            s.AutoScalingConfigurationArn !== undefined,
        );
        if (!summary?.AutoScalingConfigurationArn) return undefined;
        const described = yield* apprunner
          .describeAutoScalingConfiguration({
            AutoScalingConfigurationArn: summary.AutoScalingConfigurationArn,
          })
          .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
        const config = described?.AutoScalingConfiguration;
        return config !== undefined && isActiveStatus(config.Status) ? config : undefined;
      });

      const toAttrs = Effect.fn(function* (config: apprunner.AutoScalingConfiguration) {
        if (
          !config.AutoScalingConfigurationName ||
          !config.AutoScalingConfigurationArn ||
          config.AutoScalingConfigurationRevision === undefined
        ) {
          return yield* new AutoScalingConfigurationUnexpectedResponse({
            message: "App Runner auto scaling configuration is missing its name, ARN, or revision",
          });
        }
        return {
          autoScalingConfigurationName: config.AutoScalingConfigurationName,
          autoScalingConfigurationArn: config.AutoScalingConfigurationArn,
          autoScalingConfigurationRevision: config.AutoScalingConfigurationRevision,
          maxConcurrency: config.MaxConcurrency,
          minSize: config.MinSize,
          maxSize: config.MaxSize,
        };
      });

      return {
        stables: ["autoScalingConfigurationName"],

        diff: Effect.fn(function* ({ id, olds, news }) {
          if (!isResolved(news)) return undefined;
          if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
            return { action: "replace" } as const;
          }
        }),

        read: Effect.fn(function* ({ id, olds, output }) {
          const name = output?.autoScalingConfigurationName ?? (yield* toName(id, olds ?? {}));
          const config = yield* findLatest(name);
          if (config === undefined) return undefined;
          const attrs = yield* toAttrs(config);
          const tags = yield* readAppRunnerTags(attrs.autoScalingConfigurationArn);
          return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
        }),

        reconcile: Effect.fn(function* ({ id, news = {}, output, session }) {
          const name = output?.autoScalingConfigurationName ?? (yield* toName(id, news));
          const internalTags = yield* createInternalTags(id);
          const desiredTags = { ...internalTags, ...news.tags };

          // 1. Observe — the latest ACTIVE revision is authoritative.
          let observed = yield* findLatest(name);

          // 2/3. Ensure + sync — scaling settings live on immutable
          // revisions, so a drift on any user-specified field is converged
          // by creating a new revision under the same name. Only compare
          // fields the user actually specified: the service fills in
          // defaults that must not trigger spurious revisions.
          const drifted =
            observed !== undefined &&
            ((news.maxConcurrency !== undefined &&
              news.maxConcurrency !== observed.MaxConcurrency) ||
              (news.minSize !== undefined && news.minSize !== observed.MinSize) ||
              (news.maxSize !== undefined && news.maxSize !== observed.MaxSize));

          if (observed === undefined || drifted) {
            const created = yield* apprunner.createAutoScalingConfiguration({
              AutoScalingConfigurationName: name,
              MaxConcurrency: news.maxConcurrency,
              MinSize: news.minSize,
              MaxSize: news.maxSize,
              Tags: toWireTags(desiredTags),
            });
            observed = created.AutoScalingConfiguration;
          }

          // 3b. Sync tags on the latest revision ARN — diff against
          // OBSERVED cloud tags.
          if (observed.AutoScalingConfigurationArn) {
            yield* syncAppRunnerTags(observed.AutoScalingConfigurationArn, desiredTags);
          }

          // 4. Return fresh attributes.
          yield* session.note(name);
          return yield* toAttrs(observed);
        }),

        delete: Effect.fn(function* ({ output }) {
          // DeleteAllRevisions removes every revision that shares the
          // configuration name; it requires the revision-less name partial
          // ARN. A configuration still referenced by a service (App Runner
          // releases the association asynchronously after the service
          // finishes deleting) rejects with InvalidRequestException —
          // retry through that window (bounded).
          yield* apprunner
            .deleteAutoScalingConfiguration({
              AutoScalingConfigurationArn: toNamePartialArn(output.autoScalingConfigurationArn),
              DeleteAllRevisions: true,
            })
            .pipe(
              Effect.catchTag("ResourceNotFoundException", () => Effect.void),
              Effect.retry({
                while: (e) => e._tag === "InvalidRequestException",
                schedule: Schedule.max([Schedule.fixed("5 seconds"), Schedule.recurs(24)]),
              }),
            );
        }),

        list: () =>
          apprunner.listAutoScalingConfigurations.pages({ LatestOnly: true }).pipe(
            Stream.runCollect,
            Effect.map((chunk) =>
              Array.from(chunk).flatMap((page) =>
                (page.AutoScalingConfigurationSummaryList ?? []).filter(
                  (
                    s,
                  ): s is apprunner.AutoScalingConfigurationSummary & {
                    AutoScalingConfigurationArn: string;
                  } =>
                    isActiveStatus(s.Status) &&
                    s.AutoScalingConfigurationArn !== undefined &&
                    // App Runner ships an AWS-managed `DefaultConfiguration`
                    // revision that always exists and can never be deleted
                    // — keep it out of enumeration for account-wide
                    // teardown (nuke).
                    s.AutoScalingConfigurationName !== "DefaultConfiguration",
                ),
              ),
            ),
            Effect.flatMap(
              Effect.forEach(
                (summary) =>
                  apprunner
                    .describeAutoScalingConfiguration({
                      AutoScalingConfigurationArn: summary.AutoScalingConfigurationArn,
                    })
                    .pipe(
                      Effect.flatMap((r) => toAttrs(r.AutoScalingConfiguration)),
                      // Tolerate a delete race — drop the item.
                      Effect.catchTag("ResourceNotFoundException", () => Effect.undefined),
                    ),
                { concurrency: 4 },
              ),
            ),
            Effect.map((items) => items.filter((item) => item !== undefined)),
          ),
      };
    }),
  );