alchemy 0.7.0 → 0.7.1

package/lib/cloudflare/queue.js

@@ -0,0 +1,192 @@
+import { Resource } from "../resource";
+import { CloudflareApi, createCloudflareApi, } from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+/**
+ * Creates and manages Cloudflare Queues.
+ *
+ * Queues provide a managed queue system for reliable message delivery
+ * between workers and other systems.
+ *
+ * @example
+ * // Create a basic queue with default settings
+ * const basicQueue = await Queue("my-app-queue", {
+ *   name: "my-app-queue"
+ * });
+ *
+ * @example
+ * // Create a queue with custom settings
+ * const customQueue = await Queue("delayed-queue", {
+ *   name: "delayed-queue",
+ *   settings: {
+ *     deliveryDelay: 30, // 30 second delay before message delivery
+ *     messageRetentionPeriod: 86400 // Store messages for 1 day
+ *   }
+ * });
+ *
+ * @example
+ * // Create a paused queue for later activation
+ * const pausedQueue = await Queue("paused-queue", {
+ *   name: "paused-queue",
+ *   settings: {
+ *     deliveryPaused: true
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/queues/
+ */
+export const Queue = Resource("cloudflare::Queue", async function (id, props) {
+    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;
+        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);
+                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,
+        });
+    }
+});
+/**
+ * Create a new Cloudflare Queue
+ */
+export async function createQueue(api, queueName, props) {
+    // Prepare the create payload
+    const createPayload = {
+        queue_name: queueName,
+    };
+    // Add settings if provided
+    if (props.settings) {
+        createPayload.settings = {};
+        if (props.settings.deliveryDelay !== undefined) {
+            createPayload.settings.delivery_delay = props.settings.deliveryDelay;
+        }
+        if (props.settings.deliveryPaused !== undefined) {
+            createPayload.settings.delivery_paused = props.settings.deliveryPaused;
+        }
+        if (props.settings.messageRetentionPeriod !== undefined) {
+            createPayload.settings.message_retention_period =
+                props.settings.messageRetentionPeriod;
+        }
+    }
+    const createResponse = await api.post(`/accounts/${api.accountId}/queues`, createPayload);
+    if (!createResponse.ok) {
+        return await handleApiError(createResponse, "creating", "Queue", queueName);
+    }
+    return (await createResponse.json());
+}
+/**
+ * Get a Cloudflare Queue
+ */
+export async function getQueue(api, queueId) {
+    const response = await api.get(`/accounts/${api.accountId}/queues/${queueId}`);
+    if (!response.ok) {
+        return await handleApiError(response, "getting", "Queue", queueId);
+    }
+    return (await response.json());
+}
+/**
+ * Delete a Cloudflare Queue
+ */
+export async function deleteQueue(api, queueId) {
+    if (!queueId) {
+        console.log("No Queue ID provided, skipping delete");
+        return;
+    }
+    // Delete Queue
+    const deleteResponse = await api.delete(`/accounts/${api.accountId}/queues/${queueId}`);
+    if (!deleteResponse.ok && deleteResponse.status !== 404) {
+        const errorData = await deleteResponse.json().catch(() => ({
+            errors: [{ message: deleteResponse.statusText }],
+        }));
+        throw new CloudflareApiError(`Error deleting Cloudflare Queue '${queueId}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`, deleteResponse);
+    }
+}
+/**
+ * Update a Cloudflare Queue
+ *
+ * Note: According to Cloudflare API, the queue name cannot be changed after creation.
+ * Only the settings can be updated.
+ */
+export async function updateQueue(api, queueId, props) {
+    // Prepare the update payload - only include settings
+    const updatePayload = {};
+    // Add settings if provided
+    if (props.settings) {
+        updatePayload.settings = {};
+        if (props.settings.deliveryDelay !== undefined) {
+            updatePayload.settings.delivery_delay = props.settings.deliveryDelay;
+        }
+        if (props.settings.deliveryPaused !== undefined) {
+            updatePayload.settings.delivery_paused = props.settings.deliveryPaused;
+        }
+        if (props.settings.messageRetentionPeriod !== undefined) {
+            updatePayload.settings.message_retention_period =
+                props.settings.messageRetentionPeriod;
+        }
+    }
+    // Use PATCH for partial updates (only settings can be updated)
+    const updateResponse = await api.patch(`/accounts/${api.accountId}/queues/${queueId}`, updatePayload);
+    if (!updateResponse.ok) {
+        return await handleApiError(updateResponse, "updating", "Queue", queueId);
+    }
+    return (await updateResponse.json());
+}
+/**
+ * List all Cloudflare Queues in an account
+ */
+export async function listQueues(api) {
+    const response = await api.get(`/accounts/${api.accountId}/queues`);
+    if (!response.ok) {
+        throw new CloudflareApiError(`Failed to list queues: ${response.statusText}`, response);
+    }
+    const data = (await response.json());
+    if (!data.success) {
+        const errorMessage = data.errors?.[0]?.message || "Unknown error";
+        throw new Error(`Failed to list queues: ${errorMessage}`);
+    }
+    // Transform API response
+    return (data.result || []).map((queue) => ({
+        name: queue.queue_name,
+        id: queue.queue_id,
+    }));
+}

package/lib/cloudflare/worker.js

@@ -9,7 +9,6 @@ import { createCloudflareApi, } from "./api";
 import {} from "./assets";
 import {} from "./bindings";
 import {} from "./durable-object-namespace";
-import { isKVNamespace } from "./kv-namespace";
 import { upsertWorkflow } from "./workflow";
 /**
  * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
@@ -153,8 +152,10 @@ export const Worker = Resource("cloudflare::Worker", {
     const now = Date.now();
     // Construct the output
     return this({
+        ...props,
         type: "service",
         id,
+        entrypoint: props.entrypoint,
         name: workerName,
         script: scriptContent,
         format: props.format || "esm", // Include format in the output
@@ -265,18 +266,25 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
     // Convert bindings to the format expected by the API
     for (const [bindingName, binding] of Object.entries(bindings)) {
         // Create a copy of the binding to avoid modifying the original
-        if (isKVNamespace(binding)) {
+        if (typeof binding === "string") {
             meta.bindings.push({
-                type: "kv_namespace",
+                type: "plain_text",
                 name: bindingName,
-                namespace_id: binding.namespaceId,
+                text: binding,
             });
         }
-        else if (typeof binding === "string") {
+        else if (binding.type === "d1") {
             meta.bindings.push({
-                type: "plain_text",
+                type: "d1",
                 name: bindingName,
-                text: binding,
+                id: binding.id,
+            });
+        }
+        else if (binding.type === "kv_namespace") {
+            meta.bindings.push({
+                type: "kv_namespace",
+                name: bindingName,
+                namespace_id: binding.namespaceId,
             });
         }
         else if (binding.type === "service") {
@@ -329,6 +337,13 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
             // it's unclear whether this is needed, but it works both ways
             configureClassMigration(binding, binding.id, binding.className);
         }
+        else if (binding.type === "queue") {
+            meta.bindings.push({
+                type: "queue",
+                name: bindingName,
+                queue_name: binding.name,
+            });
+        }
         else {
             // @ts-expect-error - we should never reach here
             throw new Error(`Unsupported binding type: ${binding.type}`);

package/lib/cloudflare/wrangler.json.d.ts

@@ -1,243 +1,140 @@
 import type { Context } from "../context";
 import { Resource } from "../resource";
+import type { Worker } from "./worker";
 /**
  * Properties for wrangler.json configuration file
  */
 export interface WranglerJsonProps {
+    name?: string;
     /**
-     * The name of your worker
+     * The worker to generate the wrangler.json file for
      */
-    name: string;
+    worker: Worker;
     /**
-     * The directory containing your worker entry point
-     * @default "src"
+     * Path to write the wrangler.json file to
+     *
+     * @default cwd/wrangler.json
      */
-    main?: string;
+    path?: string;
+}
+/**
+ * Output returned after WranglerJson creation/update
+ */
+export interface WranglerJson extends Resource<"cloudflare::WranglerJson">, WranglerJsonProps {
     /**
-     * The entry point for your worker
-     * @default "index.ts" or "index.js"
+     * Time at which the file was created
      */
-    entrypoint?: string;
+    createdAt: number;
     /**
-     * The directory to store build artifacts
-     * @default "dist"
+     * Time at which the file was last updated
      */
-    outdir?: string;
+    updatedAt: number;
     /**
-     * The directory to serve static assets from
+     * Path to the wrangler.json file
      */
-    assets?: string;
+    path: string;
+}
+/**
+ * Resource for managing wrangler.json configuration files
+ */
+export declare const WranglerJson: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<WranglerJson>, id: string, props: WranglerJsonProps) => Promise<WranglerJson>);
+/**
+ * Wrangler.json configuration specification based on Cloudflare's schema
+ */
+export interface WranglerJsonSpec {
     /**
-     * Minify the worker script
-     * @default true
+     * The name of the worker
      */
-    minify?: boolean;
+    name: string;
     /**
-     * Node.js compatibility mode
-     * @default false
+     * Main entry point for the worker
      */
-    node_compat?: boolean;
+    main?: string;
     /**
-     * First-party worker service bindings
+     * A date in the form yyyy-mm-dd used to determine Workers runtime version
      */
-    services?: Array<{
-        /**
-         * Binding name
-         */
-        name: string;
-        /**
-         * Service environment
-         */
-        environment?: string;
-    }>;
+    compatibility_date?: string;
     /**
-     * Worker environment variables
+     * A list of flags that enable features from upcoming Workers runtime
      */
-    vars?: Record<string, string>;
+    compatibility_flags?: string[];
     /**
-     * KV Namespace bindings
+     * Whether to enable a workers.dev URL for this worker
      */
-    kv_namespaces?: Array<{
-        /**
-         * Binding name
-         */
-        binding: string;
-        /**
-         * KV namespace ID
-         */
-        id: string;
-        /**
-         * Preview KV namespace ID
-         */
-        preview_id?: string;
-    }>;
+    workers_dev?: boolean;
     /**
-     * R2 bucket bindings
+     * Routes to attach to the worker
      */
-    r2_buckets?: Array<{
-        /**
-         * Binding name
-         */
-        binding: string;
-        /**
-         * Bucket name
-         */
-        bucket_name: string;
-        /**
-         * Preview bucket name
-         */
-        preview_bucket_name?: string;
-    }>;
-    /**
-     * D1 database bindings
-     */
-    d1_databases?: Array<{
-        /**
-         * Binding name
-         */
+    routes?: string[];
+    /**
+     * KV Namespace bindings
+     */
+    kv_namespaces?: {
         binding: string;
-        /**
-         * Database name
-         */
-        database_name: string;
-        /**
-         * Database ID
-         */
-        database_id: string;
-        /**
-         * Preview database ID
-         */
-        preview_database_id?: string;
-    }>;
+        id: string;
+    }[];
     /**
      * Durable Object bindings
      */
     durable_objects?: {
-        /**
-         * Durable Object bindings
-         */
-        bindings: Array<{
-            /**
-             * Binding name
-             */
+        bindings: {
             name: string;
-            /**
-             * Class name
-             */
             class_name: string;
-            /**
-             * Script name
-             */
             script_name?: string;
-            /**
-             * Environment name
-             */
             environment?: string;
-        }>;
-    };
-    /**
-     * Queue bindings
-     */
-    queues?: {
-        /**
-         * Producer bindings
-         */
-        producers?: Array<{
-            /**
-             * Binding name
-             */
-            binding: string;
-            /**
-             * Queue name
-             */
-            queue: string;
-        }>;
-        /**
-         * Consumer configuration
-         */
-        consumers?: Array<{
-            /**
-             * Queue name
-             */
-            queue: string;
-            /**
-             * Maximum batch size
-             */
-            max_batch_size?: number;
-            /**
-             * Maximum batch timeout
-             */
-            max_batch_timeout?: number;
-            /**
-             * Maximum retries
-             */
-            max_retries?: number;
-            /**
-             * Dead letter queue
-             */
-            dead_letter_queue?: string;
-        }>;
+        }[];
     };
     /**
-     * Analytics Engine bindings
+     * R2 bucket bindings
      */
-    analytics_engine_datasets?: Array<{
-        /**
-         * Binding name
-         */
+    r2_buckets?: {
         binding: string;
-        /**
-         * Dataset name
-         */
-        dataset?: string;
-    }>;
+        bucket_name: string;
+    }[];
     /**
-     * Route configuration
+     * Queue bindings
      */
-    routes?: Array<string>;
+    queues?: {
+        binding: string;
+        queue: string;
+    }[];
     /**
-     * Triggers configuration
+     * Service bindings
      */
-    triggers?: {
-        /**
-         * Cron triggers
-         */
-        crons: Array<string>;
-    };
+    services?: {
+        binding: string;
+        service: string;
+        environment?: string;
+    }[];
     /**
-     * Worker compatibility date
+     * Workflow bindings
      */
-    compatibility_date?: string;
+    workflows?: {
+        name: string;
+        binding: string;
+        class_name: string;
+    }[];
     /**
-     * Worker compatibility flags
+     * Plain text bindings (vars)
      */
-    compatibility_flags?: Array<string>;
+    vars?: Record<string, string>;
     /**
-     * Worker usage model
-     * "bundled" - Includes resources like CPU and memory. Better for consistent workloads.
-     * "unbound" - Pay only for what you use. Better for sporadic workloads.
+     * Assets bindings
      */
-    usage_model?: "bundled" | "unbound";
+    assets?: {
+        directory: string;
+        binding: string;
+    };
     /**
-     * Path to the wrangler.json file
-     * @internal
+     * Workflow bindings
      */
-    path?: string;
-}
-/**
- * Output returned after WranglerJson creation/update
- */
-export interface WranglerJson extends Resource<"cloudflare::WranglerJson">, WranglerJsonProps {
+    wasm_modules?: Record<string, string>;
     /**
-     * Time at which the file was created
+     * Safe mode configuration
      */
-    createdAt: number;
+    node_compat?: boolean;
     /**
-     * Time at which the file was last updated
+     * Whether to minify the worker script
      */
-    updatedAt: number;
+    minify?: boolean;
 }
-/**
- * Resource for managing wrangler.json configuration files
- */
-export declare const WranglerJson: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<WranglerJson>, id: string, props: WranglerJsonProps) => Promise<WranglerJson>);