alchemy-effect 0.6.0 → 0.6.2

package/src/AWS/Assets.ts

@@ -0,0 +1,182 @@
+import type { Credentials } from "@distilled.cloud/aws/Credentials";
+import { Region } from "@distilled.cloud/aws/Region";
+import * as s3 from "@distilled.cloud/aws/s3";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ServiceMap from "effect/ServiceMap";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+
+import { lookupAssetsBucket } from "./Bootstrap.ts";
+
+/**
+ * Error type for Assets service operations.
+ */
+export type AssetsError =
+  | {
+      readonly _tag: "AssetsUploadError";
+      readonly message: string;
+      readonly cause?: unknown;
+    }
+  | {
+      readonly _tag: "AssetsCheckError";
+      readonly message: string;
+      readonly cause?: unknown;
+    };
+
+/**
+ * Requirements for Assets operations (S3 operations need these).
+ */
+export type AssetsRequirements = Region | Credentials | HttpClient;
+
+export class Assets extends ServiceMap.Service<
+  Assets,
+  {
+    /**
+     * The name of the assets bucket.
+     */
+    readonly bucketName: string;
+
+    /**
+     * Upload an asset to the assets bucket.
+     * Uses content-addressed storage: `lambda/{hash}.zip`
+     *
+     * @param hash - The content hash of the asset
+     * @param content - The asset content (zip file)
+     * @returns The S3 key where the asset was uploaded
+     */
+    readonly uploadAsset: (
+      hash: string,
+      content: Uint8Array,
+    ) => Effect.Effect<string, AssetsError, AssetsRequirements>;
+
+    /**
+     * Check if an asset already exists in the assets bucket.
+     *
+     * @param hash - The content hash to check
+     * @returns true if the asset exists
+     */
+    readonly hasAsset: (
+      hash: string,
+    ) => Effect.Effect<boolean, AssetsError, AssetsRequirements>;
+  }
+>()("AWS::Assets") {}
+
+/**
+ * S3 key prefix for Lambda function code assets.
+ */
+const LAMBDA_PREFIX = "lambda";
+
+/**
+ * Generate the S3 key for a Lambda asset.
+ */
+const getLambdaAssetKey = (hash: string) => `${LAMBDA_PREFIX}/${hash}.zip`;
+
+/**
+ * Look up the assets bucket by scanning for the bootstrap tags.
+ * Returns Option.some(bucketName) if found, Option.none() otherwise.
+ */
+export { lookupAssetsBucket };
+
+/**
+ * Create the Assets service implementation for a given bucket.
+ */
+const createAssetsService = (bucketName: string): typeof Assets.Service => ({
+  bucketName,
+  uploadAsset: (hash: string, content: Uint8Array) => {
+    const key = getLambdaAssetKey(hash);
+
+    return Effect.gen(function* () {
+      // Check if asset already exists
+      const exists = yield* s3
+        .headObject({ Bucket: bucketName, Key: key })
+        .pipe(
+          Effect.map(() => true),
+          Effect.catchTag("NotFound", () => Effect.succeed(false)),
+        );
+
+      if (exists) {
+        yield* Effect.logDebug(
+          `Asset already exists: s3://${bucketName}/${key}`,
+        );
+        return key;
+      }
+
+      // Upload the asset
+      yield* s3.putObject({
+        Bucket: bucketName,
+        Key: key,
+        Body: content,
+        ContentType: "application/zip",
+      });
+
+      yield* Effect.logDebug(`Uploaded asset: s3://${bucketName}/${key}`);
+      return key;
+    }).pipe(
+      Effect.mapError(
+        (err): AssetsError => ({
+          _tag: "AssetsUploadError",
+          message: `Failed to upload asset ${key}`,
+          cause: err,
+        }),
+      ),
+    );
+  },
+  hasAsset: (hash: string) => {
+    const key = getLambdaAssetKey(hash);
+
+    return s3.headObject({ Bucket: bucketName, Key: key }).pipe(
+      Effect.map(() => true),
+      Effect.catchTag("NotFound", () => Effect.succeed(false)),
+      Effect.mapError(
+        (err): AssetsError => ({
+          _tag: "AssetsCheckError",
+          message: `Failed to check asset ${key}`,
+          cause: err,
+        }),
+      ),
+    );
+  },
+});
+
+/**
+ * Layer that provides the Assets service.
+ * Looks up the assets bucket on initialization.
+ * If the bucket doesn't exist, the layer will fail - use `assetsLayerWithFallback` for graceful fallback.
+ */
+export const assetsLayer = Layer.effect(
+  Assets,
+  Effect.gen(function* () {
+    const maybeBucket = yield* lookupAssetsBucket;
+
+    if (Option.isNone(maybeBucket)) {
+      return yield* Effect.fail(
+        new Error(
+          "Assets bucket not found. Run 'alchemy-effect bootstrap' to create it.",
+        ),
+      );
+    }
+
+    return createAssetsService(maybeBucket.value);
+  }),
+);
+
+/**
+ * Try to create the assets layer, but don't fail if the bucket doesn't exist.
+ * Returns Layer.empty if the bucket is not found.
+ */
+export const AssetsProvider = () =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const maybeBucket = yield* lookupAssetsBucket;
+
+      if (Option.isNone(maybeBucket)) {
+        yield* Effect.logDebug(
+          "Assets bucket not found. Lambda will use inline ZipFile deployment.",
+        );
+        return Layer.empty;
+      }
+
+      return Layer.succeed(Assets, createAssetsService(maybeBucket.value));
+    }),
+  );

package/src/AWS/AutoScaling/AutoScalingGroup.ts

@@ -0,0 +1,440 @@
+import * as autoscaling from "@distilled.cloud/aws/auto-scaling";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import { deepEqual, isResolved } from "../../Diff.ts";
+import type { Input } from "../../Input.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import { Resource } from "../../Resource.ts";
+import { createInternalTags, diffTags } from "../../Tags.ts";
+import type { SubnetId } from "../EC2/Subnet.ts";
+import type {
+  LaunchTemplateId,
+  LaunchTemplateName,
+  LaunchTemplate as LaunchTemplateResource,
+} from "./LaunchTemplate.ts";
+
+export type AutoScalingGroupName = string;
+
+export interface LaunchTemplateReference {
+  launchTemplateId?: Input<LaunchTemplateId>;
+  launchTemplateName?: Input<LaunchTemplateName>;
+  version?: Input<string | number>;
+}
+
+export interface AutoScalingGroupProps {
+  /**
+   * Auto Scaling Group name. If omitted, a deterministic name is generated.
+   */
+  autoScalingGroupName?: string;
+  /**
+   * Launch template used for instances in the fleet.
+   */
+  launchTemplate: Input<LaunchTemplateReference> | LaunchTemplateResource;
+  /**
+   * Subnets to place the fleet into.
+   */
+  subnetIds: Input<SubnetId[]>;
+  /**
+   * Minimum number of instances.
+   */
+  minSize: number;
+  /**
+   * Maximum number of instances.
+   */
+  maxSize: number;
+  /**
+   * Desired number of instances.
+   * @default minSize
+   */
+  desiredCapacity?: number;
+  /**
+   * Target groups to attach to the fleet.
+   */
+  targetGroupArns?: Input<string[]>;
+  /**
+   * Health check type.
+   * @default "ELB" when target groups are present, otherwise "EC2"
+   */
+  healthCheckType?: "EC2" | "ELB";
+  /**
+   * Grace period in seconds before health checks start.
+   */
+  healthCheckGracePeriod?: number;
+  /**
+   * Default cooldown in seconds.
+   */
+  defaultCooldown?: number;
+  /**
+   * Termination policies for scale-in.
+   */
+  terminationPolicies?: string[];
+  /**
+   * Tags to apply to the Auto Scaling Group itself.
+   */
+  tags?: Record<string, string>;
+}
+
+export interface AutoScalingGroup extends Resource<
+  "AWS.AutoScaling.AutoScalingGroup",
+  AutoScalingGroupProps,
+  {
+    autoScalingGroupArn: string;
+    autoScalingGroupName: AutoScalingGroupName;
+    launchTemplateId?: string;
+    launchTemplateName?: string;
+    launchTemplateVersion?: string;
+    subnetIds: string[];
+    minSize: number;
+    maxSize: number;
+    desiredCapacity: number;
+    targetGroupArns: string[];
+    healthCheckType?: string;
+    healthCheckGracePeriod?: number;
+    defaultCooldown?: number;
+    terminationPolicies?: string[];
+    tags: Record<string, string>;
+  }
+> {}
+
+/**
+ * An EC2 Auto Scaling Group that manages a fleet of instances from a launch
+ * template and can register that fleet with one or more load balancer target
+ * groups.
+ */
+export const AutoScalingGroup = Resource<AutoScalingGroup>(
+  "AWS.AutoScaling.AutoScalingGroup",
+);
+
+const isLaunchTemplateResource = (
+  value: unknown,
+): value is LaunchTemplateResource =>
+  typeof value === "object" &&
+  value !== null &&
+  "Type" in value &&
+  (value as { Type?: string }).Type === "AWS.AutoScaling.LaunchTemplate";
+
+const sortStrings = (values: readonly string[] = []) =>
+  [...values].sort((a, b) => a.localeCompare(b));
+
+export const AutoScalingGroupProvider = () =>
+  AutoScalingGroup.provider.effect(
+    Effect.gen(function* () {
+      const toName = (
+        id: string,
+        props: { autoScalingGroupName?: string } = {},
+      ) =>
+        props.autoScalingGroupName
+          ? Effect.succeed(props.autoScalingGroupName)
+          : createPhysicalName({ id, maxLength: 255, lowercase: true });
+
+      const toLaunchTemplateSpec = (
+        input: AutoScalingGroupProps["launchTemplate"],
+      ) => {
+        const spec = isLaunchTemplateResource(input)
+          ? {
+              launchTemplateId: input.launchTemplateId,
+              launchTemplateName: input.launchTemplateName,
+              version: input.defaultVersionNumber,
+            }
+          : ((input ?? {}) as LaunchTemplateReference);
+
+        return {
+          LaunchTemplateId: spec.launchTemplateId as string | undefined,
+          LaunchTemplateName: spec.launchTemplateName as string | undefined,
+          Version:
+            spec.version === undefined ? "$Default" : String(spec.version),
+        };
+      };
+
+      const describeGroup = (autoScalingGroupName: string) =>
+        autoscaling
+          .describeAutoScalingGroups({
+            AutoScalingGroupNames: [autoScalingGroupName],
+          })
+          .pipe(Effect.map((result) => result.AutoScalingGroups?.[0]));
+
+      const toTags = (name: string, tags: Record<string, string>) =>
+        Object.entries(tags).map(([Key, Value]) => ({
+          ResourceId: name,
+          ResourceType: "auto-scaling-group",
+          Key,
+          Value,
+          PropagateAtLaunch: false,
+        }));
+
+      const syncTargetGroups = Effect.fn(function* ({
+        autoScalingGroupName,
+        oldTargetGroupArns,
+        newTargetGroupArns,
+      }: {
+        autoScalingGroupName: string;
+        oldTargetGroupArns: string[];
+        newTargetGroupArns: string[];
+      }) {
+        const oldSet = new Set(oldTargetGroupArns);
+        const newSet = new Set(newTargetGroupArns);
+
+        const detached = oldTargetGroupArns.filter((arn) => !newSet.has(arn));
+        const attached = newTargetGroupArns.filter((arn) => !oldSet.has(arn));
+
+        if (detached.length > 0) {
+          yield* autoscaling.detachLoadBalancerTargetGroups({
+            AutoScalingGroupName: autoScalingGroupName,
+            TargetGroupARNs: detached,
+          } as any);
+        }
+
+        if (attached.length > 0) {
+          yield* autoscaling.attachLoadBalancerTargetGroups({
+            AutoScalingGroupName: autoScalingGroupName,
+            TargetGroupARNs: attached,
+          } as any);
+        }
+      });
+
+      const syncTags = Effect.fn(function* ({
+        autoScalingGroupName,
+        oldTags,
+        newTags,
+      }: {
+        autoScalingGroupName: string;
+        oldTags: Record<string, string>;
+        newTags: Record<string, string>;
+      }) {
+        const { removed, upsert } = diffTags(oldTags, newTags);
+
+        if (removed.length > 0) {
+          yield* autoscaling.deleteTags({
+            Tags: removed.map((Key) => ({
+              ResourceId: autoScalingGroupName,
+              ResourceType: "auto-scaling-group",
+              Key,
+            })),
+          } as any);
+        }
+
+        if (upsert.length > 0) {
+          yield* autoscaling.createOrUpdateTags({
+            Tags: upsert.map(({ Key, Value }) => ({
+              ResourceId: autoScalingGroupName,
+              ResourceType: "auto-scaling-group",
+              Key,
+              Value,
+              PropagateAtLaunch: false,
+            })),
+          } as any);
+        }
+      });
+
+      const toAttributes = (
+        group: autoscaling.AutoScalingGroup,
+      ): AutoScalingGroup["Attributes"] => ({
+        autoScalingGroupArn: group.AutoScalingGroupARN!,
+        autoScalingGroupName: group.AutoScalingGroupName!,
+        launchTemplateId: group.LaunchTemplate?.LaunchTemplateId,
+        launchTemplateName: group.LaunchTemplate?.LaunchTemplateName,
+        launchTemplateVersion: group.LaunchTemplate?.Version,
+        subnetIds: String(group.VPCZoneIdentifier ?? "")
+          .split(",")
+          .filter(Boolean),
+        minSize: group.MinSize ?? 0,
+        maxSize: group.MaxSize ?? 0,
+        desiredCapacity: group.DesiredCapacity ?? 0,
+        targetGroupArns: sortStrings(group.TargetGroupARNs ?? []),
+        healthCheckType: group.HealthCheckType,
+        healthCheckGracePeriod: group.HealthCheckGracePeriod,
+        defaultCooldown: group.DefaultCooldown,
+        terminationPolicies: group.TerminationPolicies ?? [],
+        tags: Object.fromEntries(
+          (group.Tags ?? [])
+            .filter((tag): tag is { Key: string; Value: string } =>
+              Boolean(tag.Key && tag.Value !== undefined),
+            )
+            .map((tag) => [tag.Key, tag.Value]),
+        ),
+      });
+
+      return {
+        stables: ["autoScalingGroupArn", "autoScalingGroupName"],
+        diff: Effect.fn(function* ({ id, olds, news: _news }) {
+          if (!isResolved(_news)) return undefined;
+          const news = _news as typeof olds;
+          const oldName = yield* toName(id, olds ?? {});
+          const newName = yield* toName(id, news ?? {});
+          if (oldName !== newName) {
+            return { action: "replace", deleteFirst: true } as const;
+          }
+
+          if (!deepEqual(olds, news)) {
+            return {
+              action: "update",
+              stables: ["autoScalingGroupArn", "autoScalingGroupName"],
+            } as const;
+          }
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const name =
+            output?.autoScalingGroupName ?? (yield* toName(id, olds ?? {}));
+          const group = yield* describeGroup(name);
+          return group ? toAttributes(group) : undefined;
+        }),
+        create: Effect.fn(function* ({ id, news, output, session }) {
+          const autoScalingGroupName = yield* toName(id, news);
+          const tags = {
+            ...(yield* createInternalTags(id)),
+            ...news.tags,
+          };
+          const targetGroupArns = sortStrings(
+            (news.targetGroupArns ?? []) as string[],
+          );
+          const launchTemplate = toLaunchTemplateSpec(news.launchTemplate);
+          const existing =
+            output?.autoScalingGroupName === autoScalingGroupName
+              ? yield* describeGroup(autoScalingGroupName)
+              : yield* describeGroup(autoScalingGroupName);
+
+          if (!existing) {
+            yield* autoscaling.createAutoScalingGroup({
+              AutoScalingGroupName: autoScalingGroupName,
+              MinSize: news.minSize,
+              MaxSize: news.maxSize,
+              DesiredCapacity: news.desiredCapacity ?? news.minSize,
+              LaunchTemplate: launchTemplate,
+              VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
+              TargetGroupARNs: targetGroupArns,
+              HealthCheckType:
+                news.healthCheckType ??
+                (targetGroupArns.length > 0 ? "ELB" : "EC2"),
+              HealthCheckGracePeriod: news.healthCheckGracePeriod,
+              DefaultCooldown: news.defaultCooldown,
+              TerminationPolicies: news.terminationPolicies,
+              Tags: toTags(autoScalingGroupName, tags),
+            } as any);
+          } else {
+            yield* autoscaling.updateAutoScalingGroup({
+              AutoScalingGroupName: autoScalingGroupName,
+              MinSize: news.minSize,
+              MaxSize: news.maxSize,
+              DesiredCapacity: news.desiredCapacity ?? news.minSize,
+              LaunchTemplate: launchTemplate,
+              VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
+              HealthCheckType:
+                news.healthCheckType ??
+                (targetGroupArns.length > 0 ? "ELB" : "EC2"),
+              HealthCheckGracePeriod: news.healthCheckGracePeriod,
+              DefaultCooldown: news.defaultCooldown,
+              TerminationPolicies: news.terminationPolicies,
+            } as any);
+            yield* syncTargetGroups({
+              autoScalingGroupName,
+              oldTargetGroupArns: sortStrings(existing.TargetGroupARNs ?? []),
+              newTargetGroupArns: targetGroupArns,
+            });
+            yield* syncTags({
+              autoScalingGroupName,
+              oldTags: toAttributes(existing).tags,
+              newTags: tags,
+            });
+          }
+
+          const group = yield* describeGroup(autoScalingGroupName).pipe(
+            Effect.filterOrFail(
+              Boolean,
+              () =>
+                new Error(
+                  `Auto Scaling Group '${autoScalingGroupName}' was not readable after create`,
+                ),
+            ),
+            Effect.retry({
+              while: () => true,
+              schedule: Schedule.recurs(8).pipe(
+                Schedule.compose(Schedule.exponential("250 millis")),
+              ),
+            }),
+          );
+
+          yield* session.note(autoScalingGroupName);
+          return toAttributes(group);
+        }),
+        update: Effect.fn(function* ({ id, news, olds, output, session }) {
+          const tags = {
+            ...(yield* createInternalTags(id)),
+            ...news.tags,
+          };
+          const oldTags = {
+            ...(yield* createInternalTags(id)),
+            ...olds.tags,
+          };
+          const targetGroupArns = sortStrings(
+            (news.targetGroupArns ?? []) as string[],
+          );
+
+          yield* autoscaling.updateAutoScalingGroup({
+            AutoScalingGroupName: output.autoScalingGroupName,
+            MinSize: news.minSize,
+            MaxSize: news.maxSize,
+            DesiredCapacity: news.desiredCapacity ?? news.minSize,
+            LaunchTemplate: toLaunchTemplateSpec(news.launchTemplate),
+            VPCZoneIdentifier: (news.subnetIds as string[]).join(","),
+            HealthCheckType:
+              news.healthCheckType ??
+              (targetGroupArns.length > 0 ? "ELB" : "EC2"),
+            HealthCheckGracePeriod: news.healthCheckGracePeriod,
+            DefaultCooldown: news.defaultCooldown,
+            TerminationPolicies: news.terminationPolicies,
+          } as any);
+
+          yield* syncTargetGroups({
+            autoScalingGroupName: output.autoScalingGroupName,
+            oldTargetGroupArns: sortStrings(
+              (olds.targetGroupArns ?? []) as string[],
+            ),
+            newTargetGroupArns: targetGroupArns,
+          });
+          yield* syncTags({
+            autoScalingGroupName: output.autoScalingGroupName,
+            oldTags,
+            newTags: tags,
+          });
+
+          const group = yield* describeGroup(output.autoScalingGroupName).pipe(
+            Effect.filterOrFail(
+              Boolean,
+              () =>
+                new Error(
+                  `Auto Scaling Group '${output.autoScalingGroupName}' was not readable after update`,
+                ),
+            ),
+          );
+          yield* session.note(output.autoScalingGroupName);
+          return toAttributes(group);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          const existing = yield* describeGroup(output.autoScalingGroupName);
+          if (!existing) {
+            return;
+          }
+
+          yield* autoscaling.deleteAutoScalingGroup({
+            AutoScalingGroupName: output.autoScalingGroupName,
+            ForceDelete: true,
+          } as any);
+
+          yield* describeGroup(output.autoScalingGroupName).pipe(
+            Effect.flatMap((group) =>
+              group
+                ? Effect.fail(new Error("AutoScalingGroupStillExists"))
+                : Effect.void,
+            ),
+            Effect.retry({
+              while: (error) =>
+                (error as Error).message === "AutoScalingGroupStillExists",
+              schedule: Schedule.recurs(12).pipe(
+                Schedule.compose(Schedule.exponential("250 millis")),
+              ),
+            }),
+          );
+        }),
+      };
+    }),
+  );