alchemy 0.1.12 → 0.1.14

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

@@ -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/api.ts

@@ -183,6 +183,12 @@ export class CloudflareApi {
     return this.fetch(path, { ...init, method: "GET" });
   }
 
+  /**
+   * Helper for HEAD requests
+   */
+  async head(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "HEAD" });
+  }
   /**
    * Helper for POST requests
    */

package/src/cloudflare/bindings.ts

@@ -3,6 +3,44 @@
  * Based on Cloudflare API documentation:
  * 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;
+};
+
+/**
+ * L2 Binding Resources.
+ */
+export type Binding = DurableObjectNamespace | KVNamespace | Worker | string;
+
+/**
+ * Union type for all Worker binding types (API spec)
+ */
+export type WorkerBindingSpec =
+  | WorkerBindingAI
+  | WorkerBindingAnalyticsEngine
+  | WorkerBindingAssets
+  | WorkerBindingBrowserRendering
+  | WorkerBindingD1
+  | WorkerBindingDispatchNamespace
+  | WorkerBindingDurableObjectNamespace
+  | WorkerBindingHyperdrive
+  | WorkerBindingJson
+  | WorkerBindingKVNamespace
+  | WorkerBindingMTLSCertificate
+  | WorkerBindingPlainText
+  | WorkerBindingQueue
+  | WorkerBindingR2Bucket
+  | WorkerBindingSecretText
+  | WorkerBindingService
+  | WorkerBindingStaticContent
+  | WorkerBindingTailConsumer
+  | WorkerBindingVectorize
+  | WorkerBindingVersionMetadata
+  | WorkerBindingWasmModule;
 
 /**
  * AI binding type
@@ -76,6 +114,11 @@ export interface WorkerBindingDispatchNamespace {
  * Durable Object Namespace binding type
  */
 export interface WorkerBindingDurableObjectNamespace {
+  /**
+   * The stable ID of the binding
+   * @internal
+   */
+  stableId?: string;
   /** The name of the binding */
   name: string;
   /** Type identifier for Durable Object Namespace binding */
@@ -258,29 +301,3 @@ export interface WorkerBindingStaticContent {
   /** Type identifier for Static Content binding */
   type: "static_content";
 }
-
-/**
- * Union type for all Worker binding types
- */
-export type WorkerBinding =
-  | WorkerBindingAI
-  | WorkerBindingAnalyticsEngine
-  | WorkerBindingAssets
-  | WorkerBindingBrowserRendering
-  | WorkerBindingD1
-  | WorkerBindingDispatchNamespace
-  | WorkerBindingDurableObjectNamespace
-  | WorkerBindingHyperdrive
-  | WorkerBindingJson
-  | WorkerBindingKVNamespace
-  | WorkerBindingMTLSCertificate
-  | WorkerBindingPlainText
-  | WorkerBindingQueue
-  | WorkerBindingR2Bucket
-  | WorkerBindingSecretText
-  | WorkerBindingService
-  | WorkerBindingStaticContent
-  | WorkerBindingTailConsumer
-  | WorkerBindingVectorize
-  | WorkerBindingVersionMetadata
-  | WorkerBindingWasmModule;

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

@@ -0,0 +1,37 @@
+import type { Resolved } from "../output";
+
+export interface DurableObjectNamespaceInput {
+  className: string;
+  scriptName?: string | undefined;
+  environment?: string | undefined;
+  sqlite?: boolean | undefined;
+  namespaceId?: string | undefined;
+}
+
+export function isDurableObjectNamespace(
+  binding: any,
+): binding is Resolved<DurableObjectNamespace> {
+  return (
+    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 className: string;
+  public readonly scriptName?: string | undefined;
+  public readonly environment?: string | undefined;
+  public readonly sqlite?: boolean | undefined;
+  public readonly namespaceId?: string | undefined;
+
+  constructor(
+    public readonly id: string,
+    input: DurableObjectNamespaceInput,
+  ) {
+    this.className = input.className;
+    this.scriptName = input.scriptName;
+    this.environment = input.environment;
+    this.sqlite = input.sqlite;
+  }
+}

package/src/cloudflare/index.ts

@@ -1,4 +1,5 @@
 export * from "./bindings";
+export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./state";
 export * from "./static-site";

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) => {
@@ -121,7 +131,7 @@ export class KVNamespace extends Resource(
             errors: [{ message: createResponse.statusText }],
           }));
           throw new Error(
-            `Error creating KV namespace: ${errorData.errors?.[0]?.message || createResponse.statusText}`,
+            `Error creating KV namespace '${props.title}': ${errorData.errors?.[0]?.message || createResponse.statusText}`,
           );
         }
 
@@ -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,