alchemy 0.25.0 → 0.26.1

package/src/cloudflare/dns-records.ts

@@ -5,6 +5,7 @@ import type {
   DnsRecordWithMetadata,
 } from "../dns/record.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 import {
   type CloudflareApi,
   type CloudflareApiOptions,
@@ -146,12 +147,12 @@ export const DnsRecords = Resource(
                 `/zones/${zoneId}/dns_records/${record.id}`,
               );
               if (!response.ok && response.status !== 404) {
-                console.error(
+                logger.error(
                   `Failed to delete DNS record ${record.name}: ${response.statusText}`,
                 );
               }
             } catch (error) {
-              console.error(`Error deleting DNS record ${record.name}:`, error);
+              logger.error(`Error deleting DNS record ${record.name}:`, error);
             }
           }),
         );
@@ -181,12 +182,12 @@ export const DnsRecords = Resource(
               `/zones/${zoneId}/dns_records/${record.id}`,
             );
             if (!response.ok && response.status !== 404) {
-              console.error(
+              logger.error(
                 `Failed to delete DNS record ${record.name}: ${response.statusText}`,
               );
             }
           } catch (error) {
-            console.error(`Error deleting DNS record ${record.name}:`, error);
+            logger.error(`Error deleting DNS record ${record.name}:`, error);
           }
         }),
       );

package/src/cloudflare/do-state-store/worker.ts

@@ -11,6 +11,10 @@ interface Env {
 
 export default class extends WorkerEntrypoint<Env> {
   override async fetch(request: Request) {
+    const url = new URL(request.url);
+    if (url.pathname === "/health-check") {
+      return new Response("OK", { status: 200 });
+    }
     try {
       const result = await this.handle(request);
       const body: DOStateStoreAPI.Response = {

package/src/cloudflare/email-address.ts

@@ -0,0 +1,203 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { handleApiError } from "./api-error.ts";
+import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
+import type { CloudflareResponse } from "./response.ts";
+
+/**
+ * Cloudflare Email Address response format
+ */
+interface CloudflareEmailAddress {
+  email: string;
+  verified: boolean;
+  created: string;
+  modified: string;
+  tag: string;
+}
+
+/**
+ * Properties for creating an email destination address
+ */
+export interface EmailAddressProps extends CloudflareApiOptions {
+  /**
+   * Destination email address for routing
+   */
+  email: string;
+
+  /**
+   * Whether to automatically verify the email address if possible
+   * Note: Verification typically requires email confirmation by the recipient
+   *
+   * @default false
+   */
+  verified?: boolean;
+}
+
+/**
+ * A destination email address for Cloudflare email routing
+ */
+export interface EmailAddress extends Resource<"cloudflare::EmailAddress"> {
+  /**
+   * The email address
+   */
+  email: string;
+
+  /**
+   * Whether the email address has been verified
+   */
+  verified: boolean;
+
+  /**
+   * When the email address was created
+   */
+  created: string;
+
+  /**
+   * When the email address was last modified
+   */
+  modified: string;
+
+  /**
+   * Email address tag
+   */
+  tag: string;
+}
+
+/**
+ * Manages destination email addresses for Cloudflare email routing.
+ * These addresses can be used as targets in email routing rules.
+ *
+ * @example
+ * ## Add a destination email address
+ *
+ * Add an email address that can receive routed emails.
+ *
+ * ```ts
+ * const emailAddress = await EmailAddress("admin-email", {
+ *   email: "admin@company.com"
+ * });
+ *
+ * // Note: The email address will need to be verified before it can receive emails
+ * console.log(`Verified: ${emailAddress.verified}`);
+ * ```
+ *
+ * @example
+ * ## Add multiple destination addresses
+ *
+ * Create multiple destination addresses for different routing purposes.
+ *
+ * ```ts
+ * const supportEmail = await EmailAddress("support-email", {
+ *   email: "support@company.com"
+ * });
+ *
+ * const salesEmail = await EmailAddress("sales-email", {
+ *   email: "sales@company.com"
+ * });
+ * ```
+ */
+export const EmailAddress = Resource(
+  "cloudflare::EmailAddress",
+  async function (
+    this: Context<EmailAddress>,
+    _id: string,
+    props: EmailAddressProps,
+  ): Promise<EmailAddress> {
+    const api = await createCloudflareApi(props);
+
+    if (this.phase === "delete") {
+      if (this.output?.email) {
+        const response = await api.delete(
+          `/accounts/${api.accountId}/email/routing/addresses/${encodeURIComponent(this.output.email)}`,
+        );
+        if (!response.ok && response.status !== 404) {
+          await handleApiError(response, "delete", "email address");
+        }
+      }
+      return this.destroy();
+    }
+
+    if (this.phase === "update" && this.output) {
+      // Email addresses cannot be updated, only created or deleted
+      // If the email changed, we need to delete the old one and create a new one
+      if (this.output.email !== props.email) {
+        // Delete the old email address
+        const deleteResponse = await api.delete(
+          `/accounts/${api.accountId}/email/routing/addresses/${encodeURIComponent(this.output.email)}`,
+        );
+        if (!deleteResponse.ok && deleteResponse.status !== 404) {
+          await handleApiError(deleteResponse, "delete", "old email address");
+        }
+
+        // Create the new email address (fall through to create logic)
+      } else {
+        // Get current state
+        const getResponse = await api.get(
+          `/accounts/${api.accountId}/email/routing/addresses/${encodeURIComponent(props.email)}`,
+        );
+        if (!getResponse.ok) {
+          if (getResponse.status === 404) {
+            // Email address was deleted externally, recreate it
+          } else {
+            await handleApiError(getResponse, "get", "email address");
+          }
+        } else {
+          const result =
+            (await getResponse.json()) as CloudflareResponse<CloudflareEmailAddress>;
+
+          return this({
+            email: result.result.email,
+            verified: result.result.verified,
+            created: result.result.created,
+            modified: result.result.modified,
+            tag: result.result.tag,
+          });
+        }
+      }
+    }
+
+    // Check if email address already exists
+    const getResponse = await api.get(
+      `/accounts/${api.accountId}/email/routing/addresses/${encodeURIComponent(props.email)}`,
+    );
+
+    if (getResponse.ok) {
+      // Email address already exists, return it
+      const result =
+        (await getResponse.json()) as CloudflareResponse<CloudflareEmailAddress>;
+
+      return this({
+        email: result.result.email,
+        verified: result.result.verified,
+        created: result.result.created,
+        modified: result.result.modified,
+        tag: result.result.tag,
+      });
+    }
+
+    // Create new email address
+    const createPayload = {
+      email: props.email,
+    };
+
+    const createResponse = await api.post(
+      `/accounts/${api.accountId}/email/routing/addresses`,
+      createPayload,
+    );
+
+    if (!createResponse.ok) {
+      await handleApiError(createResponse, "create", "email address");
+    }
+
+    const result =
+      (await createResponse.json()) as CloudflareResponse<CloudflareEmailAddress>;
+
+    return this({
+      email: result.result.email,
+      verified: result.result.verified,
+      created: result.result.created,
+      modified: result.result.modified,
+      tag: result.result.tag,
+    });
+  },
+);

package/src/cloudflare/email-catch-all.ts

@@ -0,0 +1,248 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
+import type { CloudflareResponse } from "./response.ts";
+import type { EmailAction, EmailMatcher } from "./email-rule.ts";
+import type { Zone } from "./zone.ts";
+
+/**
+ * Cloudflare Email Catch All response format
+ */
+interface CloudflareEmailCatchAll {
+  enabled: boolean;
+  name: string;
+  matchers: EmailMatcher[];
+  actions: EmailAction[];
+  tag: string;
+}
+
+/**
+ * Properties for configuring the catch-all email rule
+ */
+export interface EmailCatchAllProps extends CloudflareApiOptions {
+  /**
+   * Zone ID or Zone resource where the catch-all rule will be configured
+   */
+  zone: string | Zone;
+
+  /**
+   * Whether the catch-all rule is enabled
+   *
+   * @default true
+   */
+  enabled?: boolean;
+
+  /**
+   * Name for the catch-all rule
+   *
+   * @default "Catch All"
+   */
+  name?: string;
+
+  /**
+   * Matchers for the catch-all rule (typically matches all emails)
+   * If not provided, defaults to matching all emails
+   */
+  matchers?: EmailMatcher[];
+
+  /**
+   * Actions to take for emails that don't match other rules
+   */
+  actions: EmailAction[];
+}
+
+/**
+ * A catch-all email routing rule for a Cloudflare zone
+ */
+export interface EmailCatchAll extends Resource<"cloudflare::EmailCatchAll"> {
+  /**
+   * Zone ID where the catch-all rule is configured
+   */
+  zoneId: string;
+
+  /**
+   * Whether the catch-all rule is enabled
+   */
+  enabled: boolean;
+
+  /**
+   * Rule name
+   */
+  name: string;
+
+  /**
+   * Matchers for the catch-all rule
+   */
+  matchers: EmailMatcher[];
+
+  /**
+   * Actions for the catch-all rule
+   */
+  actions: EmailAction[];
+
+  /**
+   * Rule tag
+   */
+  tag: string;
+}
+
+/**
+ * Configures a catch-all email routing rule that handles emails not matched by other rules.
+ * This rule is processed last and typically matches all emails that haven't been handled.
+ *
+ * @example
+ * ## Forward all unmatched emails
+ *
+ * Set up a catch-all rule to forward any unmatched emails to an admin address.
+ *
+ * ```ts
+ * const catchAll = await EmailCatchAll("default-catchall", {
+ *   zone: "example.com",
+ *   enabled: true,
+ *   actions: [
+ *     {
+ *       type: "forward",
+ *       value: ["admin@company.com"]
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ## Drop unmatched emails
+ *
+ * Configure catch-all to drop any emails that don't match specific rules.
+ *
+ * ```ts
+ * const catchAll = await EmailCatchAll("drop-catchall", {
+ *   zone: "example.com",
+ *   enabled: true,
+ *   actions: [
+ *     {
+ *       type: "drop"
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * ## Process with Worker
+ *
+ * Use a Worker to handle all unmatched emails for custom processing.
+ *
+ * ```ts
+ * const catchAll = await EmailCatchAll("worker-catchall", {
+ *   zone: "example.com",
+ *   enabled: true,
+ *   actions: [
+ *     {
+ *       type: "worker",
+ *       value: ["email-processor"]
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+export const EmailCatchAll = Resource(
+  "cloudflare::EmailCatchAll",
+  async function (
+    this: Context<EmailCatchAll>,
+    _id: string,
+    props: EmailCatchAllProps,
+  ): Promise<EmailCatchAll> {
+    const api = await createCloudflareApi(props);
+    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+
+    if (this.phase === "delete") {
+      // Disable the catch-all rule by setting enabled to false
+      const disablePayload = {
+        enabled: false,
+        name: "Catch All",
+        matchers: [{ type: "all" as const }],
+        actions: [{ type: "drop" as const }],
+      };
+
+      const response = await api.put(
+        `/zones/${zoneId}/email/routing/rules/catch_all`,
+        disablePayload,
+      );
+      if (!response.ok && response.status !== 404) {
+        throw new Error(
+          `Failed to disable catch-all rule: ${response.statusText}`,
+        );
+      }
+      return this.destroy();
+    }
+
+    // Get current catch-all rule state
+    const _getResponse = await api.get(
+      `/zones/${zoneId}/email/routing/rules/catch_all`,
+    );
+
+    if (this.phase === "update" && this.output) {
+      // Update the catch-all rule
+      const updatePayload = {
+        enabled: props.enabled ?? true,
+        name: props.name || "Catch All",
+        matchers: props.matchers || [{ type: "all" as const }],
+        actions: props.actions,
+      };
+
+      const response = await api.put(
+        `/zones/${zoneId}/email/routing/rules/catch_all`,
+        updatePayload,
+      );
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(
+          `Failed to update catch-all rule: ${response.statusText}\nResponse: ${errorBody}`,
+        );
+      }
+
+      const result =
+        (await response.json()) as CloudflareResponse<CloudflareEmailCatchAll>;
+
+      return this({
+        zoneId,
+        enabled: result.result.enabled,
+        name: result.result.name,
+        matchers: result.result.matchers,
+        actions: result.result.actions,
+        tag: result.result.tag,
+      });
+    }
+
+    // Create or update catch-all rule
+    const catchAllPayload = {
+      enabled: props.enabled ?? true,
+      name: props.name || "Catch All",
+      matchers: props.matchers || [{ type: "all" as const }],
+      actions: props.actions,
+    };
+
+    const response = await api.put(
+      `/zones/${zoneId}/email/routing/rules/catch_all`,
+      catchAllPayload,
+    );
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(
+        `Failed to configure catch-all rule: ${response.statusText}\nResponse: ${errorBody}`,
+      );
+    }
+
+    const result =
+      (await response.json()) as CloudflareResponse<CloudflareEmailCatchAll>;
+
+    return this({
+      zoneId,
+      enabled: result.result.enabled,
+      name: result.result.name,
+      matchers: result.result.matchers,
+      actions: result.result.actions,
+      tag: result.result.tag,
+    });
+  },
+);