alchemy 0.6.0 → 0.7.1

package/src/cloudflare/wrangler.json.ts

@@ -1,309 +1,330 @@
-import * as fs from "fs/promises";
 import type { Context } from "../context";
+import { StaticJsonFile } from "../fs";
 import { Resource } from "../resource";
+import type { Bindings } from "./bindings";
+import type { DurableObjectNamespace } from "./durable-object-namespace";
+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 const WranglerJson = Resource(
+  "cloudflare::WranglerJson",
+  async function (
+    this: Context<WranglerJson>,
+    id: string,
+    props: WranglerJsonProps
+  ): Promise<WranglerJson> {
+    // Default path is wrangler.json in current directory
+    const filePath = props.path || "wrangler.json";
+
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    if (props.worker.entrypoint === undefined) {
+      throw new Error(
+        "Worker must have an entrypoint to generate a wrangler.json"
+      );
+    }
+
+    const worker = props.worker;
+
+    const spec: WranglerJsonSpec = {
+      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",
+    };
+
+    // 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(),
+    });
+  }
+);
+
+/**
+ * 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;
-  }>;
+  routes?: string[];
 
   /**
-   * D1 database bindings
+   * KV Namespace bindings
    */
-  d1_databases?: Array<{
-    /**
-     * Binding name
-     */
+  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;
-}
+  wasm_modules?: Record<string, string>;
 
-/**
- * Output returned after WranglerJson creation/update
- */
-export interface WranglerJson
-  extends Resource<"cloudflare::WranglerJson">,
-    WranglerJsonProps {
   /**
-   * 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
+ * Process worker bindings into wrangler.json format
  */
-export const WranglerJson = Resource(
-  "cloudflare::WranglerJson",
-  async function (
-    this: Context<WranglerJson>,
-    id: string,
-    props: WranglerJsonProps,
-  ): Promise<WranglerJson> {
-    // Default path is wrangler.json in current directory
-    const filePath = props.path || "wrangler.json";
+function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
+  // Arrays to collect different binding types
+  const kvNamespaces: { binding: string; id: string }[] = [];
+  const durableObjects: {
+    name: string;
+    class_name: string;
+    script_name?: string;
+    environment?: string;
+  }[] = [];
+  const r2Buckets: { binding: string; bucket_name: string }[] = [];
+  const services: { binding: string; service: string; environment?: string }[] =
+    [];
+  const secrets: string[] = [];
+  const workflows: { name: string; binding: string; class_name: string }[] = [];
+  const d1Databases: {
+    binding: string;
+    database_id: string;
+    database_name: string;
+  }[] = [];
+  const queues: { binding: string; queue: string }[] = [];
 
-    if (this.phase === "delete") {
-      try {
-        await fs.unlink(filePath);
-      } catch (error) {
-        // Ignore errors if file doesn't exist
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-          throw error;
-        }
+  // 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 = {};
       }
-      return this.destroy();
+      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 as DurableObjectNamespace;
+      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,
+      });
     }
+  }
 
-    // Create or update the file
-    const config = {
-      ...props,
-      // Remove internal path property
-      path: undefined,
+  // Add collected bindings to the spec
+  if (kvNamespaces.length > 0) {
+    spec.kv_namespaces = kvNamespaces;
+  }
+
+  if (durableObjects.length > 0) {
+    spec.durable_objects = {
+      bindings: durableObjects,
     };
+  }
 
-    // Write the file
-    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+  if (r2Buckets.length > 0) {
+    spec.r2_buckets = r2Buckets;
+  }
 
-    // Return the resource
-    return this({
-      ...props,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    });
-  },
-);
+  if (services.length > 0) {
+    spec.services = services;
+  }
+
+  if (queues.length > 0) {
+    spec.queues = queues;
+  }
+}

package/src/internal/docs/providers.ts

@@ -145,7 +145,7 @@ async function generateProviderDocs({
       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.