alchemy 0.12.6 → 0.12.8

package/src/cloudflare/queue-consumer.ts

@@ -0,0 +1,433 @@
+import type { Context } from "../context.js";
+import { Resource } from "../resource.js";
+import { CloudflareApiError, handleApiError } from "./api-error.js";
+import {
+  CloudflareApi,
+  createCloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.js";
+import type { Queue } from "./queue.js";
+
+/**
+ * Settings for configuring a Queue Consumer
+ */
+export interface QueueConsumerSettings {
+  /**
+   * Number of messages to deliver in a batch
+   * @default 10
+   */
+  batchSize?: number;
+
+  /**
+   * Maximum number of concurrent consumer worker invocations
+   * @default 2
+   */
+  maxConcurrency?: number;
+
+  /**
+   * Maximum number of retries for each message
+   * @default 3
+   */
+  maxRetries?: number;
+
+  /**
+   * Maximum time in milliseconds to wait for batch to fill
+   * @default 500
+   */
+  maxWaitTimeMs?: number;
+
+  /**
+   * Time in seconds to delay retry after a failure
+   * @default 30
+   */
+  retryDelay?: number;
+}
+
+/**
+ * Properties for creating or updating a Queue Consumer
+ */
+export interface QueueConsumerProps extends CloudflareApiOptions {
+  /**
+   * The queue to consume
+   * Either queue or queueId must be provided
+   */
+  queue?: Queue;
+
+  /**
+   * The queue ID to consume (alternative to providing a queue)
+   * Either queue or queueId must be provided
+   */
+  queueId?: string;
+
+  /**
+   * Name of the worker script that will consume the queue
+   */
+  scriptName: string;
+
+  /**
+   * Settings for the consumer
+   */
+  settings?: QueueConsumerSettings;
+
+  /**
+   * Whether to delete the consumer.
+   * If set to false, the consumer will remain but the resource will be removed from state
+   * @default true
+   */
+  delete?: boolean;
+}
+
+/**
+ * Output returned after Queue Consumer creation/update
+ */
+export interface QueueConsumer
+  extends Resource<"cloudflare::QueueConsumer">,
+    QueueConsumerProps {
+  /**
+   * Unique ID for the consumer
+   */
+  id: string;
+
+  /**
+   * Type identifier for Cloudflare Queue Consumer
+   */
+  type: "worker";
+
+  /**
+   * ID of the queue being consumed
+   */
+  queueId: string;
+
+  /**
+   * Time when the consumer was created
+   */
+  createdOn?: string;
+}
+
+/**
+ * Creates a consumer for a Cloudflare Queue that processes messages using a Worker.
+ *
+ * @example
+ * // Create a queue consumer with default settings
+ * const queue = await Queue("notifications", {
+ *   name: "notifications"
+ * });
+ *
+ * const consumer = await QueueConsumer("notification-processor", {
+ *   queue,
+ *   scriptName: "notification-worker"
+ * });
+ *
+ * @example
+ * // Create a consumer with custom settings
+ * const batchConsumer = await QueueConsumer("batch-processor", {
+ *   queue,
+ *   scriptName: "batch-worker",
+ *   settings: {
+ *     batchSize: 50,         // Process 50 messages at once
+ *     maxConcurrency: 10,    // Allow 10 concurrent invocations
+ *     maxRetries: 5,         // Retry failed messages up to 5 times
+ *     maxWaitTimeMs: 2000,   // Wait up to 2 seconds to fill a batch
+ *     retryDelay: 60         // Wait 60 seconds before retrying failed messages
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/queues/platform/consumers/
+ */
+export const QueueConsumer = Resource(
+  "cloudflare::QueueConsumer",
+  async function (
+    this: Context<QueueConsumer>,
+    id: string,
+    props: QueueConsumerProps
+  ): Promise<QueueConsumer> {
+    const api = await createCloudflareApi(props);
+
+    // Get queueId from either props.queue or props.queueId
+    const queueId = props.queue?.id || props.queueId;
+
+    if (!queueId) {
+      throw new Error("Either queue or queueId must be provided");
+    }
+
+    if (this.phase === "delete") {
+      console.log(`Deleting Queue Consumer for queue ${queueId}`);
+      if (props.delete !== false && this.output?.id) {
+        // Delete the consumer
+        await deleteQueueConsumer(api, queueId, this.output.id);
+      }
+
+      // Return void (a deleted consumer has no content)
+      return this.destroy();
+    } else {
+      let consumerData: CloudflareQueueConsumerResponse;
+
+      if (this.phase === "create") {
+        console.log(`Creating Queue Consumer for queue ${queueId}`);
+        consumerData = await createQueueConsumer(api, queueId, props);
+      } else if (this.output?.id) {
+        console.log(`Updating Queue Consumer ${this.output.id}`);
+        consumerData = await updateQueueConsumer(
+          api,
+          queueId,
+          this.output.id,
+          props
+        );
+      } else {
+        // If no ID exists, fall back to creating a new consumer
+        console.log(
+          `No existing Consumer ID found, creating new Queue Consumer for queue ${queueId}`
+        );
+        consumerData = await createQueueConsumer(api, queueId, props);
+      }
+
+      return this({
+        id: consumerData.result.consumer_id,
+        queueId,
+        queue: props.queue,
+        type: "worker",
+        scriptName: props.scriptName,
+        settings: consumerData.result.settings
+          ? {
+              batchSize: consumerData.result.settings.batch_size,
+              maxConcurrency: consumerData.result.settings.max_concurrency,
+              maxRetries: consumerData.result.settings.max_retries,
+              maxWaitTimeMs: consumerData.result.settings.max_wait_time_ms,
+              retryDelay: consumerData.result.settings.retry_delay,
+            }
+          : undefined,
+        createdOn: consumerData.result.created_on,
+        accountId: api.accountId,
+      });
+    }
+  }
+);
+
+/**
+ * Response from Cloudflare API for Queue Consumer operations
+ */
+interface CloudflareQueueConsumerResponse {
+  result: {
+    consumer_id: string;
+    script_name: string;
+    settings?: {
+      batch_size?: number;
+      max_concurrency?: number;
+      max_retries?: number;
+      max_wait_time_ms?: number;
+      retry_delay?: number;
+    };
+    type: "worker";
+    queue_id?: string;
+    created_on?: string;
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+/**
+ * Create a new Queue Consumer
+ */
+export async function createQueueConsumer(
+  api: CloudflareApi,
+  queueId: string,
+  props: QueueConsumerProps
+): Promise<CloudflareQueueConsumerResponse> {
+  // Prepare the create payload
+  const createPayload: any = {
+    script_name: props.scriptName,
+    type: "worker",
+  };
+
+  // Add settings if provided
+  if (props.settings) {
+    createPayload.settings = {};
+
+    if (props.settings.batchSize !== undefined) {
+      createPayload.settings.batch_size = props.settings.batchSize;
+    }
+
+    if (props.settings.maxConcurrency !== undefined) {
+      createPayload.settings.max_concurrency = props.settings.maxConcurrency;
+    }
+
+    if (props.settings.maxRetries !== undefined) {
+      createPayload.settings.max_retries = props.settings.maxRetries;
+    }
+
+    if (props.settings.maxWaitTimeMs !== undefined) {
+      createPayload.settings.max_wait_time_ms = props.settings.maxWaitTimeMs;
+    }
+
+    if (props.settings.retryDelay !== undefined) {
+      createPayload.settings.retry_delay = props.settings.retryDelay;
+    }
+  }
+
+  const createResponse = await api.post(
+    `/accounts/${api.accountId}/queues/${queueId}/consumers`,
+    createPayload
+  );
+
+  if (!createResponse.ok) {
+    return await handleApiError(
+      createResponse,
+      "creating",
+      "Queue Consumer",
+      `for queue ${queueId}`
+    );
+  }
+
+  return (await createResponse.json()) as CloudflareQueueConsumerResponse;
+}
+
+/**
+ * Delete a Queue Consumer
+ */
+export async function deleteQueueConsumer(
+  api: CloudflareApi,
+  queueId: string,
+  consumerId: string
+): Promise<void> {
+  const deleteResponse = await api.delete(
+    `/accounts/${api.accountId}/queues/${queueId}/consumers/${consumerId}`
+  );
+
+  if (!deleteResponse.ok && deleteResponse.status !== 404) {
+    const errorData: any = await deleteResponse.json().catch(() => ({
+      errors: [{ message: deleteResponse.statusText }],
+    }));
+    throw new CloudflareApiError(
+      `Error deleting Queue Consumer '${consumerId}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
+      deleteResponse
+    );
+  }
+}
+
+/**
+ * Update a Queue Consumer
+ */
+async function updateQueueConsumer(
+  api: CloudflareApi,
+  queueId: string,
+  consumerId: string,
+  props: QueueConsumerProps
+): Promise<CloudflareQueueConsumerResponse> {
+  // Prepare the update payload
+  const updatePayload: any = {
+    script_name: props.scriptName,
+    type: "worker",
+  };
+
+  // Add settings if provided
+  if (props.settings) {
+    updatePayload.settings = {};
+
+    if (props.settings.batchSize !== undefined) {
+      updatePayload.settings.batch_size = props.settings.batchSize;
+    }
+
+    if (props.settings.maxConcurrency !== undefined) {
+      updatePayload.settings.max_concurrency = props.settings.maxConcurrency;
+    }
+
+    if (props.settings.maxRetries !== undefined) {
+      updatePayload.settings.max_retries = props.settings.maxRetries;
+    }
+
+    if (props.settings.maxWaitTimeMs !== undefined) {
+      updatePayload.settings.max_wait_time_ms = props.settings.maxWaitTimeMs;
+    }
+
+    if (props.settings.retryDelay !== undefined) {
+      updatePayload.settings.retry_delay = props.settings.retryDelay;
+    }
+  }
+
+  // Use PUT to update the consumer
+  const updateResponse = await api.put(
+    `/accounts/${api.accountId}/queues/${queueId}/consumers/${consumerId}`,
+    updatePayload
+  );
+
+  if (!updateResponse.ok) {
+    return await handleApiError(
+      updateResponse,
+      "updating",
+      "Queue Consumer",
+      consumerId
+    );
+  }
+
+  return (await updateResponse.json()) as CloudflareQueueConsumerResponse;
+}
+
+export interface ListQueueConsumersResponse {
+  id: string;
+  scriptName: string;
+  queueId: string;
+  queueName: string;
+  createdOn: string;
+  settings?: QueueConsumerSettings;
+}
+/**
+ * List all consumers for a queue
+ */
+export async function listQueueConsumers(
+  api: CloudflareApi,
+  queueId: string
+): Promise<ListQueueConsumersResponse[]> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/queues/${queueId}/consumers`
+  );
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to list queue consumers: ${response.statusText}`,
+      response
+    );
+  }
+
+  const data = (await response.json()) as {
+    success: boolean;
+    errors?: Array<{ code: number; message: string }>;
+    result?: Array<{
+      consumer_id: string;
+      script: string;
+      queue_id: string;
+      queue_name: string;
+      created_on: string;
+      settings?: {
+        batch_size?: number;
+        max_concurrency?: number;
+        max_retries?: number;
+        max_wait_time_ms?: number;
+        retry_delay?: number;
+      };
+    }>;
+  };
+
+  if (!data.success) {
+    const errorMessage = data.errors?.[0]?.message || "Unknown error";
+    throw new Error(`Failed to list queue consumers: ${errorMessage}`);
+  }
+
+  // Transform API response
+  return (data.result || []).map((consumer) => ({
+    id: consumer.consumer_id,
+    scriptName: consumer.script,
+    queueId: consumer.queue_id,
+    queueName: consumer.queue_name,
+    createdOn: consumer.created_on,
+    settings: consumer.settings
+      ? {
+          batchSize: consumer.settings.batch_size,
+          maxConcurrency: consumer.settings.max_concurrency,
+          maxRetries: consumer.settings.max_retries,
+          maxWaitTimeMs: consumer.settings.max_wait_time_ms,
+          retryDelay: consumer.settings.retry_delay,
+        }
+      : undefined,
+  }));
+}

package/src/cloudflare/queue.ts

@@ -38,8 +38,10 @@ export interface QueueProps extends CloudflareApiOptions {
    * Name of the queue
    * Required during creation
    * Cannot be changed after creation
+   *
+   * @default id
    */
-  name: string;
+  name?: string;
 
   /**
    * Settings for the queue
@@ -56,10 +58,16 @@ export interface QueueProps extends CloudflareApiOptions {
   delete?: boolean;
 }
 
+export function isQueue(eventSource: any): eventSource is Queue {
+  return "Kind" in eventSource && eventSource.Kind === "cloudflare::Queue";
+}
+
 /**
  * Output returned after Cloudflare Queue creation/update
  */
-export interface Queue extends Resource<"cloudflare::Queue">, QueueProps {
+export interface Queue<Body = unknown>
+  extends Resource<"cloudflare::Queue">,
+    QueueProps {
   /**
    * Type identifier for Cloudflare Queue
    */
@@ -70,6 +78,11 @@ export interface Queue extends Resource<"cloudflare::Queue">, QueueProps {
    */
   id: string;
 
+  /**
+   * The name of the queue
+   */
+  name: string;
+
   /**
    * Time when the queue was created
    */
@@ -79,6 +92,13 @@ export interface Queue extends Resource<"cloudflare::Queue">, QueueProps {
    * Modified timestamp
    */
   modifiedOn: string;
+
+  /**
+   * Phantom property to allow type inference
+   */
+  Body: Body;
+
+  Batch: MessageBatch<Body>;
 }
 
 interface CloudflareQueueResponse {
@@ -131,74 +151,74 @@ interface CloudflareQueueResponse {
  *
  * @see https://developers.cloudflare.com/queues/
  */
-export const Queue = Resource(
-  "cloudflare::Queue",
-  async function (
-    this: Context<Queue>,
-    id: string,
-    props: QueueProps
-  ): Promise<Queue> {
-    const api = await createCloudflareApi(props);
-    const queueName = props.name || id;
-
-    if (this.phase === "delete") {
-      console.log("Deleting Cloudflare Queue:", queueName);
-      if (props.delete !== false) {
-        // Delete Queue
-        await deleteQueue(api, this.output?.id);
-      }
+export const Queue = Resource("cloudflare::Queue", async function <
+  T = unknown,
+>(this: Context<Queue<T>>, id: string, props: QueueProps = {}): Promise<
+  Queue<T>
+> {
+  const api = await createCloudflareApi(props);
+  const queueName = props.name ?? id;
+
+  if (this.phase === "delete") {
+    console.log("Deleting Cloudflare Queue:", queueName);
+    if (props.delete !== false) {
+      // Delete Queue
+      await deleteQueue(api, this.output?.id);
+    }
 
-      // Return void (a deleted queue has no content)
-      return this.destroy();
-    } else {
-      let queueData: CloudflareQueueResponse;
+    // Return void (a deleted queue has no content)
+    return this.destroy();
+  } else {
+    let queueData: CloudflareQueueResponse;
 
-      if (this.phase === "create") {
-        console.log("Creating Cloudflare Queue:", queueName);
-        queueData = await createQueue(api, queueName, props);
-      } else {
-        // Update operation
-        if (this.output?.id) {
-          console.log("Updating Cloudflare Queue:", queueName);
-
-          // Check if name is being changed, which is not allowed
-          if (props.name !== this.output.name) {
-            throw new Error(
-              "Cannot update Queue name after creation. Queue name is immutable."
-            );
-          }
-
-          // Update the queue with new settings
-          queueData = await updateQueue(api, this.output.id, props);
-        } else {
-          // If no ID exists, fall back to creating a new queue
-          console.log(
-            "No existing Queue ID found, creating new Cloudflare Queue:",
-            queueName
+    if (this.phase === "create") {
+      console.log("Creating Cloudflare Queue:", queueName);
+      queueData = await createQueue(api, queueName, props);
+    } else {
+      // Update operation
+      if (this.output?.id) {
+        console.log("Updating Cloudflare Queue:", queueName);
+
+        // Check if name is being changed, which is not allowed
+        if (props.name !== this.output.name) {
+          throw new Error(
+            "Cannot update Queue name after creation. Queue name is immutable."
           );
-          queueData = await createQueue(api, queueName, props);
         }
-      }
 
-      return this({
-        type: "queue",
-        id: queueData.result.queue_id || "",
-        name: queueName,
-        settings: queueData.result.settings
-          ? {
-              deliveryDelay: queueData.result.settings.delivery_delay,
-              deliveryPaused: queueData.result.settings.delivery_paused,
-              messageRetentionPeriod:
-                queueData.result.settings.message_retention_period,
-            }
-          : undefined,
-        createdOn: queueData.result.created_on || new Date().toISOString(),
-        modifiedOn: queueData.result.modified_on || new Date().toISOString(),
-        accountId: api.accountId,
-      });
+        // Update the queue with new settings
+        queueData = await updateQueue(api, this.output.id, props);
+      } else {
+        // If no ID exists, fall back to creating a new queue
+        console.log(
+          "No existing Queue ID found, creating new Cloudflare Queue:",
+          queueName
+        );
+        queueData = await createQueue(api, queueName, props);
+      }
     }
+
+    return this({
+      type: "queue",
+      id: queueData.result.queue_id || "",
+      name: queueName,
+      settings: queueData.result.settings
+        ? {
+            deliveryDelay: queueData.result.settings.delivery_delay,
+            deliveryPaused: queueData.result.settings.delivery_paused,
+            messageRetentionPeriod:
+              queueData.result.settings.message_retention_period,
+          }
+        : undefined,
+      createdOn: queueData.result.created_on || new Date().toISOString(),
+      modifiedOn: queueData.result.modified_on || new Date().toISOString(),
+      accountId: api.accountId,
+      // phantom properties
+      Body: undefined as T,
+      Batch: undefined! as MessageBatch<T>,
+    });
   }
-);
+});
 
 /**
  * Create a new Cloudflare Queue

package/src/cloudflare/website.ts

@@ -93,15 +93,6 @@ export async function Website<B extends Bindings>(
       command: props.command,
     });
 
-    const dist =
-      typeof props.assets === "string"
-        ? props.assets
-        : (props.assets?.dist ?? "dist");
-
-    const staticAssets = await Assets("assets", {
-      path: dist,
-    });
-
     const worker = await Worker("worker", {
       ...props,
       name: props.name ?? id,
@@ -116,15 +107,20 @@ export async function Website<B extends Bindings>(
         ? undefined
         : `
 export default {
-async fetch(request, env) {
-  return new Response("Not Found", { status: 404 });
-},
+  async fetch(request, env) {
+    return new Response("Not Found", { status: 404 });
+  },
 };`,
       url: true,
       adopt: true,
       bindings: {
         ...props.bindings,
-        ASSETS: staticAssets,
+        ASSETS: await Assets("assets", {
+          path:
+            typeof props.assets === "string"
+              ? props.assets
+              : (props.assets?.dist ?? "dist"),
+        }),
       },
     });