alchemy 0.1.13 → 0.1.15

package/src/aws/ses.ts

@@ -1,5 +1,4 @@
 import {
-  AlreadyExistsException,
   CreateConfigurationSetCommand,
   CreateEmailIdentityCommand,
   DeleteConfigurationSetCommand,
@@ -8,6 +7,11 @@ import {
   GetConfigurationSetCommand,
   GetEmailIdentityCommand,
   NotFoundException,
+  PutConfigurationSetDeliveryOptionsCommand,
+  PutConfigurationSetReputationOptionsCommand,
+  PutConfigurationSetSendingOptionsCommand,
+  PutConfigurationSetSuppressionOptionsCommand,
+  PutConfigurationSetTrackingOptionsCommand,
   PutEmailIdentityDkimAttributesCommand,
   type ReputationOptions,
   SESv2Client,
@@ -103,7 +107,7 @@ export interface SESOutput extends SESProps {
  */
 export class SES extends Resource(
   "aws::SES",
-  async (ctx: Context<SESOutput>, props: SESProps): Promise<SESOutput> => {
+  async (ctx: Context<SESOutput>, props: SESProps) => {
     // Create SES client
     const client = new SESv2Client({});
 
@@ -138,10 +142,7 @@ export class SES extends Resource(
       }
 
       // Return empty output for delete
-      return {
-        ...props,
-        id,
-      };
+      return;
     }
 
     // Created resources
@@ -154,66 +155,68 @@ export class SES extends Resource(
     if (props.configurationSetName) {
       try {
         // Check if configuration set exists
-        let getConfigResult;
+        let configSetExists = false;
         try {
-          getConfigResult = await client.send(
+          await client.send(
             new GetConfigurationSetCommand({
               ConfigurationSetName: props.configurationSetName,
             }),
           );
+          configSetExists = true;
         } catch (error) {
           if (error instanceof NotFoundException) {
-            getConfigResult = null;
+            configSetExists = false;
           } else {
             throw error;
           }
         }
 
-        if (getConfigResult) {
-          // For updating configuration set, we need to use individual commands
-          // since there's no unified UpdateConfigurationSetCommand
-
+        if (configSetExists) {
+          // Update existing configuration set using appropriate update commands
           if (props.sendingOptions) {
             await client.send(
-              new CreateConfigurationSetCommand({
+              new PutConfigurationSetSendingOptionsCommand({
                 ConfigurationSetName: props.configurationSetName,
-                SendingOptions: props.sendingOptions,
+                SendingEnabled: props.sendingOptions.SendingEnabled,
               }),
             );
           }
 
           if (props.reputationOptions) {
             await client.send(
-              new CreateConfigurationSetCommand({
+              new PutConfigurationSetReputationOptionsCommand({
                 ConfigurationSetName: props.configurationSetName,
-                ReputationOptions: props.reputationOptions,
+                ReputationMetricsEnabled:
+                  props.reputationOptions.ReputationMetricsEnabled,
               }),
             );
           }
 
           if (props.trackingOptions) {
             await client.send(
-              new CreateConfigurationSetCommand({
+              new PutConfigurationSetTrackingOptionsCommand({
                 ConfigurationSetName: props.configurationSetName,
-                TrackingOptions: props.trackingOptions,
+                CustomRedirectDomain:
+                  props.trackingOptions.CustomRedirectDomain,
               }),
             );
           }
 
           if (props.suppressionOptions) {
             await client.send(
-              new CreateConfigurationSetCommand({
+              new PutConfigurationSetSuppressionOptionsCommand({
                 ConfigurationSetName: props.configurationSetName,
-                SuppressionOptions: props.suppressionOptions,
+                SuppressedReasons: props.suppressionOptions.SuppressedReasons,
               }),
             );
           }
 
           if (props.deliveryOptions) {
             await client.send(
-              new CreateConfigurationSetCommand({
+              new PutConfigurationSetDeliveryOptionsCommand({
                 ConfigurationSetName: props.configurationSetName,
-                DeliveryOptions: props.deliveryOptions,
+                TlsPolicy: props.deliveryOptions.TlsPolicy,
+                SendingPoolName: props.deliveryOptions.SendingPoolName,
               }),
             );
           }
@@ -241,14 +244,7 @@ export class SES extends Resource(
           configurationSetArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:configuration-set/${props.configurationSetName}`;
         }
       } catch (error: any) {
-        if (error instanceof AlreadyExistsException) {
-          // If it already exists but we couldn't get it (permissions issue), continue
-          console.warn(
-            `Configuration set ${props.configurationSetName} already exists but cannot be retrieved`,
-          );
-        } else {
-          throw error;
-        }
+        throw error;
       }
     }
 

package/src/aws/table.ts

@@ -3,12 +3,14 @@ import {
   DeleteTableCommand,
   DescribeTableCommand,
   DynamoDBClient,
+  InternalServerError,
   type KeySchemaElement,
   ResourceInUseException,
   ResourceNotFoundException,
 } 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,21 +40,33 @@ export class Table extends Resource(
   async (
     ctx: Context<TableOutput>,
     props: TableProps,
-  ): Promise<TableOutput> => {
+  ): Promise<TableOutput | void> => {
     const client = new DynamoDBClient({});
 
     if (ctx.event === "delete") {
-      await ignore(ResourceNotFoundException.name, () =>
-        client.send(
-          new DeleteTableCommand({
-            TableName: props.tableName,
-          }),
-        ),
+      await withExponentialBackoff(
+        async () => {
+          await ignore(ResourceNotFoundException.name, () =>
+            client.send(
+              new DeleteTableCommand({
+                TableName: props.tableName,
+              }),
+            ),
+          );
+        },
+        (error) =>
+          error instanceof ResourceInUseException ||
+          error instanceof InternalServerError,
+        10, // Max attempts
+        200, // Initial delay in ms
       );
 
       // Wait for table to be deleted
       let tableDeleted = false;
-      while (!tableDeleted) {
+      let retryCount = 0;
+      const maxRetries = 60; // Wait up to 60 seconds
+
+      while (!tableDeleted && retryCount < maxRetries) {
         try {
           await client.send(
             new DescribeTableCommand({
@@ -60,7 +74,10 @@ export class Table extends Resource(
             }),
           );
           // If we get here, table still exists
-          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) {
           if (error instanceof ResourceNotFoundException) {
             tableDeleted = true;
@@ -70,103 +87,139 @@ 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: "",
-      };
+      if (!tableDeleted) {
+        throw new Error(
+          `Timed out waiting for table ${props.tableName} to be deleted`,
+        );
+      }
+
+      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;
+            }
+
+            // 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
 
-        // Wait for table to be active
-        let tableActive = false;
-        let tableDescription;
-        while (!tableActive) {
+      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,4 +1,6 @@
+import type { Resolved } from "../output";
 import { type Context, Resource } from "../resource";
+import { withExponentialBackoff } from "../utils/retry";
 import { createCloudflareApi } from "./api";
 
 /**
@@ -51,6 +53,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 +70,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) => {
@@ -76,7 +87,6 @@ export class KVNamespace extends Resource(
     if (ctx.event === "delete") {
       // For delete operations, we need to check if the namespace ID exists in the output
       const namespaceId = ctx.output?.id;
-
       if (namespaceId) {
         // Delete KV namespace
         const deleteResponse = await api.delete(
@@ -87,9 +97,8 @@ export class KVNamespace extends Resource(
           const errorData: any = await deleteResponse.json().catch(() => ({
             errors: [{ message: deleteResponse.statusText }],
           }));
-          console.error(
-            "Error deleting KV namespace:",
-            errorData.errors?.[0]?.message || deleteResponse.statusText,
+          throw new Error(
+            `Error deleting KV namespace '${props.title}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
           );
         }
       }
@@ -162,18 +171,38 @@ export class KVNamespace extends Resource(
             return item;
           });
 
-          const bulkResponse = await api.put(
-            `/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
-            bulkPayload,
-          );
-
-          if (!bulkResponse.ok) {
-            const errorData: any = await bulkResponse.json().catch(() => ({
-              errors: [{ message: bulkResponse.statusText }],
-            }));
-            console.warn(
-              `Error writing KV batch: ${errorData.errors?.[0]?.message || bulkResponse.statusText}`,
+          try {
+            await withExponentialBackoff(
+              async () => {
+                const bulkResponse = await api.put(
+                  `/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
+                  bulkPayload,
+                );
+
+                if (!bulkResponse.ok) {
+                  const errorData: any = await bulkResponse
+                    .json()
+                    .catch(() => ({
+                      errors: [{ message: bulkResponse.statusText }],
+                    }));
+                  const errorMessage =
+                    errorData.errors?.[0]?.message || bulkResponse.statusText;
+
+                  // Throw error to trigger retry
+                  throw new Error(`Error writing KV batch: ${errorMessage}`);
+                }
+
+                return bulkResponse;
+              },
+              (error) => {
+                // Retry on "namespace not found" errors as they're likely propagation delays
+                return error.message?.includes("not found");
+              },
+              5, // 5 retry attempts
+              1000, // Start with 1 second delay
             );
+          } catch (error: any) {
+            console.warn(error.message);
           }
         }
       }
@@ -182,6 +211,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