alchemy 0.1.18 → 0.2.0

package/src/aws/ses.ts

@@ -19,8 +19,9 @@ import {
   type SuppressionOptions,
   type TrackingOptions,
 } from "@aws-sdk/client-sesv2";
-import { ignore } from "../error";
-import { type Context, Resource } from "../resource";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
 
 /**
  * Properties for configuring AWS SES resources
@@ -75,12 +76,7 @@ export interface SESProps {
 /**
  * Output returned after SES resource creation/update
  */
-export interface SESOutput extends SESProps {
-  /**
-   * Resource ID
-   */
-  id: string;
-
+export interface SES extends Resource<"aws::SES">, SESProps {
   /**
    * ARN of the configuration set if created
    */
@@ -105,19 +101,23 @@ export interface SESOutput extends SESProps {
 /**
  * AWS SES resource for creating and configuring Simple Email Service
  */
-export class SES extends Resource(
+export const SES = Resource(
   "aws::SES",
-  async (ctx: Context<SESOutput>, props: SESProps) => {
+  async function (
+    this: Context<SES>,
+    id: string,
+    props: SESProps,
+  ): Promise<SES> {
     // Create SES client
     const client = new SESv2Client({});
 
     // Resource ID is either based on the configuration set name or email identity
-    const id =
-      props.configurationSetName || props.emailIdentity || ctx.resourceID;
+    // const id =
+    //   props.configurationSetName || props.emailIdentity || this.resourceID;
 
     // Handle deletion
-    if (ctx.event === "delete") {
-      const output = ctx.output;
+    if (this.phase === "delete") {
+      const output = this.output;
 
       // Delete configuration set if it exists
       if (output?.configurationSetName) {
@@ -142,7 +142,7 @@ export class SES extends Resource(
       }
 
       // Return empty output for delete
-      return;
+      return this.destroy();
     }
 
     // Created resources
@@ -153,190 +153,176 @@ export class SES extends Resource(
 
     // Create or update configuration set if specified
     if (props.configurationSetName) {
+      // Check if configuration set exists
+      let configSetExists = false;
       try {
-        // Check if configuration set exists
-        let configSetExists = false;
-        try {
+        await client.send(
+          new GetConfigurationSetCommand({
+            ConfigurationSetName: props.configurationSetName,
+          }),
+        );
+        configSetExists = true;
+      } catch (error) {
+        if (error instanceof NotFoundException) {
+          configSetExists = false;
+        } else {
+          throw error;
+        }
+      }
+
+      if (configSetExists) {
+        // Update existing configuration set using appropriate update commands
+        if (props.sendingOptions) {
           await client.send(
-            new GetConfigurationSetCommand({
+            new PutConfigurationSetSendingOptionsCommand({
               ConfigurationSetName: props.configurationSetName,
+              SendingEnabled: props.sendingOptions.SendingEnabled,
             }),
           );
-          configSetExists = true;
-        } catch (error) {
-          if (error instanceof NotFoundException) {
-            configSetExists = false;
-          } else {
-            throw error;
-          }
         }
 
-        if (configSetExists) {
-          // Update existing configuration set using appropriate update commands
-          if (props.sendingOptions) {
-            await client.send(
-              new PutConfigurationSetSendingOptionsCommand({
-                ConfigurationSetName: props.configurationSetName,
-                SendingEnabled: props.sendingOptions.SendingEnabled,
-              }),
-            );
-          }
-
-          if (props.reputationOptions) {
-            await client.send(
-              new PutConfigurationSetReputationOptionsCommand({
-                ConfigurationSetName: props.configurationSetName,
-                ReputationMetricsEnabled:
-                  props.reputationOptions.ReputationMetricsEnabled,
-              }),
-            );
-          }
-
-          if (props.trackingOptions) {
-            await client.send(
-              new PutConfigurationSetTrackingOptionsCommand({
-                ConfigurationSetName: props.configurationSetName,
-                CustomRedirectDomain:
-                  props.trackingOptions.CustomRedirectDomain,
-              }),
-            );
-          }
-
-          if (props.suppressionOptions) {
-            await client.send(
-              new PutConfigurationSetSuppressionOptionsCommand({
-                ConfigurationSetName: props.configurationSetName,
-                SuppressedReasons: props.suppressionOptions.SuppressedReasons,
-              }),
-            );
-          }
+        if (props.reputationOptions) {
+          await client.send(
+            new PutConfigurationSetReputationOptionsCommand({
+              ConfigurationSetName: props.configurationSetName,
+              ReputationMetricsEnabled:
+                props.reputationOptions.ReputationMetricsEnabled,
+            }),
+          );
+        }
 
-          if (props.deliveryOptions) {
-            await client.send(
-              new PutConfigurationSetDeliveryOptionsCommand({
-                ConfigurationSetName: props.configurationSetName,
-                TlsPolicy: props.deliveryOptions.TlsPolicy,
-                SendingPoolName: props.deliveryOptions.SendingPoolName,
-              }),
-            );
-          }
+        if (props.trackingOptions) {
+          await client.send(
+            new PutConfigurationSetTrackingOptionsCommand({
+              ConfigurationSetName: props.configurationSetName,
+              CustomRedirectDomain: props.trackingOptions.CustomRedirectDomain,
+            }),
+          );
+        }
 
-          // In SESv2, the ARN isn't directly returned in the response
-          configurationSetArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:configuration-set/${props.configurationSetName}`;
-        } else {
-          // Create new configuration set
+        if (props.suppressionOptions) {
           await client.send(
-            new CreateConfigurationSetCommand({
+            new PutConfigurationSetSuppressionOptionsCommand({
               ConfigurationSetName: props.configurationSetName,
-              SendingOptions: props.sendingOptions,
-              ReputationOptions: props.reputationOptions,
-              TrackingOptions: props.trackingOptions,
-              SuppressionOptions: props.suppressionOptions,
-              DeliveryOptions: props.deliveryOptions,
-              Tags: Object.entries(props.tags || {}).map(([Key, Value]) => ({
-                Key,
-                Value,
-              })),
+              SuppressedReasons: props.suppressionOptions.SuppressedReasons,
             }),
           );
+        }
 
-          // In SESv2, the ARN isn't directly returned in the response
-          configurationSetArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:configuration-set/${props.configurationSetName}`;
+        if (props.deliveryOptions) {
+          await client.send(
+            new PutConfigurationSetDeliveryOptionsCommand({
+              ConfigurationSetName: props.configurationSetName,
+              TlsPolicy: props.deliveryOptions.TlsPolicy,
+              SendingPoolName: props.deliveryOptions.SendingPoolName,
+            }),
+          );
         }
-      } catch (error: any) {
-        throw error;
+
+        // In SESv2, the ARN isn't directly returned in the response
+        configurationSetArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:configuration-set/${props.configurationSetName}`;
+      } else {
+        // Create new configuration set
+        await client.send(
+          new CreateConfigurationSetCommand({
+            ConfigurationSetName: props.configurationSetName,
+            SendingOptions: props.sendingOptions,
+            ReputationOptions: props.reputationOptions,
+            TrackingOptions: props.trackingOptions,
+            SuppressionOptions: props.suppressionOptions,
+            DeliveryOptions: props.deliveryOptions,
+            Tags: Object.entries(props.tags || {}).map(([Key, Value]) => ({
+              Key,
+              Value,
+            })),
+          }),
+        );
+
+        // In SESv2, the ARN isn't directly returned in the response
+        configurationSetArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:configuration-set/${props.configurationSetName}`;
       }
     }
 
     // Create or verify email identity if specified
     if (props.emailIdentity) {
+      // Check if identity exists
+      let getIdentityResult;
       try {
-        // Check if identity exists
-        let getIdentityResult;
-        try {
-          getIdentityResult = await client.send(
-            new GetEmailIdentityCommand({
-              EmailIdentity: props.emailIdentity,
-            }),
-          );
-        } catch (error) {
-          if (error instanceof NotFoundException) {
-            getIdentityResult = null;
-          } else {
-            throw error;
-          }
+        getIdentityResult = await client.send(
+          new GetEmailIdentityCommand({
+            EmailIdentity: props.emailIdentity,
+          }),
+        );
+      } catch (error) {
+        if (error instanceof NotFoundException) {
+          getIdentityResult = null;
+        } else {
+          throw error;
         }
+      }
 
-        if (!getIdentityResult) {
-          // Create new email identity
-          const createIdentityResult = await client.send(
-            new CreateEmailIdentityCommand({
-              EmailIdentity: props.emailIdentity,
-              Tags: Object.entries(props.tags || {}).map(([Key, Value]) => ({
-                Key,
-                Value,
-              })),
-            }),
-          );
+      if (!getIdentityResult) {
+        // Create new email identity
+        const createIdentityResult = await client.send(
+          new CreateEmailIdentityCommand({
+            EmailIdentity: props.emailIdentity,
+            Tags: Object.entries(props.tags || {}).map(([Key, Value]) => ({
+              Key,
+              Value,
+            })),
+          }),
+        );
+
+        // If it's an email address, we don't need to explicitly verify in v2
+        // The verification email is automatically sent by SES in v2
+
+        // Store the identity information
+        emailIdentityArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:identity/${props.emailIdentity}`;
+        emailIdentityVerificationStatus =
+          createIdentityResult.VerifiedForSendingStatus
+            ? "VERIFIED"
+            : "PENDING";
+      } else {
+        // Store the identity information
+        emailIdentityArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:identity/${props.emailIdentity}`;
+        emailIdentityVerificationStatus =
+          getIdentityResult.VerifiedForSendingStatus ? "VERIFIED" : "PENDING";
+
+        // Update DKIM settings if requested
+        if (props.enableDkim !== undefined) {
+          if (props.enableDkim) {
+            await client.send(
+              new PutEmailIdentityDkimAttributesCommand({
+                EmailIdentity: props.emailIdentity,
+                SigningEnabled: true,
+              }),
+            );
 
-          // If it's an email address, we don't need to explicitly verify in v2
-          // The verification email is automatically sent by SES in v2
+            // We can check the current status of DKIM
+            dkimVerificationStatus = "PENDING"; // Default to pending
 
-          // Store the identity information
-          emailIdentityArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:identity/${props.emailIdentity}`;
-          emailIdentityVerificationStatus =
-            createIdentityResult.VerifiedForSendingStatus
-              ? "VERIFIED"
-              : "PENDING";
-        } else {
-          // Store the identity information
-          emailIdentityArn = `arn:aws:ses:${process.env.AWS_REGION}:${process.env.AWS_ACCOUNT_ID}:identity/${props.emailIdentity}`;
-          emailIdentityVerificationStatus =
-            getIdentityResult.VerifiedForSendingStatus ? "VERIFIED" : "PENDING";
-
-          // Update DKIM settings if requested
-          if (props.enableDkim !== undefined) {
-            if (props.enableDkim) {
-              await client.send(
-                new PutEmailIdentityDkimAttributesCommand({
-                  EmailIdentity: props.emailIdentity,
-                  SigningEnabled: true,
-                }),
-              );
-
-              // We can check the current status of DKIM
-              dkimVerificationStatus = "PENDING"; // Default to pending
-
-              // Get the updated identity to check DKIM status
-              const updatedIdentity = await client.send(
-                new GetEmailIdentityCommand({
-                  EmailIdentity: props.emailIdentity,
-                }),
-              );
-
-              if (updatedIdentity.DkimAttributes?.Status) {
-                dkimVerificationStatus = updatedIdentity.DkimAttributes.Status;
-              }
+            // Get the updated identity to check DKIM status
+            const updatedIdentity = await client.send(
+              new GetEmailIdentityCommand({
+                EmailIdentity: props.emailIdentity,
+              }),
+            );
+
+            if (updatedIdentity.DkimAttributes?.Status) {
+              dkimVerificationStatus = updatedIdentity.DkimAttributes.Status;
             }
           }
         }
-      } catch (error) {
-        console.error(
-          `Error configuring email identity ${props.emailIdentity}:`,
-          error,
-        );
-        throw error;
       }
     }
 
     // Return the resource output
-    return {
+    return this({
       ...props,
-      id,
       configurationSetArn,
       emailIdentityArn,
       emailIdentityVerificationStatus,
       dkimVerificationStatus,
-    };
+    });
   },
-) {}
+);

package/src/aws/table.ts

@@ -8,9 +8,10 @@ import {
   ResourceInUseException,
   ResourceNotFoundException,
 } from "@aws-sdk/client-dynamodb";
-import { ignore } from "../error";
-import { type Context, Resource } from "../resource";
-import { withExponentialBackoff } from "../utils/retry";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+import { withExponentialBackoff } from "../util/retry";
 
 export interface TableProps {
   tableName: string;
@@ -28,22 +29,22 @@ export interface TableProps {
   tags?: Record<string, string>;
 }
 
-export interface TableOutput extends TableProps {
-  id: string; // Same as tableName
+export interface Table extends Resource<"dynamo::Table">, TableProps {
   arn: string;
   streamArn?: string;
   tableId: string;
 }
 
-export class Table extends Resource(
+export const Table = Resource(
   "dynamo::Table",
-  async (
-    ctx: Context<TableOutput>,
+  async function (
+    this: Context<Table>,
+    id: string,
     props: TableProps,
-  ): Promise<TableOutput | void> => {
+  ): Promise<Table> {
     const client = new DynamoDBClient({});
 
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
       await withExponentialBackoff(
         async () => {
           await ignore(ResourceNotFoundException.name, () =>
@@ -93,7 +94,7 @@ export class Table extends Resource(
         );
       }
 
-      return;
+      return this.destroy();
     } else {
       // Setup for table creation
       const attributeDefinitions = [
@@ -213,13 +214,12 @@ export class Table extends Resource(
         );
       }
 
-      return {
+      return this({
         ...props,
-        id: props.tableName,
         arn: tableDescription!.TableArn!,
         streamArn: tableDescription!.LatestStreamArn,
         tableId: tableDescription!.TableId!,
-      };
+      });
     }
   },
-) {}
+);

package/src/cloudflare/bindings.ts

@@ -24,6 +24,14 @@ export type Binding =
   | Secret
   | string;
 
+export function isDurableObjectNamespace(
+  binding: Binding,
+): binding is DurableObjectNamespace {
+  return (
+    typeof binding === "object" && binding.type === "durable_object_namespace"
+  );
+}
+
 /**
  * Union type for all Worker binding types (API spec)
  */

package/src/cloudflare/bucket.ts

@@ -1,5 +1,5 @@
-import type { Resolved } from "../output";
-import { type Context, Resource } from "../resource";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 import { createCloudflareApi } from "./api";
 
 /**
@@ -11,7 +11,7 @@ export interface BucketProps {
    * Names can only contain lowercase letters (a-z), numbers (0-9), and hyphens (-)
    * Cannot begin or end with a hyphen
    */
-  name?: string;
+  name: string;
 
   /**
    * Optional location hint for the bucket
@@ -35,11 +35,13 @@ export interface BucketProps {
 /**
  * Output returned after R2 Bucket creation/update
  */
-export interface BucketOutput extends BucketProps {
+export interface R2Bucket
+  extends Resource<"cloudflare::R2Bucket">,
+    BucketProps {
   /**
-   * The ID of the bucket (same as name)
+   * Resource type identifier
    */
-  id: string;
+  type: "r2_bucket";
 
   /**
    * Location of the bucket
@@ -50,44 +52,23 @@ export interface BucketOutput extends BucketProps {
    * Time at which the bucket was created (Unix timestamp in seconds)
    */
   creationDate: number;
-
-  /**
-   * Resource type identifier
-   */
-  type: "r2_bucket";
-}
-
-/**
- * Cloudflare R2 bucket API response
- */
-interface CloudflareBucketResponse {
-  result: {
-    name: string;
-    location?: string;
-    creation_date: string;
-  };
-  success: boolean;
-  errors: Array<{ code: number; message: string }>;
-  messages: string[];
-}
-
-export function isBucket(resource: any): resource is Resolved<R2Bucket> {
-  return (
-    resource && typeof resource === "object" && resource.id && resource.location
-  );
 }
 
-export class R2Bucket extends Resource(
+export const R2Bucket = Resource(
   "cloudflare::R2Bucket",
-  async (ctx: Context<BucketOutput>, props: BucketProps) => {
+  async function (
+    this: Context<R2Bucket>,
+    id: string,
+    props: BucketProps,
+  ): Promise<R2Bucket> {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
 
     // Resource ID defaults to bucket name if provided
-    const bucketName = props.name || ctx.resourceID;
+    const bucketName = props.name || this.id;
 
-    if (ctx.event === "delete") {
-      if (ctx.output?.id) {
+    if (this.phase === "delete") {
+      if (this.output?.name) {
         // Delete R2 bucket
         const headers: Record<string, string> = {};
         if (props.jurisdiction && props.jurisdiction !== "default") {
@@ -95,7 +76,7 @@ export class R2Bucket extends Resource(
         }
 
         const deleteResponse = await api.delete(
-          `/accounts/${api.accountId}/r2/buckets/${ctx.output.id}`,
+          `/accounts/${api.accountId}/r2/buckets/${this.output.name}`,
           { headers },
         );
 
@@ -110,12 +91,25 @@ export class R2Bucket extends Resource(
       }
 
       // Return void (a deleted bucket has no content)
-      return;
+      return this.destroy();
     } else {
+      /**
+       * Cloudflare R2 bucket API response
+       */
+      interface CloudflareBucketResponse {
+        result: {
+          name: string;
+          location?: string;
+          creation_date: string;
+        };
+        success: boolean;
+        errors: Array<{ code: number; message: string }>;
+        messages: string[];
+      }
       try {
-        let bucketOutput: BucketOutput;
+        let bucketOutput: R2Bucket;
 
-        if (ctx.event === "update" && ctx.output?.id) {
+        if (this.phase === "update" && this.output?.name) {
           // Get bucket details to verify it exists
           const headers: Record<string, string> = {};
           if (props.jurisdiction && props.jurisdiction !== "default") {
@@ -137,8 +131,7 @@ export class R2Bucket extends Resource(
           }
 
           const result = (await getResponse.json()) as CloudflareBucketResponse;
-          bucketOutput = {
-            id: result.result.name,
+          bucketOutput = this({
             name: result.result.name,
             location: result.result.location || "default",
             creationDate: Math.floor(
@@ -146,7 +139,7 @@ export class R2Bucket extends Resource(
             ),
             jurisdiction: props.jurisdiction || "default",
             type: "r2_bucket",
-          };
+          });
 
           // Update public access setting if it has changed
           if (props.allowPublicAccess !== undefined) {
@@ -184,8 +177,7 @@ export class R2Bucket extends Resource(
 
           const result =
             (await createResponse.json()) as CloudflareBucketResponse;
-          bucketOutput = {
-            id: result.result.name,
+          bucketOutput = this({
             name: result.result.name,
             location: result.result.location || "default",
             creationDate: Math.floor(
@@ -193,7 +185,7 @@ export class R2Bucket extends Resource(
             ),
             jurisdiction: props.jurisdiction || "default",
             type: "r2_bucket",
-          };
+          });
 
           // Set public access if requested
           if (props.allowPublicAccess) {
@@ -208,7 +200,7 @@ export class R2Bucket extends Resource(
       }
     }
   },
-) {}
+);
 
 /**
  * Helper function to update the public access setting for a bucket

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

@@ -1,5 +1,3 @@
-import type { Resolved } from "../output";
-
 export interface DurableObjectNamespaceInput {
   className: string;
   scriptName?: string | undefined;
@@ -8,14 +6,6 @@ export interface DurableObjectNamespaceInput {
   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

package/src/cloudflare/generate-asset-manifest.ts

@@ -2,7 +2,7 @@ import crypto from "crypto";
 import { promises as fs } from "fs";
 import { glob } from "glob";
 import path from "path";
-import { getContentType } from "../utils/content-type";
+import { getContentType } from "../util/content-type";
 import type {
   AssetManifest,
   AssetManifestEntry,