alchemy 0.1.13 → 0.1.14

package/src/aws/table.ts

@@ -9,6 +9,7 @@ import {
 } from "@aws-sdk/client-dynamodb";
 import { ignore } from "../error";
 import { type Context, Resource } from "../resource";
+import { withExponentialBackoff } from "../utils/retry";
 
 export interface TableProps {
   tableName: string;
@@ -38,7 +39,7 @@ export class Table extends Resource(
   async (
     ctx: Context<TableOutput>,
     props: TableProps,
-  ): Promise<TableOutput> => {
+  ): Promise<TableOutput | void> => {
     const client = new DynamoDBClient({});
 
     if (ctx.event === "delete") {
@@ -70,103 +71,133 @@ export class Table extends Resource(
         }
       }
 
-      return {
-        ...props,
-        id: props.tableName,
-        arn: `arn:aws:dynamodb:${client.config.region}:${process.env.AWS_ACCOUNT_ID}:table/${props.tableName}`,
-        tableId: "",
-      };
+      return;
     } else {
-      try {
-        const attributeDefinitions = [
-          {
-            AttributeName: props.partitionKey.name,
-            AttributeType: props.partitionKey.type,
-          },
-        ];
-
-        const keySchema: KeySchemaElement[] = [
-          {
-            AttributeName: props.partitionKey.name,
-            KeyType: "HASH",
-          },
-        ];
-
-        if (props.sortKey) {
-          attributeDefinitions.push({
-            AttributeName: props.sortKey.name,
-            AttributeType: props.sortKey.type,
-          });
-          keySchema.push({
-            AttributeName: props.sortKey.name,
-            KeyType: "RANGE",
-          });
-        }
+      // Setup for table creation
+      const attributeDefinitions = [
+        {
+          AttributeName: props.partitionKey.name,
+          AttributeType: props.partitionKey.type,
+        },
+      ];
 
-        await client.send(
-          new CreateTableCommand({
-            TableName: props.tableName,
-            AttributeDefinitions: attributeDefinitions,
-            KeySchema: keySchema,
-            BillingMode: props.billingMode || "PAY_PER_REQUEST",
-            ProvisionedThroughput:
-              props.billingMode === "PROVISIONED"
-                ? {
-                    ReadCapacityUnits: props.readCapacity || 5,
-                    WriteCapacityUnits: props.writeCapacity || 5,
-                  }
-                : undefined,
-            Tags: props.tags
-              ? Object.entries(props.tags).map(([Key, Value]) => ({
-                  Key,
-                  Value,
-                }))
-              : undefined,
-          }),
-        );
+      const keySchema: KeySchemaElement[] = [
+        {
+          AttributeName: props.partitionKey.name,
+          KeyType: "HASH",
+        },
+      ];
+
+      if (props.sortKey) {
+        attributeDefinitions.push({
+          AttributeName: props.sortKey.name,
+          AttributeType: props.sortKey.type,
+        });
+        keySchema.push({
+          AttributeName: props.sortKey.name,
+          KeyType: "RANGE",
+        });
+      }
+
+      // Attempt to create the table with exponential backoff for ResourceInUseException
+      await withExponentialBackoff(
+        async () => {
+          try {
+            // First check if table already exists
+            const describeResponse = await client.send(
+              new DescribeTableCommand({
+                TableName: props.tableName,
+              }),
+            );
+
+            // If table exists and is ACTIVE, no need to create it
+            if (describeResponse.Table?.TableStatus === "ACTIVE") {
+              return;
+            }
 
-        // Wait for table to be active
-        let tableActive = false;
-        let tableDescription;
-        while (!tableActive) {
+            // If table exists but not ACTIVE, wait for it in the polling loop below
+            if (describeResponse.Table) {
+              return;
+            }
+          } catch (error) {
+            if (error instanceof ResourceNotFoundException) {
+              // Table doesn't exist, try to create it
+              await client.send(
+                new CreateTableCommand({
+                  TableName: props.tableName,
+                  AttributeDefinitions: attributeDefinitions,
+                  KeySchema: keySchema,
+                  BillingMode: props.billingMode || "PAY_PER_REQUEST",
+                  ProvisionedThroughput:
+                    props.billingMode === "PROVISIONED"
+                      ? {
+                          ReadCapacityUnits: props.readCapacity || 5,
+                          WriteCapacityUnits: props.writeCapacity || 5,
+                        }
+                      : undefined,
+                  Tags: props.tags
+                    ? Object.entries(props.tags).map(([Key, Value]) => ({
+                        Key,
+                        Value,
+                      }))
+                    : undefined,
+                }),
+              );
+            } else {
+              throw error;
+            }
+          }
+        },
+        (error) => error instanceof ResourceInUseException,
+        10, // Max attempts
+        200, // Initial delay in ms
+      );
+
+      // Wait for table to be active with timeout
+      let tableActive = false;
+      let tableDescription;
+      let retryCount = 0;
+      const maxRetries = 60; // Wait up to 60 seconds
+
+      while (!tableActive && retryCount < maxRetries) {
+        try {
           const response = await client.send(
             new DescribeTableCommand({
               TableName: props.tableName,
             }),
           );
+
           tableActive = response.Table?.TableStatus === "ACTIVE";
           if (tableActive) {
             tableDescription = response.Table;
           } else {
-            await new Promise((resolve) => setTimeout(resolve, 1000));
+            retryCount++;
+            // Increasing delay for each retry with some jitter
+            const delay = Math.min(1000 * (1 + 0.1 * Math.random()), 5000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
           }
+        } catch (error) {
+          retryCount++;
+          if (!(error instanceof ResourceNotFoundException)) {
+            throw error;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1000));
         }
+      }
 
-        return {
-          ...props,
-          id: props.tableName,
-          arn: tableDescription!.TableArn!,
-          streamArn: tableDescription!.LatestStreamArn,
-          tableId: tableDescription!.TableId!,
-        };
-      } catch (error) {
-        if (error instanceof ResourceInUseException) {
-          // Table already exists, get its details
-          const response = await client.send(
-            new DescribeTableCommand({
-              TableName: props.tableName,
-            }),
-          );
-          return {
-            ...props,
-            id: props.tableName,
-            arn: response.Table!.TableArn!,
-            streamArn: response.Table!.LatestStreamArn,
-            tableId: response.Table!.TableId!,
-          };
-        }
-        throw error;
+      if (!tableActive) {
+        throw new Error(
+          `Timed out waiting for table ${props.tableName} to become active`,
+        );
       }
+
+      return {
+        ...props,
+        id: props.tableName,
+        arn: tableDescription!.TableArn!,
+        streamArn: tableDescription!.LatestStreamArn,
+        tableId: tableDescription!.TableId!,
+      };
     }
   },
 ) {}

package/src/cloudflare/bindings.ts

@@ -4,11 +4,17 @@
  * https://developers.cloudflare.com/api/resources/workers/subresources/scripts/methods/update/
  */
 import type { DurableObjectNamespace } from "./durable-object-namespace";
+import type { KVNamespace } from "./kv-namespace";
+import type { Worker } from "./worker";
+
+export type Bindings = {
+  [bindingName: string]: Binding;
+};
 
 /**
- * Union type for all Worker binding types (Alchemy abstraction)
+ * L2 Binding Resources.
  */
-export type WorkerBinding = WorkerBindingSpec | DurableObjectNamespace;
+export type Binding = DurableObjectNamespace | KVNamespace | Worker | string;
 
 /**
  * Union type for all Worker binding types (API spec)

package/src/cloudflare/durable-object-namespace.ts

@@ -1,7 +1,6 @@
-import type { WorkerBinding } from "./bindings";
+import type { Resolved } from "../output";
 
 export interface DurableObjectNamespaceInput {
-  bindingName: string;
   className: string;
   scriptName?: string | undefined;
   environment?: string | undefined;
@@ -10,19 +9,16 @@ export interface DurableObjectNamespaceInput {
 }
 
 export function isDurableObjectNamespace(
-  binding: WorkerBinding,
-): binding is DurableObjectNamespace {
+  binding: any,
+): binding is Resolved<DurableObjectNamespace> {
   return (
-    binding.type === "durable_object_namespace" &&
-    typeof (binding as any).bindingName === "string"
+    typeof binding === "object" && binding.type === "durable_object_namespace"
   );
 }
 
 export class DurableObjectNamespace implements DurableObjectNamespaceInput {
   public readonly type = "durable_object_namespace" as const;
   // alias for bindingName to be consistent with other bindings
-  public readonly name: string;
-  public readonly bindingName: string;
   public readonly className: string;
   public readonly scriptName?: string | undefined;
   public readonly environment?: string | undefined;
@@ -33,8 +29,6 @@ export class DurableObjectNamespace implements DurableObjectNamespaceInput {
     public readonly id: string,
     input: DurableObjectNamespaceInput,
   ) {
-    this.bindingName = input.bindingName;
-    this.name = this.bindingName;
     this.className = input.className;
     this.scriptName = input.scriptName;
     this.environment = input.environment;

package/src/cloudflare/kv-namespace.ts

@@ -1,3 +1,4 @@
+import type { Resolved } from "../output";
 import { type Context, Resource } from "../resource";
 import { createCloudflareApi } from "./api";
 
@@ -51,6 +52,7 @@ export interface KVPair {
  * Output returned after KV Namespace creation/update
  */
 export interface KVNamespaceOutput extends KVNamespaceProps {
+  type: "kv_namespace";
   /**
    * The ID of the namespace
    */
@@ -67,6 +69,14 @@ export interface KVNamespaceOutput extends KVNamespaceProps {
   modifiedAt: number;
 }
 
+export function isKVNamespace(
+  resource: any,
+): resource is Resolved<KVNamespace> {
+  return (
+    resource && typeof resource === "object" && resource.type === "kv_namespace"
+  );
+}
+
 export class KVNamespace extends Resource(
   "cloudflare::KVNamespace",
   async (ctx: Context<KVNamespaceOutput>, props: KVNamespaceProps) => {
@@ -182,6 +192,7 @@ export class KVNamespace extends Resource(
 
       // Construct the output
       const output: KVNamespaceOutput = {
+        type: "kv_namespace",
         id: namespaceId,
         title: props.title,
         values: props.values,

package/src/cloudflare/static-site.ts

@@ -7,7 +7,7 @@ import type { BundleProps } from "../esbuild";
 import type { Input } from "../input";
 import { type Context, Resource } from "../resource";
 import { createCloudflareApi } from "./api";
-import type { WorkerBindingSpec } from "./bindings";
+import type { Bindings } from "./bindings";
 import { generateAssetManifest } from "./generate-asset-manifest";
 import { KVNamespace } from "./kv-namespace";
 import { uploadAssetManifest } from "./upload-asset-manifest";
@@ -276,12 +276,12 @@ export class StaticSite extends Resource(
     const api = await createCloudflareApi();
 
     // Step 1: Create or get the KV namespace for assets
-    const namespace = new KVNamespace("assets", {
+    const kv = new KVNamespace("assets", {
       title: `${siteName}-assets`,
     });
 
     const [{ id: kvNamespaceId }, assetManifest] = await Promise.all([
-      apply(namespace, {
+      apply(kv, {
         quiet: ctx.quiet,
       }),
       generateAssetManifest(props.dir),
@@ -291,39 +291,20 @@ export class StaticSite extends Resource(
     await uploadAssetManifest(api, kvNamespaceId, assetManifest);
 
     // Prepare the bindings for the worker
-    const bindings: Input<WorkerBindingSpec>[] = [
-      {
-        name: "ASSETS",
-        type: "kv_namespace",
-        namespace_id: kvNamespaceId,
-      },
-      {
-        name: "INDEX_PAGE",
-        type: "plain_text",
-        text: indexPage,
-      },
-    ];
-
-    // Add error page binding if specified
-    if (props.errorPage) {
-      bindings.push({
-        name: "ERROR_PAGE",
-        type: "plain_text",
-        text: props.errorPage,
-      });
-    }
+    const bindings: Input<Bindings> = {
+      ASSETS: kv,
+      INDEX_PAGE: indexPage,
+      // Add error page binding if specified
+      ...(props.errorPage ? { ERROR_PAGE: props.errorPage } : {}),
+    };
 
     const routes: Record<string, string> = {};
     // Create backend worker if configured
     if (props.routes) {
-      for (const [path, entrypoint] of Object.entries(props.routes)) {
+      for (const [path, worker] of Object.entries(props.routes)) {
         // @ts-ignore - TODO: need to use Resolved<Worker> to get the string ...
-        routes[path] = entrypoint.id;
-        bindings.push({
-          type: "service",
-          name: `ROUTE_${entrypoint.id}`,
-          service: entrypoint.id,
-        });
+        routes[path] = worker.id;
+        bindings[`ROUTE_${worker.id}`] = worker;
       }
     }
 
@@ -366,7 +347,7 @@ export class StaticSite extends Resource(
         },
       },
       // place a dependency on the namespace
-      namespace.id,
+      kv.id,
     );
 
     // Get current timestamp

package/src/cloudflare/worker.ts

@@ -1,11 +1,13 @@
 import * as fs from "fs/promises";
 import { apply } from "../apply";
 import { Bundle, type BundleProps } from "../esbuild";
+import type { Resolved } from "../output";
 import { type Context, Resource } from "../resource";
 import { type CloudflareApi, createCloudflareApi } from "./api";
-import type { WorkerBinding, WorkerBindingSpec } from "./bindings";
+import type { Bindings, WorkerBindingSpec } from "./bindings";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import { isDurableObjectNamespace } from "./durable-object-namespace";
+import { isKVNamespace } from "./kv-namespace";
 import type { WorkerScriptMetadata } from "./worker-metadata";
 import type { SingleStepMigration } from "./worker-migration";
 /**
@@ -54,7 +56,7 @@ export interface WorkerProps {
   /**
    * Bindings to attach to the worker
    */
-  bindings?: WorkerBinding[];
+  bindings?: Bindings;
 
   /**
    * Environment variables to attach to the worker
@@ -94,6 +96,8 @@ export interface WorkerProps {
  * Output returned after Worker creation/update
  */
 export interface WorkerOutput extends Omit<WorkerProps, "url"> {
+  type: "service";
+
   /**
    * The ID of the worker
    */
@@ -118,7 +122,11 @@ export interface WorkerOutput extends Omit<WorkerProps, "url"> {
   /**
    * The bindings that were created
    */
-  bindings: WorkerBinding[];
+  bindings: Bindings;
+}
+
+export function isWorker(resource: any): resource is Resolved<Worker> {
+  return resource && typeof resource === "object" && resource.type === "worker";
 }
 
 export class Worker extends Resource(
@@ -144,7 +152,7 @@ export class Worker extends Resource(
       await assertWorkerDoesNotExist(ctx, api, workerName);
     }
 
-    const oldBindings = await ctx.get<WorkerBinding[]>("bindings");
+    const oldBindings = await ctx.get<Bindings>("bindings");
 
     const scriptMetadata = await prepareWorkerMetadata(ctx, oldBindings, props);
 
@@ -174,12 +182,13 @@ export class Worker extends Resource(
 
     // Construct the output
     const output: WorkerOutput = {
+      type: "service",
       id: workerName,
       name: workerName,
       script: scriptContent,
       format: props.format || "esm", // Include format in the output
       routes: props.routes || [],
-      bindings: props.bindings || [],
+      bindings: props.bindings ?? {},
       env: props.env,
       observability: scriptMetadata.observability,
       createdAt: now,
@@ -283,7 +292,7 @@ async function putWorker(
     scriptName,
   );
 
-  console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
+  // console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
 
   // Add metadata as JSON
   formData.append(
@@ -318,7 +327,7 @@ async function putWorker(
 }
 
 interface WorkerMetadata {
-  bindings: WorkerBinding[];
+  bindings: WorkerBindingSpec[];
   observability: {
     enabled: boolean;
   };
@@ -330,12 +339,12 @@ interface WorkerMetadata {
 
 async function prepareWorkerMetadata(
   ctx: Context<WorkerOutput>,
-  oldBindings: WorkerBinding[] | undefined,
+  oldBindings: Bindings | undefined,
   props: WorkerProps,
 ): Promise<WorkerMetadata> {
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
-    bindings: [] as WorkerBinding[],
+    bindings: [],
     observability: {
       enabled: props.observability?.enabled !== false,
     },
@@ -349,30 +358,51 @@ async function prepareWorkerMetadata(
     },
   };
 
+  const bindings = (props.bindings ?? {}) as Resolved<Bindings>;
+
   // Convert bindings to the format expected by the API
-  for (const binding of props.bindings ?? []) {
+  for (const [bindingName, binding] of Object.entries(bindings)) {
     // Create a copy of the binding to avoid modifying the original
-    const bindingData = { ...binding };
 
-    if (isDurableObjectNamespace(bindingData)) {
-      const stableId = bindingData.id;
-      const className = bindingData.className;
+    if (isKVNamespace(binding)) {
+      meta.bindings.push({
+        type: "kv_namespace",
+        name: bindingName,
+        namespace_id: binding.id,
+      });
+    } else if (typeof binding === "string") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: binding,
+      });
+    } else if (binding.type === "service") {
+      meta.bindings.push({
+        type: "service",
+        name: bindingName,
+        service: binding.id,
+      });
+    } else if (isDurableObjectNamespace(binding)) {
+      const stableId = binding.id;
+      const className = binding.className;
 
       meta.bindings.push({
         type: "durable_object_namespace",
-        name: bindingData.bindingName,
+        name: bindingName,
         class_name: className,
-        script_name: bindingData.scriptName,
-        environment: bindingData.environment,
-        namespace_id: bindingData.namespaceId,
+        script_name: binding.scriptName,
+        environment: binding.environment,
+        namespace_id: binding.namespaceId,
       });
 
-      const oldBinding: DurableObjectNamespace | undefined = oldBindings
+      const oldBinding: DurableObjectNamespace | undefined = Object.values(
+        oldBindings ?? {},
+      )
         ?.filter(isDurableObjectNamespace)
         ?.find((b) => b.id === stableId);
 
       if (!oldBinding) {
-        if (bindingData.sqlite) {
+        if (binding.sqlite) {
           meta.migrations!.new_sqlite_classes!.push(className);
         } else {
           meta.migrations!.new_classes!.push(className);
@@ -384,8 +414,8 @@ async function prepareWorkerMetadata(
         });
       }
     } else {
-      // For all other binding types, use as-is
-      meta.bindings.push(bindingData as WorkerBindingSpec);
+      // @ts-expect-error - we should never reach here
+      throw new Error(`Unsupported binding type: ${binding.type}`);
     }
   }