alchemy 2.0.0-beta.52 → 2.0.0-beta.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.52",
+  "version": "2.0.0-beta.53",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -288,18 +288,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@alchemy.run/node-utils": "0.0.4",
+    "@alchemy.run/node-utils": "0.0.5",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "^0.23.1",
-    "@distilled.cloud/axiom": "^0.23.1",
-    "@distilled.cloud/cloudflare": "^0.23.1",
-    "@distilled.cloud/cloudflare-rolldown-plugin": "0.10.5",
-    "@distilled.cloud/cloudflare-runtime": "0.10.5",
-    "@distilled.cloud/cloudflare-vite-plugin": "0.10.5",
-    "@distilled.cloud/core": "^0.23.1",
-    "@distilled.cloud/neon": "^0.23.1",
-    "@distilled.cloud/planetscale": "^0.23.1",
+    "@distilled.cloud/aws": "^0.24.5",
+    "@distilled.cloud/axiom": "^0.24.5",
+    "@distilled.cloud/cloudflare": "^0.24.5",
+    "@distilled.cloud/cloudflare-rolldown-plugin": "0.10.11",
+    "@distilled.cloud/cloudflare-runtime": "0.10.11",
+    "@distilled.cloud/cloudflare-vite-plugin": "0.10.11",
+    "@distilled.cloud/core": "^0.24.5",
+    "@distilled.cloud/neon": "^0.24.5",
+    "@distilled.cloud/planetscale": "^0.24.5",
     "@effect/vitest": ">=4.0.0-beta.78 || >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
@@ -347,6 +347,7 @@
     "tsdown": "^0.15.4",
     "tsx": "^4.20.6",
     "typescript": "^6.0.3",
+    "uuid": "^14.0.0",
     "ws": "^8.20.0"
   },
   "peerDependencies": {

package/src/AWS/ApiGateway/ApiKey.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
@@ -7,9 +6,10 @@ import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, hasAlchemyTags, tagRecord } from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
 
+import { AWSEnvironment } from "../Environment.ts";
 import { apiKeyArn, syncTags } from "./common.ts";
 
 export interface ApiKeyProps {
@@ -110,8 +110,6 @@ export const ApiKeyProvider = () =>
   Provider.effect(
     ApiKeyResource,
     Effect.gen(function* () {
-      const awsRegion = yield* Region;
-
       return {
         stables: ["id"] as const,
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
@@ -144,6 +142,7 @@ export const ApiKeyProvider = () =>
           };
         }),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
+          const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {
             return yield* Effect.die("ApiKey props were not resolved");
           }
@@ -246,7 +245,7 @@ export const ApiKeyProvider = () =>
           const observedTags = tagRecord(observed.tags);
           if (!deepEqual(observedTags, desiredTags)) {
             yield* syncTags({
-              resourceArn: apiKeyArn(awsRegion, apiKeyId),
+              resourceArn: apiKeyArn(region, apiKeyId),
               oldTags: observedTags,
               newTags: desiredTags,
             });

package/src/AWS/ApiGateway/RestApi.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import { deepEqual, isResolved } from "../../Diff.ts";
@@ -6,9 +5,10 @@ import type { Input } from "../../Input.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, tagRecord } from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
 
+import { AWSEnvironment } from "../Environment.ts";
 import { restApiArn, retryOnApiStatusUpdating, syncTags } from "./common.ts";
 
 export interface RestApiProps {
@@ -299,8 +299,6 @@ export const RestApiProvider = () =>
   Provider.effect(
     RestApi,
     Effect.gen(function* () {
-      const awsRegion = yield* Region;
-
       return {
         stables: ["restApiId", "rootResourceId"] as const,
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
@@ -355,7 +353,7 @@ export const RestApiProvider = () =>
           const news = newsIn as RestApiProps;
           const name = yield* generatedName(id, news);
           const internalTags = yield* createInternalTags(id);
-          const allTags = { ...(news.tags ?? {}), ...internalTags };
+          const allTags = { ...news.tags, ...internalTags };
           const created = yield* retryOnApiStatusUpdating(
             ag.createRestApi({
               name,
@@ -383,6 +381,7 @@ export const RestApiProvider = () =>
           return snapshotFromApi(full);
         }),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
+          const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {
             return yield* Effect.die("RestApi props were not resolved");
           }
@@ -434,7 +433,7 @@ export const RestApiProvider = () =>
           const internalTags = yield* createInternalTags(id);
           const desiredTags = { ...news.tags, ...internalTags };
           if (!deepEqual(observedSnapshot.tags, desiredTags)) {
-            const arn = restApiArn(awsRegion, output.restApiId);
+            const arn = restApiArn(region, output.restApiId);
             yield* syncTags({
               resourceArn: arn,
               oldTags: observedSnapshot.tags,

package/src/AWS/ApiGateway/Stage.ts

@@ -1,13 +1,13 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import type { Input } from "../../Input.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags } from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
 
+import { AWSEnvironment } from "../Environment.ts";
 import type { RestApi } from "./RestApi.ts";
 import { retryOnApiStatusUpdating, stageArn, syncTags } from "./common.ts";
 
@@ -527,8 +527,6 @@ export const StageProvider = () =>
   Provider.effect(
     StageResource,
     Effect.gen(function* () {
-      const awsRegion = yield* Region;
-
       return {
         stables: ["restApiId", "stageName"] as const,
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
@@ -557,6 +555,7 @@ export const StageProvider = () =>
           return snapshotStage(s, output.restApiId, s.stageName);
         }),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
+          const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {
             return yield* Effect.die("Stage props were not resolved");
           }
@@ -626,7 +625,7 @@ export const StageProvider = () =>
 
           // Sync tags — observed ↔ desired.
           if (!deepEqual(observedSnapshot.tags, desiredTags)) {
-            const arn = stageArn(awsRegion, restApiId, stageName);
+            const arn = stageArn(region, restApiId, stageName);
             yield* syncTags({
               resourceArn: arn,
               oldTags: observedSnapshot.tags,

package/src/AWS/ApiGateway/UsagePlan.ts

@@ -1,13 +1,13 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, tagRecord } from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
 
+import { AWSEnvironment } from "../Environment.ts";
 import { syncTags, usagePlanArn } from "./common.ts";
 
 export interface UsagePlanProps {
@@ -234,8 +234,6 @@ export const UsagePlanProvider = () =>
   Provider.effect(
     UsagePlanResource,
     Effect.gen(function* () {
-      const awsRegion = yield* Region;
-
       return {
         stables: ["id"] as const,
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
@@ -266,6 +264,7 @@ export const UsagePlanProvider = () =>
           };
         }),
         reconcile: Effect.fn(function* ({ id, news: newsIn, output, session }) {
+          const { region } = yield* AWSEnvironment.current;
           if (!isResolved(newsIn)) {
             return yield* Effect.die("UsagePlan props were not resolved");
           }
@@ -333,7 +332,7 @@ export const UsagePlanProvider = () =>
           const observedTags = tagRecord(observed.tags);
           if (!deepEqual(observedTags, desiredTags)) {
             yield* syncTags({
-              resourceArn: usagePlanArn(awsRegion, planId),
+              resourceArn: usagePlanArn(region, planId),
               oldTags: observedTags,
               newTags: desiredTags,
             });

package/src/AWS/ApiGateway/VpcLink.ts

@@ -1,4 +1,3 @@
-import { Region } from "@distilled.cloud/aws/Region";
 import * as ag from "@distilled.cloud/aws/api-gateway";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
@@ -6,9 +5,10 @@ import { deepEqual, isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import type { Providers } from "../Providers.ts";
 import { createInternalTags, tagRecord } from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
 
+import { AWSEnvironment } from "../Environment.ts";
 import { syncTags, vpcLinkArn } from "./common.ts";
 
 export interface VpcLinkProps {
@@ -96,8 +96,6 @@ export const VpcLinkProvider = () =>
   Provider.effect(
     VpcLinkResource,
     Effect.gen(function* () {
-      const awsRegion = yield* Region;
-
       return {
         stables: ["vpcLinkId"] as const,
         diff: Effect.fn(function* ({ news: newsIn, olds }) {
@@ -127,7 +125,7 @@ export const VpcLinkProvider = () =>
           const name = yield* generatedName(id, news);
           const internalTags = yield* createInternalTags(id);
           const desiredTags = { ...news.tags, ...internalTags };
-
+          const { region } = yield* AWSEnvironment.current;
           // Observe — fetch the live VPC link if we have a cached id.
           // We never trust `output.description`/etc. for diffing; the
           // observed cloud state drives every sync below.
@@ -186,7 +184,7 @@ export const VpcLinkProvider = () =>
           const observedTags = tagRecord(observed.tags);
           if (!deepEqual(observedTags, desiredTags)) {
             yield* syncTags({
-              resourceArn: vpcLinkArn(awsRegion, vpcLinkId),
+              resourceArn: vpcLinkArn(region, vpcLinkId),
               oldTags: observedTags,
               newTags: desiredTags,
             });

package/src/AWS/Assets.ts

@@ -5,9 +5,14 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
+import { AWSEnvironment } from "./Environment.ts";
 
-import { lookupAssetsBucket } from "./Bootstrap.ts";
+/**
+ * Tag key used to identify the alchemy assets bucket.
+ */
+export const ASSETS_BUCKET_TAG = "alchemy::assets-bucket";
 
 /**
  * Error type for Assets service operations.
@@ -27,7 +32,11 @@ export type AssetsError =
 /**
  * Requirements for Assets operations (S3 operations need these).
  */
-export type AssetsRequirements = Region | Credentials | HttpClient;
+export type AssetsRequirements =
+  | Region
+  | Credentials
+  | HttpClient
+  | AWSEnvironment;
 
 export class Assets extends Context.Service<
   Assets,
@@ -35,7 +44,7 @@ export class Assets extends Context.Service<
     /**
      * The name of the assets bucket.
      */
-    readonly bucketName: string;
+    readonly bucketName: Effect.Effect<string, never, AssetsRequirements>;
 
     /**
      * Upload an asset to the assets bucket.
@@ -60,123 +69,167 @@ export class Assets extends Context.Service<
       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,
-        }),
-      ),
-    );
-  },
-});
+>()("AWS::Assets") {
+  static BucketName = Assets.use((assets) => assets.bucketName);
+}
 
 /**
  * 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(
+export const AssetsLive = 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 bootstrap' to create it.",
-        ),
-      );
-    }
+    const bucketName = yield* lookupAssetsBucket.pipe(
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.die(
+              new Error(
+                "Assets bucket not found. Run 'alchemy aws bootstrap' to create it.",
+              ),
+            ),
+          onSome: (bucketName) => Effect.succeed(bucketName),
+        }),
+      ),
+      Effect.orDie,
+      Effect.cached,
+    );
 
-    return createAssetsService(maybeBucket.value);
+    const getLambdaAssetKey = (hash: string) => `lambda/${hash}.zip`;
+
+    return {
+      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: yield* bucketName, Key: key })
+            .pipe(
+              Effect.map(() => true),
+              Effect.catchTag("NotFound", () => Effect.succeed(false)),
+            );
+
+          if (exists) {
+            yield* Effect.logDebug(
+              `Asset already exists: s3://${yield* bucketName}/${key}`,
+            );
+            return key;
+          }
+
+          // Upload the asset
+          yield* s3.putObject({
+            Bucket: yield* bucketName,
+            Key: key,
+            Body: content,
+            ContentType: "application/zip",
+          });
+
+          yield* Effect.logDebug(
+            `Uploaded asset: s3://${yield* bucketName}/${key}`,
+          );
+          return key;
+        }).pipe(
+          Effect.mapError(
+            (err): AssetsError => ({
+              _tag: "AssetsUploadError",
+              message: `Failed to upload asset ${key}`,
+              cause: err,
+            }),
+          ),
+        );
+      },
+      hasAsset: Effect.fnUntraced(function* (hash: string) {
+        const key = getLambdaAssetKey(hash);
+
+        return yield* s3
+          .headObject({ Bucket: yield* 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,
+              }),
+            ),
+          );
+      }),
+    };
   }),
 );
 
+export const lookupAssetsBuckets = Effect.gen(function* () {
+  const { region } = yield* AWSEnvironment.current;
+
+  return yield* s3.listBuckets
+    .pages({
+      Prefix: "alchemy-assets-",
+      BucketRegion: region,
+    })
+    .pipe(
+      Stream.flatMap((page) => Stream.fromIterable(page.Buckets ?? [])),
+      Stream.filterEffect((bucket) =>
+        bucket.Name === undefined
+          ? Effect.succeed(false)
+          : getBucketTags(bucket.Name).pipe(
+              Effect.map((tags) => hasAssetsBucketTag(tags)),
+              Effect.catch(() => Effect.succeed(false)),
+            ),
+      ),
+      Stream.map((bucket) => bucket.Name!),
+      Stream.runCollect,
+    );
+});
+
+export const lookupAssetsBucket = Effect.gen(function* () {
+  const matchingBuckets = yield* lookupAssetsBuckets;
+  for (const bucketName of matchingBuckets) {
+    return Option.some(bucketName);
+  }
+  return Option.none<string>();
+});
+
+const hasAssetsBucketTag = (tags: Array<{ Key?: string; Value?: string }>) =>
+  tags.some((tag) => tag.Key === ASSETS_BUCKET_TAG && tag.Value === "true");
+
 /**
- * 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.
+ * Build an account-regional namespace bucket name.
+ *
+ * Account-regional buckets must follow the naming convention:
+ *   `<prefix>-<accountId>-<region>-an`
+ *
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/gpbucketnamespaces.html#account-regional-gp-buckets
  */
-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));
-    }),
+export const createAssetsBucketName = (accountId: string, region: string) =>
+  `alchemy-assets-${accountId}-${region}-an`.toLowerCase();
+
+const getBucketTags = (bucketName: string) =>
+  s3.getBucketTagging({ Bucket: bucketName }).pipe(
+    Effect.map((response) => response.TagSet ?? []),
+    Effect.catchTag("NoSuchTagSet", () =>
+      Effect.succeed<Array<{ Key?: string; Value?: string }>>([]),
+    ),
   );
+
+export const ensureAssetsBucketTags = Effect.fn(function* (bucketName: string) {
+  const existingTags = yield* getBucketTags(bucketName);
+  const tagSet = [
+    ...existingTags.filter((tag) => tag.Key !== ASSETS_BUCKET_TAG),
+    { Key: ASSETS_BUCKET_TAG, Value: "true" },
+  ];
+
+  yield* s3.putBucketTagging({
+    Bucket: bucketName,
+    Tagging: {
+      TagSet: tagSet.map((tag) => ({
+        Key: tag.Key!,
+        Value: tag.Value!,
+      })),
+    },
+  });
+});