alchemy 0.91.2 → 0.92.2

package/src/cloudflare/email-rule.ts

@@ -1,7 +1,8 @@
 import type { Context } from "../context.ts";
-import { Resource } from "../resource.ts";
+import { Resource, ResourceKind } from "../resource.ts";
 import { handleApiError } from "./api-error.ts";
 import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
+import { resolveEmailZoneId } from "./email-common.ts";
 import type { CloudflareResponse } from "./response.ts";
 import type { Zone } from "./zone.ts";
 
@@ -19,7 +20,7 @@ export interface EmailMatcher {
   /**
    * Field to match against (required for literal matchers)
    */
-  field?: "to" | "from" | "subject";
+  field?: "to";
 
   /**
    * Value to match (required for literal matchers)
@@ -141,9 +142,42 @@ export interface EmailRule {
   actions: EmailAction[];
 
   /**
-   * Rule tag
+   * Deprecated rule tag returned by the Cloudflare API.
    */
-  tag: string;
+  tag?: string;
+}
+
+export function isEmailRule(resource: any): resource is EmailRule {
+  return resource?.[ResourceKind] === "cloudflare::EmailRule";
+}
+
+function validateMatchers(matchers: EmailMatcher[]) {
+  for (const matcher of matchers) {
+    if (matcher.type === "all") {
+      continue;
+    }
+    if (matcher.field !== "to") {
+      throw new Error(
+        'EmailRule literal matchers currently only support field: "to".',
+      );
+    }
+    if (!matcher.value) {
+      throw new Error("EmailRule literal matchers require a value.");
+    }
+  }
+}
+
+function validateActions(actions: EmailAction[]) {
+  for (const action of actions) {
+    if (action.type === "drop") {
+      continue;
+    }
+    if (!action.value?.length) {
+      throw new Error(
+        `EmailRule action "${action.type}" requires at least one value.`,
+      );
+    }
+  }
 }
 
 /**
@@ -235,7 +269,9 @@ export const EmailRule = Resource(
     props: EmailRuleProps,
   ): Promise<EmailRule> {
     const api = await createCloudflareApi(props);
-    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+    const zoneId = await resolveEmailZoneId(api, props.zone);
+    validateMatchers(props.matchers);
+    validateActions(props.actions);
 
     if (this.phase === "delete") {
       if (this.output?.ruleId) {
@@ -282,7 +318,7 @@ export const EmailRule = Resource(
           priority: result.result.priority,
           matchers: result.result.matchers,
           actions: result.result.actions,
-          tag: result.result.tag,
+          tag: result.result.tag || undefined,
         };
       }
     }
@@ -316,7 +352,7 @@ export const EmailRule = Resource(
       priority: result.result.priority,
       matchers: result.result.matchers,
       actions: result.result.actions,
-      tag: result.result.tag,
+      tag: result.result.tag || undefined,
     };
   },
 );

package/src/cloudflare/email-sender.ts

@@ -0,0 +1,49 @@
+export interface BaseEmailSenderProps {
+  allowedSenderAddresses?: string[];
+  dev?: {
+    remote?: boolean;
+  };
+}
+
+export type EmailSenderProps = BaseEmailSenderProps &
+  (
+    | {
+        destinationAddress?: string;
+        allowedDestinationAddresses?: never;
+      }
+    | {
+        destinationAddress?: never;
+        allowedDestinationAddresses?: string[];
+      }
+  );
+
+/**
+ * Type representing a Cloudflare Email Service send binding.
+ * @see https://developers.cloudflare.com/email-service/api/send-emails/workers-api/
+ */
+export type EmailSender = EmailSenderProps & {
+  type: "send_email";
+};
+
+/**
+ * Creates a Cloudflare Email Service binding for sending emails from Workers.
+ *
+ * Set `dev.remote` to `true` to use the real Cloudflare email binding while
+ * running the Worker locally.
+ *
+ * @example
+ * ```ts
+ * const email = EmailSender({
+ *   allowedSenderAddresses: ["noreply@example.com"],
+ *   dev: { remote: true },
+ * });
+ * ```
+ *
+ * @see https://developers.cloudflare.com/email-service/api/send-emails/workers-api/
+ */
+export function EmailSender(props: EmailSenderProps = {}): EmailSender {
+  return {
+    type: "send_email",
+    ...props,
+  };
+}

package/src/cloudflare/index.ts

@@ -38,6 +38,7 @@ export * from "./email-address.ts";
 export * from "./email-catch-all.ts";
 export * from "./email-routing.ts";
 export * from "./email-rule.ts";
+export * from "./email-sender.ts";
 export * from "./health-check.ts";
 export * from "./hyperdrive-ref.ts";
 export * from "./hyperdrive.ts";

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -50,7 +50,10 @@ type RemoteBinding =
       }
     > & { raw: true })
   // Fetcher type bindings do not require the `raw` flag and will throw an error if it is present.
-  | Extract<WorkerBindingSpec, { type: "service" | "vpc_service" }>;
+  | Extract<
+      WorkerBindingSpec,
+      { type: "send_email" | "service" | "vpc_service" }
+    >;
 
 type BaseWorkerOptions = {
   [K in keyof miniflare.WorkerOptions]: K extends
@@ -261,6 +264,36 @@ export const buildWorkerOptions = async (
         (options.bindings ??= {})[key] = binding.unencrypted;
         break;
       }
+      case "send_email": {
+        const config = {
+          name: key,
+          destination_address: binding.destinationAddress,
+          allowed_destination_addresses: binding.allowedDestinationAddresses,
+          allowed_sender_addresses: binding.allowedSenderAddresses,
+        };
+        if (isRemoteBinding(binding)) {
+          remoteBindings.push({
+            type: "send_email",
+            ...config,
+          });
+        } else {
+          ((
+            options as BaseWorkerOptions & {
+              email?: {
+                send_email?: Array<typeof config>;
+              };
+            }
+          ).email ??= {}).send_email ??= [];
+          (
+            options as BaseWorkerOptions & {
+              email: {
+                send_email: Array<typeof config>;
+              };
+            }
+          ).email.send_email.push(config);
+        }
+        break;
+      }
       case "secret_key": {
         throw new Error("Secret keys are not supported in local mode");
       }
@@ -441,6 +474,41 @@ export const buildWorkerOptions = async (
             remoteProxyConnectionString: remoteProxy.connectionString,
           };
           break;
+        case "send_email":
+          ((
+            options as BaseWorkerOptions & {
+              email?: {
+                send_email?: Array<{
+                  name: string;
+                  destination_address?: string;
+                  allowed_destination_addresses?: string[];
+                  allowed_sender_addresses?: string[];
+                  remoteProxyConnectionString: typeof remoteProxy.connectionString;
+                }>;
+              };
+            }
+          ).email ??= {}).send_email ??= [];
+          (
+            options as BaseWorkerOptions & {
+              email: {
+                send_email: Array<{
+                  name: string;
+                  destination_address?: string;
+                  allowed_destination_addresses?: string[];
+                  allowed_sender_addresses?: string[];
+                  remoteProxyConnectionString: typeof remoteProxy.connectionString;
+                }>;
+              };
+            }
+          ).email.send_email.push({
+            name: binding.name,
+            destination_address: binding.destination_address,
+            allowed_destination_addresses:
+              binding.allowed_destination_addresses,
+            allowed_sender_addresses: binding.allowed_sender_addresses,
+            remoteProxyConnectionString: remoteProxy.connectionString,
+          });
+          break;
         case "service":
           (options.serviceBindings ??= {})[binding.name] = {
             name: binding.name,

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -101,7 +101,7 @@ export class MiniflareController {
         unsafeDevRegistryPath: miniflare.getDefaultDevRegistryPath(),
         log: process.env.DEBUG
           ? new miniflare.Log(miniflare.LogLevel.DEBUG)
-          : undefined,
+          : new DefaultLogger(),
         // This is required to allow websites and other separate processes
         // to detect Alchemy-managed Durable Objects via the Wrangler dev registry.
         unsafeDevRegistryDurableObjectProxy: true,
@@ -170,3 +170,20 @@ export class MiniflareController {
     ]);
   }
 }
+
+class DefaultLogger extends miniflare.Log {
+  constructor() {
+    // Miniflare emits send_email activity at info level.
+    super(miniflare.LogLevel.INFO);
+  }
+
+  override info(message: string) {
+    if (
+      message.startsWith("Ready on") ||
+      message.startsWith("Updated and ready on")
+    ) {
+      return;
+    }
+    super.info(message);
+  }
+}

package/src/cloudflare/worker-metadata.ts

@@ -492,6 +492,14 @@ export async function prepareWorkerMetadata(
         jurisdiction:
           binding.jurisdiction === "default" ? undefined : binding.jurisdiction,
       });
+    } else if (binding.type === "send_email") {
+      meta.bindings.push({
+        type: "send_email",
+        name: bindingName,
+        destination_address: binding.destinationAddress,
+        allowed_destination_addresses: binding.allowedDestinationAddresses,
+        allowed_sender_addresses: binding.allowedSenderAddresses,
+      });
     } else if (binding.type === "secrets_store_secret") {
       meta.bindings.push({
         type: "secrets_store_secret",

package/src/cloudflare/wrangler.json.ts

@@ -263,6 +263,7 @@ async function processBindings(
   const durableObjects: WranglerJsonConfig["durable_objects"]["bindings"] = [];
   const r2Buckets: WranglerJsonConfig["r2_buckets"] = [];
   const services: WranglerJsonConfig["services"] = [];
+  const sendEmailBindings: WranglerJsonConfig["send_email"] = [];
   const secrets: string[] = [];
   const workflows: WranglerJsonConfig["workflows"] = [];
   const d1Databases: WranglerJsonConfig["d1_databases"] = [];
@@ -389,6 +390,14 @@ async function processBindings(
           binding.jurisdiction === "default" ? undefined : binding.jurisdiction,
         ...(binding.dev?.remote ? { remote: true } : {}),
       });
+    } else if (binding.type === "send_email") {
+      sendEmailBindings.push({
+        name: bindingName,
+        destination_address: binding.destinationAddress,
+        allowed_destination_addresses: binding.allowedDestinationAddresses,
+        allowed_sender_addresses: binding.allowedSenderAddresses,
+        ...(binding.dev?.remote ? { remote: true } : {}),
+      });
     } else if (binding.type === "secret") {
       // Secret binding
       secrets.push(bindingName);
@@ -569,6 +578,14 @@ async function processBindings(
     spec.services = services;
   }
 
+  if (sendEmailBindings.length > 0) {
+    (
+      spec as WranglerJsonSpec & {
+        send_email?: typeof sendEmailBindings;
+      }
+    ).send_email = sendEmailBindings;
+  }
+
   if (d1Databases.length > 0) {
     spec.d1_databases = d1Databases;
   }