alchemy 0.6.0 → 0.7.1

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>);

package/lib/cloudflare/wrangler.json.js

@@ -1,4 +1,4 @@
-import * as fs from "fs/promises";
+import { StaticJsonFile } from "../fs";
 import { Resource } from "../resource";
 /**
  * Resource for managing wrangler.json configuration files
@@ -7,29 +7,136 @@ export const WranglerJson = Resource("cloudflare::WranglerJson", async function
     // Default path is wrangler.json in current directory
     const filePath = props.path || "wrangler.json";
     if (this.phase === "delete") {
-        try {
-            await fs.unlink(filePath);
-        }
-        catch (error) {
-            // Ignore errors if file doesn't exist
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
         return this.destroy();
     }
-    // Create or update the file
-    const config = {
-        ...props,
-        // Remove internal path property
-        path: undefined,
+    if (props.worker.entrypoint === undefined) {
+        throw new Error("Worker must have an entrypoint to generate a wrangler.json");
+    }
+    const worker = props.worker;
+    const spec = {
+        name: worker.name,
+        // Use entrypoint as main if it exists
+        main: worker.entrypoint,
+        // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
+        compatibility_date: "2022-04-05",
     };
-    // Write the file
-    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+    // Process bindings if they exist
+    if (worker.bindings) {
+        processBindings(spec, worker.bindings);
+    }
+    // Add environment variables as vars
+    if (worker.env) {
+        spec.vars = { ...worker.env };
+    }
+    await StaticJsonFile("wrangler.json", spec);
     // Return the resource
     return this({
         ...props,
+        path: filePath,
         createdAt: Date.now(),
         updatedAt: Date.now(),
     });
 });
+/**
+ * Process worker bindings into wrangler.json format
+ */
+function processBindings(spec, bindings) {
+    // Arrays to collect different binding types
+    const kvNamespaces = [];
+    const durableObjects = [];
+    const r2Buckets = [];
+    const services = [];
+    const secrets = [];
+    const workflows = [];
+    const d1Databases = [];
+    const queues = [];
+    // Process each binding
+    for (const [bindingName, binding] of Object.entries(bindings)) {
+        if (typeof binding === "string") {
+            // Plain text binding - add to vars
+            if (!spec.vars) {
+                spec.vars = {};
+            }
+            spec.vars[bindingName] = binding;
+        }
+        else if (binding.type === "kv_namespace") {
+            // KV Namespace binding
+            kvNamespaces.push({
+                binding: bindingName,
+                id: binding.namespaceId,
+            });
+        }
+        else if (typeof binding === "object" &&
+            binding.type === "durable_object_namespace") {
+            // Durable Object binding
+            const doBinding = binding;
+            durableObjects.push({
+                name: bindingName,
+                class_name: doBinding.className,
+                script_name: doBinding.scriptName,
+                environment: doBinding.environment,
+            });
+        }
+        else if (binding.type === "r2_bucket") {
+            r2Buckets.push({
+                binding: bindingName,
+                bucket_name: binding.name,
+            });
+        }
+        else if (binding.type === "service") {
+            // Service binding
+            services.push({
+                binding: bindingName,
+                service: binding.id,
+            });
+        }
+        else if (binding.type === "secret") {
+            // Secret binding
+            secrets.push(bindingName);
+        }
+        else if (binding.type === "assets") {
+            spec.assets = {
+                directory: binding.path,
+                binding: bindingName,
+            };
+        }
+        else if (binding.type === "workflow") {
+            workflows.push({
+                name: bindingName,
+                binding: binding.id,
+                class_name: binding.className,
+            });
+        }
+        else if (binding.type === "d1") {
+            d1Databases.push({
+                binding: bindingName,
+                database_id: binding.id,
+                database_name: binding.name,
+            });
+        }
+        else if (binding.type === "queue") {
+            queues.push({
+                binding: bindingName,
+                queue: binding.name,
+            });
+        }
+    }
+    // Add collected bindings to the spec
+    if (kvNamespaces.length > 0) {
+        spec.kv_namespaces = kvNamespaces;
+    }
+    if (durableObjects.length > 0) {
+        spec.durable_objects = {
+            bindings: durableObjects,
+        };
+    }
+    if (r2Buckets.length > 0) {
+        spec.r2_buckets = r2Buckets;
+    }
+    if (services.length > 0) {
+        spec.services = services;
+    }
+    if (queues.length > 0) {
+        spec.queues = queues;
+    }
+}

package/lib/internal/docs/providers.js

@@ -70,7 +70,7 @@ async function generateProviderDocs({ provider, outDir, parallel, }) {
       The ${provider} Service has the following resources:
       ${alchemy.files(files)}
 
-      A file is considered a "Resource" if it contains a const <ResourceName> = Resource(...) call or if it is a function that calls a Resource function, e.g. const TypeScriptFile = () => File(...).
+      A file is considered a "Resource" if it contains a const <ResourceName> = Resource(...) call or if it is a function that calls a Resource function, e.g. const TypeScriptFile = () => File(...), or it is the Workflow or DurableObject classes.
       A file is considered a "Client" if it exposes a wrapper around creating a SDK client or fetch.
       A file is considered a "Utility" if it contains utility functions that are not resources or clients.
       A file is considered a "Types" if it contains just type definitions and maybe helpers around working with those types.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/cloudflare/bindings.ts

@@ -6,9 +6,12 @@
 import type { Secret } from "../secret";
 import type { Assets } from "./assets";
 import type { R2Bucket } from "./bucket";
+import type { D1Database } from "./d1-database";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
+import type { Queue } from "./queue";
 import type { Worker } from "./worker";
+import type { Workflow } from "./workflow";
 
 export type Bindings = {
   [bindingName: string]: Binding;
@@ -18,28 +21,16 @@ export type Bindings = {
  * L2 Binding Resources.
  */
 export type Binding =
+  | Assets
+  | D1Database
   | DurableObjectNamespace
   | KVNamespace
-  | Worker
+  | Queue
   | R2Bucket
   | Secret
   | string
-  | Assets;
-
-export function isDurableObjectNamespace(
-  binding: Binding
-): binding is DurableObjectNamespace {
-  return (
-    typeof binding === "object" && binding.type === "durable_object_namespace"
-  );
-}
-
-/**
- * Check if a binding is an Assets resource
- */
-export function isAssets(binding: Binding): binding is Assets {
-  return typeof binding === "object" && binding.type === "assets";
-}
+  | Worker
+  | Workflow;
 
 /**
  * Union type for all Worker binding types (API spec)
@@ -65,7 +56,8 @@ export type WorkerBindingSpec =
   | WorkerBindingTailConsumer
   | WorkerBindingVectorize
   | WorkerBindingVersionMetadata
-  | WorkerBindingWasmModule;
+  | WorkerBindingWasmModule
+  | WorkerBindingWorkflow;
 
 /**
  * AI binding type
@@ -326,3 +318,20 @@ export interface WorkerBindingStaticContent {
   /** Type identifier for Static Content binding */
   type: "static_content";
 }
+
+export interface WorkerBindingWorkflow {
+  /** The name of the binding */
+  name: string;
+  /** Type identifier for Workflow binding */
+  type: "workflow";
+  /** Workflow name */
+  workflow_name: string;
+  /** Workflow class name */
+  class_name: string;
+  /**
+   * Workflow script name
+   *
+   * @default - the name of the script it is bound to
+   */
+  script_name?: string;
+}

package/src/cloudflare/bound.ts

@@ -2,9 +2,12 @@ import type { Secret } from "../secret";
 import type { Assets } from "./assets";
 import type { Binding } from "./bindings";
 import type { R2Bucket as _R2Bucket } from "./bucket";
+import type { D1Database as _D1Database } from "./d1-database";
 import type { DurableObjectNamespace as _DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace as _KVNamespace } from "./kv-namespace";
+import type { Queue as _Queue } from "./queue";
 import type { Worker as _Worker } from "./worker";
+import type { Workflow as _Workflow } from "./workflow";
 
 export type Bound<T extends Binding> = T extends _DurableObjectNamespace
   ? DurableObjectNamespace
@@ -18,4 +21,10 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace
           ? string
           : T extends Assets
             ? Service
-            : Service;
+            : T extends _Workflow<infer P>
+              ? Workflow<P>
+              : T extends _D1Database
+                ? D1Database
+                : T extends _Queue
+                  ? Queue
+                  : Service;