alchemy 0.1.11 → 0.1.13

package/src/alchemize.ts

@@ -51,6 +51,7 @@ export async function alchemize(options?: AlchemizeOptions) {
   const stateStore = new (options?.stateStore ?? defaultStateStore)(
     scope.getScopePath(stage),
   );
+  const callbacks = scope.callbacks;
 
   if (nodes.size > 0) {
     await stateStore.init?.();
@@ -81,6 +82,17 @@ export async function alchemize(options?: AlchemizeOptions) {
     if (options?.destroyOrphans === false) {
       return;
     }
+
+    await Promise.all(
+      callbacks.map((callback) =>
+        evaluate(callback, {
+          stage,
+          scope,
+          stateStore,
+          quiet: options?.quiet,
+        }),
+      ),
+    );
   }
   const aliveIDs = new Set(
     mode === "up"

package/src/apply.ts

@@ -1,5 +1,5 @@
 import { defaultStage, defaultStateStore } from "./global";
-import { Output } from "./output";
+import { type Output, OutputChain, type Resolved } from "./output";
 import {
   Input,
   Provider,
@@ -23,9 +23,9 @@ export interface ApplyOptions {
  * @returns The resource properties.
  */
 export async function apply<T>(
-  output: T | Output<T>,
+  output: T,
   options?: Partial<ApplyOptions>,
-): Promise<T> {
+): Promise<Resolved<T>> {
   const stage = options?.stage ?? defaultStage;
   const scope = options?.scope ?? getScope();
   const statePath = scope.getScopePath(stage);
@@ -33,7 +33,7 @@ export async function apply<T>(
 
   return (
     await evaluate(output, { stage, scope, stateStore, quiet: options?.quiet })
-  ).value;
+  ).value as Resolved<T>;
 }
 
 class Evaluated<T> {
@@ -83,11 +83,11 @@ export async function evaluate<T>(
       );
       resolve!(new Evaluated(result, [resourceID, ...deps]));
     } catch (error) {
-      console.error(error);
+      // console.error(error);
       reject!(error);
     }
     return promise;
-  } else if (output instanceof Output) {
+  } else if (output instanceof OutputChain) {
     const inside = output as unknown as {
       parent: Output<any>;
       fn: (value: any) => T;

package/src/aws/index.ts

@@ -3,4 +3,5 @@ export * from "./function";
 export * from "./policy";
 export * from "./queue";
 export * from "./role";
+export * from "./ses";
 export * from "./table";

package/src/aws/ses.ts

@@ -0,0 +1,346 @@
+import {
+  AlreadyExistsException,
+  CreateConfigurationSetCommand,
+  CreateEmailIdentityCommand,
+  DeleteConfigurationSetCommand,
+  DeleteEmailIdentityCommand,
+  type DeliveryOptions,
+  GetConfigurationSetCommand,
+  GetEmailIdentityCommand,
+  NotFoundException,
+  PutEmailIdentityDkimAttributesCommand,
+  type ReputationOptions,
+  SESv2Client,
+  type SendingOptions,
+  type SuppressionOptions,
+  type TrackingOptions,
+} from "@aws-sdk/client-sesv2";
+import { ignore } from "../error";
+import { type Context, Resource } from "../resource";
+
+/**
+ * Properties for configuring AWS SES resources
+ */
+export interface SESProps {
+  /**
+   * Name of the configuration set
+   */
+  configurationSetName?: string;
+
+  /**
+   * Email identity to verify (email address or domain)
+   */
+  emailIdentity?: string;
+
+  /**
+   * Whether to enable DKIM signing for the email identity
+   */
+  enableDkim?: boolean;
+
+  /**
+   * Sending options for the configuration set
+   */
+  sendingOptions?: SendingOptions;
+
+  /**
+   * Reputation options for the configuration set
+   */
+  reputationOptions?: ReputationOptions;
+
+  /**
+   * Tracking options for the configuration set
+   */
+  trackingOptions?: TrackingOptions;
+
+  /**
+   * Suppression options for the configuration set
+   */
+  suppressionOptions?: SuppressionOptions;
+
+  /**
+   * Delivery options for the configuration set
+   */
+  deliveryOptions?: DeliveryOptions;
+
+  /**
+   * Tags to apply to the SES resources
+   */
+  tags?: Record<string, string>;
+}
+
+/**
+ * Output returned after SES resource creation/update
+ */
+export interface SESOutput extends SESProps {
+  /**
+   * Resource ID
+   */
+  id: string;
+
+  /**
+   * ARN of the configuration set if created
+   */
+  configurationSetArn?: string;
+
+  /**
+   * Email identity verification status if an identity was created
+   */
+  emailIdentityVerificationStatus?: string;
+
+  /**
+   * DKIM verification status if DKIM was enabled
+   */
+  dkimVerificationStatus?: string;
+
+  /**
+   * Email identity ARN if an identity was created
+   */
+  emailIdentityArn?: string;
+}
+
+/**
+ * AWS SES resource for creating and configuring Simple Email Service
+ */
+export class SES extends Resource(
+  "aws::SES",
+  async (ctx: Context<SESOutput>, props: SESProps): Promise<SESOutput> => {
+    // 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;
+
+    // Handle deletion
+    if (ctx.event === "delete") {
+      const output = ctx.output;
+
+      // Delete configuration set if it exists
+      if (output?.configurationSetName) {
+        await ignore(NotFoundException.name, () =>
+          client.send(
+            new DeleteConfigurationSetCommand({
+              ConfigurationSetName: output.configurationSetName,
+            }),
+          ),
+        );
+      }
+
+      // Delete email identity if it exists
+      if (output?.emailIdentity) {
+        await ignore(NotFoundException.name, () =>
+          client.send(
+            new DeleteEmailIdentityCommand({
+              EmailIdentity: output.emailIdentity,
+            }),
+          ),
+        );
+      }
+
+      // Return empty output for delete
+      return {
+        ...props,
+        id,
+      };
+    }
+
+    // Created resources
+    let configurationSetArn: string | undefined;
+    let emailIdentityArn: string | undefined;
+    let emailIdentityVerificationStatus: string | undefined;
+    let dkimVerificationStatus: string | undefined;
+
+    // Create or update configuration set if specified
+    if (props.configurationSetName) {
+      try {
+        // Check if configuration set exists
+        let getConfigResult;
+        try {
+          getConfigResult = await client.send(
+            new GetConfigurationSetCommand({
+              ConfigurationSetName: props.configurationSetName,
+            }),
+          );
+        } catch (error) {
+          if (error instanceof NotFoundException) {
+            getConfigResult = null;
+          } else {
+            throw error;
+          }
+        }
+
+        if (getConfigResult) {
+          // For updating configuration set, we need to use individual commands
+          // since there's no unified UpdateConfigurationSetCommand
+
+          if (props.sendingOptions) {
+            await client.send(
+              new CreateConfigurationSetCommand({
+                ConfigurationSetName: props.configurationSetName,
+                SendingOptions: props.sendingOptions,
+              }),
+            );
+          }
+
+          if (props.reputationOptions) {
+            await client.send(
+              new CreateConfigurationSetCommand({
+                ConfigurationSetName: props.configurationSetName,
+                ReputationOptions: props.reputationOptions,
+              }),
+            );
+          }
+
+          if (props.trackingOptions) {
+            await client.send(
+              new CreateConfigurationSetCommand({
+                ConfigurationSetName: props.configurationSetName,
+                TrackingOptions: props.trackingOptions,
+              }),
+            );
+          }
+
+          if (props.suppressionOptions) {
+            await client.send(
+              new CreateConfigurationSetCommand({
+                ConfigurationSetName: props.configurationSetName,
+                SuppressionOptions: props.suppressionOptions,
+              }),
+            );
+          }
+
+          if (props.deliveryOptions) {
+            await client.send(
+              new CreateConfigurationSetCommand({
+                ConfigurationSetName: props.configurationSetName,
+                DeliveryOptions: props.deliveryOptions,
+              }),
+            );
+          }
+
+          // 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}`;
+        }
+      } 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;
+        }
+      }
+    }
+
+    // Create or verify email identity if specified
+    if (props.emailIdentity) {
+      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;
+          }
+        }
+
+        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,
+                }),
+              );
+
+              // 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;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        console.error(
+          `Error configuring email identity ${props.emailIdentity}:`,
+          error,
+        );
+        throw error;
+      }
+    }
+
+    // Return the resource output
+    return {
+      ...props,
+      id,
+      configurationSetArn,
+      emailIdentityArn,
+      emailIdentityVerificationStatus,
+      dkimVerificationStatus,
+    };
+  },
+) {}

package/src/cloudflare/api.ts

@@ -0,0 +1,282 @@
+import { type CloudflareAuthOptions, getCloudflareHeaders } from "./auth";
+
+/**
+ * Options for Cloudflare API requests
+ */
+export interface CloudflareApiOptions {
+  /**
+   * API Key to use (overrides CLOUDFLARE_API_KEY env var)
+   */
+  apiKey?: string;
+
+  /**
+   * Account ID to use (overrides CLOUDFLARE_ACCOUNT_ID env var)
+   * If not provided, will be automatically retrieved from the Cloudflare API
+   */
+  accountId?: string;
+
+  /**
+   * Zone ID to use (overrides CLOUDFLARE_ZONE_ID env var)
+   */
+  zoneId?: string;
+
+  /**
+   * Email to use with API Key authentication
+   * If not provided, will attempt to discover from Cloudflare API
+   */
+  email?: string;
+}
+
+/**
+ * Account information returned from Cloudflare API
+ */
+interface CloudflareAccount {
+  id: string;
+  name: string;
+}
+
+/**
+ * Creates a CloudflareApi instance with automatic account ID discovery if not provided
+ *
+ * @param options API options
+ * @returns Promise resolving to a CloudflareApi instance
+ */
+export async function createCloudflareApi(
+  options: CloudflareApiOptions = {},
+): Promise<CloudflareApi> {
+  try {
+    return new CloudflareApi({
+      ...options,
+      accountId:
+        options.accountId ||
+        process.env.CLOUDFLARE_ACCOUNT_ID ||
+        (await fetchAccountId()),
+    });
+  } catch (error) {
+    console.error("Error during Cloudflare account ID discovery:", error);
+    throw new Error(
+      "Failed to automatically discover Cloudflare account ID. Please provide an account ID explicitly or ensure your API token/key has sufficient permissions.",
+    );
+  }
+}
+
+/**
+ * Cloudflare API client using raw fetch
+ */
+export class CloudflareApi {
+  /** Base URL for Cloudflare API */
+  readonly baseUrl: string;
+
+  /** Cloudflare API Key */
+  readonly apiKey: string;
+
+  /** Cloudflare account ID */
+  readonly accountId: string;
+
+  /** Cloudflare zone ID (if provided) */
+  readonly zoneId: string | null;
+
+  /** User email (when using API Key auth) */
+  readonly email?: string;
+
+  /** Auth options for making requests */
+  private readonly authOptions: CloudflareAuthOptions;
+
+  /**
+   * Create a new Cloudflare API client
+   * Use createCloudflareApi factory function instead of direct constructor
+   * for automatic account ID discovery.
+   *
+   * @param options API options
+   */
+  constructor(options: CloudflareApiOptions = {}) {
+    this.baseUrl = "https://api.cloudflare.com/client/v4";
+
+    const apiKey =
+      options.apiKey || process.env.CLOUDFLARE_API_KEY || undefined;
+    if (!apiKey) {
+      throw new Error(
+        "No API key provided. Use createCloudflareApi() instead for automatic account discovery.",
+      );
+    }
+    this.apiKey = apiKey;
+
+    this.email = options.email || process.env.CLOUDFLARE_EMAIL;
+    if (!this.email) {
+      throw new Error(
+        "No email provided. Use createCloudflareApi() instead for automatic account discovery.",
+      );
+    }
+
+    // Get account ID from options or environment
+    this.accountId =
+      options.accountId || process.env.CLOUDFLARE_ACCOUNT_ID || "";
+    if (!this.accountId) {
+      throw new Error(
+        "No account ID provided. Use createCloudflareApi() instead for automatic account discovery.",
+      );
+    }
+
+    // Zone ID is optional for some operations
+    this.zoneId = options.zoneId || process.env.CLOUDFLARE_ZONE_ID || null;
+
+    // Store auth options for later use
+    this.authOptions = {
+      email: this.email,
+    };
+  }
+
+  /**
+   * Make a fetch request to the Cloudflare API
+   *
+   * @param path API path (without base URL)
+   * @param init Fetch init options
+   * @returns Raw Response object from fetch
+   */
+  async fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    // Get content type from init headers or default to application/json
+    let contentType = "application/json";
+    if (init.headers) {
+      const initHeaders = init.headers as Record<string, string>;
+      if (initHeaders["Content-Type"]) {
+        contentType = initHeaders["Content-Type"];
+      }
+    }
+
+    // Get auth headers (async now)
+    const authHeaders = await getCloudflareHeaders(
+      contentType,
+      this.authOptions,
+    );
+
+    // Combine all headers
+    const combinedHeaders: Record<string, string> = {
+      ...authHeaders,
+    };
+
+    // Add headers from init if provided
+    if (init.headers) {
+      const initHeadersObj = init.headers as Record<string, string>;
+      Object.keys(initHeadersObj).forEach((key) => {
+        combinedHeaders[key] = initHeadersObj[key];
+      });
+    }
+
+    // If using FormData, remove Content-Type to let browser set it with boundary
+    if (init.body instanceof FormData) {
+      delete combinedHeaders["Content-Type"];
+    }
+
+    const url = `${this.baseUrl}${path}`;
+
+    // Make the request
+    return fetch(url, {
+      ...init,
+      headers: combinedHeaders,
+    });
+  }
+
+  /**
+   * Helper for GET requests
+   */
+  async get(path: string, init: RequestInit = {}): Promise<Response> {
+    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
+   */
+  async post(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    const requestBody =
+      body instanceof FormData
+        ? body
+        : typeof body === "string"
+          ? body
+          : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "POST", body: requestBody });
+  }
+
+  /**
+   * Helper for PUT requests
+   */
+  async put(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    const requestBody = body instanceof FormData ? body : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "PUT", body: requestBody });
+  }
+
+  /**
+   * Helper for PATCH requests
+   */
+  async patch(
+    path: string,
+    body: any,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    return this.fetch(path, {
+      ...init,
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Helper for DELETE requests
+   */
+  async delete(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "DELETE" });
+  }
+}
+
+/**
+ * Create a temporary API client for bootstrapping
+ * This client can only be used to fetch the account ID
+ */
+async function fetchAccountId(): Promise<string> {
+  // Create a minimal API client for bootstrapping
+  const baseUrl = "https://api.cloudflare.com/client/v4";
+
+  // Get content type and auth headers
+  const authHeaders = await getCloudflareHeaders("application/json");
+
+  // Make the request to get accounts
+  const response = await fetch(`${baseUrl}/accounts`, {
+    method: "GET",
+    headers: authHeaders,
+  });
+
+  if (!response.ok) {
+    const errorData: any = await response.json().catch(() => ({
+      errors: [{ message: response.statusText }],
+    }));
+
+    throw new Error(
+      `Error fetching Cloudflare accounts: ${errorData.errors?.[0]?.message || response.statusText}`,
+    );
+  }
+
+  const data: any = await response.json();
+  const accounts = data.result as CloudflareAccount[];
+
+  if (!accounts || accounts.length === 0) {
+    throw new Error(
+      "No Cloudflare accounts found. Check your API token/key permissions.",
+    );
+  }
+
+  // Return the first account ID
+  return accounts[0].id;
+}