alchemy 0.1.18 → 0.2.1

package/src/cloudflare/worker.ts

@@ -1,17 +1,18 @@
 import * as fs from "fs/promises";
-import { apply } from "../apply";
-import { Bundle, type BundleProps } from "../esbuild";
-import type { Input } from "../input";
-import type { Resolved } from "../output";
-import { type Context, Resource } from "../resource";
-import { Secret } from "../secret";
-import { withExponentialBackoff } from "../utils/retry";
+import type { Context } from "../context";
+import { Bundle, type BundleProps } from "../esbuild/bundle";
+import { Resource } from "../resource";
+import { isSecret } from "../secret";
+import { withExponentialBackoff } from "../util/retry";
+import { slugify } from "../util/slugify";
 import { type CloudflareApi, createCloudflareApi } from "./api";
-import type { Bindings, WorkerBindingSpec } from "./bindings";
+import {
+  type Bindings,
+  type WorkerBindingSpec,
+  isDurableObjectNamespace,
+} from "./bindings";
 import type { Bound } from "./bound";
-import { isBucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
-import { isDurableObjectNamespace } from "./durable-object-namespace";
 import { isKVNamespace } from "./kv-namespace";
 import type { WorkerScriptMetadata } from "./worker-metadata";
 import type { SingleStepMigration } from "./worker-migration";
@@ -100,8 +101,9 @@ export interface WorkerProps<B extends Bindings = Bindings> {
 /**
  * Output returned after Worker creation/update
  */
-export interface WorkerOutput<B extends Bindings = Bindings>
-  extends Omit<WorkerProps<B>, "url"> {
+export interface Worker<B extends Bindings = Bindings>
+  extends Resource<"cloudflare::Worker">,
+    Omit<WorkerProps<B>, "url"> {
   type: "service";
 
   /**
@@ -128,94 +130,95 @@ export interface WorkerOutput<B extends Bindings = Bindings>
   /**
    * The bindings that were created
    */
-  bindings: B;
-}
+  bindings: B | undefined;
 
-export function isWorker(resource: any): resource is Resolved<Worker> {
-  return resource && typeof resource === "object" && resource.type === "worker";
+  // phantom property (for typeof myWorker.Env)
+  Env: {
+    [bindingName in keyof B]: Bound<B[bindingName]>;
+  };
 }
 
-export class Worker<B extends Bindings = Bindings> extends Resource(
+export const Worker = Resource(
   "cloudflare::Worker",
   {
     alwaysUpdate: true,
   },
-  applyWorker,
-) {
-  public declare readonly Env: {
-    [bindingName in keyof B]: Bound<B[bindingName]>;
-  };
-  constructor(id: string, input: Input<WorkerProps<B>>, ...inputs: any[]) {
-    super(id, input as any, ...inputs);
-  }
-}
-
-async function applyWorker(ctx: Context<WorkerOutput>, props: WorkerProps) {
-  // Create Cloudflare API client with automatic account discovery
-  const api = await createCloudflareApi();
-
-  // Use the provided name
-  const workerName = props.name;
-
-  // Validate input - we need either script, entryPoint, or bundle
-  if (!props.script && !props.entrypoint) {
-    throw new Error("One of script or entryPoint must be provided");
-  }
-
-  if (ctx.event === "delete") {
-    return deleteWorker(ctx, api, workerName);
-  } else if (ctx.event === "create") {
-    await assertWorkerDoesNotExist(ctx, api, workerName);
-  }
+  async function <const B extends Bindings>(
+    this: Context<Worker<NoInfer<B>>>,
+    id: string,
+    props: WorkerProps<B>,
+  ): Promise<Worker<B>> {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi();
+
+    // Use the provided name
+    const workerName = props.name;
+
+    // Validate input - we need either script, entryPoint, or bundle
+    if (!props.script && !props.entrypoint) {
+      throw new Error("One of script or entryPoint must be provided");
+    }
 
-  const oldBindings = await ctx.get<Bindings>("bindings");
+    if (this.phase === "delete") {
+      await deleteWorker(this, api, workerName);
+      return this.destroy();
+    } else if (this.phase === "create") {
+      await assertWorkerDoesNotExist(this, api, workerName);
+    }
 
-  const scriptMetadata = await prepareWorkerMetadata(ctx, oldBindings, props);
+    const oldBindings = await this.get<Bindings>("bindings");
 
-  // Get the script content - either from props.script, or by bundling
-  const scriptContent = props.script ?? (await bundleWorkerScript(ctx, props));
+    const scriptMetadata = await prepareWorkerMetadata(
+      this,
+      oldBindings,
+      props,
+    );
 
-  // Upload the worker script
-  await putWorker(ctx, api, workerName, scriptContent, scriptMetadata);
+    // Get the script content - either from props.script, or by bundling
+    const scriptContent = props.script ?? (await bundleWorkerScript(props));
 
-  // TODO: it is less than ideal that this can fail, resulting in state problem
-  await ctx.set("bindings", props.bindings);
+    // Upload the worker script
+    await putWorker(api, workerName, scriptContent, scriptMetadata);
 
-  // Handle routes if requested
-  await setupRoutes(api, workerName, props.routes || []);
+    // TODO: it is less than ideal that this can fail, resulting in state problem
+    await this.set("bindings", props.bindings);
 
-  // Handle worker URL if requested
-  const workerUrl = await configureURL(
-    ctx,
-    api,
-    workerName,
-    props.url ?? false,
-  );
+    // Handle routes if requested
+    await setupRoutes(api, workerName, props.routes || []);
 
-  // Get current timestamp
-  const now = Date.now();
-
-  // Construct the output
-  const output: WorkerOutput = {
-    type: "service",
-    id: workerName,
-    name: workerName,
-    script: scriptContent,
-    format: props.format || "esm", // Include format in the output
-    routes: props.routes || [],
-    bindings: props.bindings ?? {},
-    env: props.env,
-    observability: scriptMetadata.observability,
-    createdAt: now,
-    updatedAt: now,
-    url: workerUrl,
-  };
+    // Handle worker URL if requested
+    const workerUrl = await configureURL(
+      this,
+      api,
+      workerName,
+      props.url ?? false,
+    );
 
-  return output;
-}
+    // Get current timestamp
+    const now = Date.now();
+
+    // Construct the output
+    return this({
+      type: "service",
+      id,
+      name: workerName,
+      script: scriptContent,
+      format: props.format || "esm", // Include format in the output
+      routes: props.routes || [],
+      bindings: props.bindings ?? ({} as B),
+      env: props.env,
+      observability: scriptMetadata.observability,
+      createdAt: now,
+      updatedAt: now,
+      url: workerUrl,
+      // phantom property
+      Env: undefined!,
+    });
+  },
+);
 
-async function deleteWorker(
-  ctx: Context<WorkerOutput>,
+async function deleteWorker<B extends Bindings>(
+  ctx: Context<Worker<B>>,
   api: CloudflareApi,
   workerName: string,
 ) {
@@ -284,7 +287,6 @@ async function deleteWorker(
 }
 
 async function putWorker(
-  ctx: Context<WorkerOutput>,
   api: CloudflareApi,
   workerName: string,
   scriptContent: string,
@@ -309,8 +311,6 @@ async function putWorker(
         scriptName,
       );
 
-      // console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
-
       // Add metadata as JSON
       formData.append(
         "metadata",
@@ -375,8 +375,8 @@ interface WorkerMetadata {
   tags?: string[];
 }
 
-async function prepareWorkerMetadata(
-  ctx: Context<WorkerOutput>,
+async function prepareWorkerMetadata<B extends Bindings>(
+  ctx: Context<Worker<B>>,
   oldBindings: Bindings | undefined,
   props: WorkerProps,
 ): Promise<WorkerMetadata> {
@@ -386,7 +386,8 @@ async function prepareWorkerMetadata(
     observability: {
       enabled: props.observability?.enabled !== false,
     },
-    tags: [`alchemy:id:${ctx.resourceFQN}`],
+    // TODO(sam): base64 encode instead? 0 collision risk vs readability.
+    tags: [`alchemy:id:${slugify(ctx.fqn)}`],
     migrations: {
       new_classes: props.migrations?.new_classes ?? [],
       deleted_classes: props.migrations?.deleted_classes ?? [],
@@ -396,7 +397,7 @@ async function prepareWorkerMetadata(
     },
   };
 
-  const bindings = (props.bindings ?? {}) as Resolved<Bindings>;
+  const bindings = (props.bindings ?? {}) as Bindings;
 
   // Convert bindings to the format expected by the API
   for (const [bindingName, binding] of Object.entries(bindings)) {
@@ -406,7 +407,7 @@ async function prepareWorkerMetadata(
       meta.bindings.push({
         type: "kv_namespace",
         name: bindingName,
-        namespace_id: binding.id,
+        namespace_id: binding.namespaceId,
       });
     } else if (typeof binding === "string") {
       meta.bindings.push({
@@ -420,7 +421,7 @@ async function prepareWorkerMetadata(
         name: bindingName,
         service: binding.id,
       });
-    } else if (isDurableObjectNamespace(binding)) {
+    } else if (binding.type === "durable_object_namespace") {
       const stableId = binding.id;
       const className = binding.className;
 
@@ -451,13 +452,13 @@ async function prepareWorkerMetadata(
           to: className,
         });
       }
-    } else if (isBucket(binding)) {
+    } else if (binding.type === "r2_bucket") {
       meta.bindings.push({
         type: "r2_bucket",
         name: bindingName,
-        bucket_name: binding.name || binding.id,
+        bucket_name: binding.name,
       });
-    } else if (binding instanceof Secret) {
+    } else if (isSecret(binding)) {
       meta.bindings.push({
         type: "secret_text",
         name: bindingName,
@@ -494,8 +495,8 @@ async function prepareWorkerMetadata(
   return meta;
 }
 
-async function assertWorkerDoesNotExist(
-  ctx: Context<WorkerOutput>,
+async function assertWorkerDoesNotExist<B extends Bindings>(
+  ctx: Context<Worker<B>>,
   api: CloudflareApi,
   workerName: string,
 ) {
@@ -516,7 +517,7 @@ async function assertWorkerDoesNotExist(
 
     if (
       metadata.default_environment?.script.tags.includes(
-        `alchemy:id:${ctx.resourceFQN}`,
+        `alchemy:id:${slugify(ctx.fqn)}`,
       )
     ) {
       return true;
@@ -527,15 +528,12 @@ async function assertWorkerDoesNotExist(
     );
   } else {
     throw new Error(
-      `Error checking if worker exists: ${response.status} ${response.statusText}`,
+      `Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`,
     );
   }
 }
 
-async function bundleWorkerScript(
-  ctx: Context<WorkerOutput>,
-  props: WorkerProps,
-) {
+async function bundleWorkerScript<B extends Bindings>(props: WorkerProps) {
   // Get the script content - either from props.script, or by bundling
 
   // Create and use a Bundle resource with worker-optimized configuration
@@ -556,18 +554,14 @@ async function bundleWorkerScript(
   };
 
   // Create the bundle
-  const bundle = new Bundle("bundle", {
+  const bundle = await Bundle("bundle", {
     entryPoint: props.entrypoint!,
     ...bundleOptions,
     external: [...(bundleOptions.external ?? []), "cloudflare:workers"],
   });
 
-  // Get the bundled content
-  const bundleOutput = await apply(bundle, {
-    quiet: ctx.quiet,
-  });
   try {
-    return await fs.readFile(bundleOutput.path, "utf-8");
+    return await fs.readFile(bundle.path, "utf-8");
   } catch (error) {
     console.error("Error reading bundle:", error);
     throw new Error("Error reading bundle");
@@ -635,8 +629,8 @@ async function setupRoutes(
   }
 }
 
-async function configureURL(
-  ctx: Context<WorkerOutput>,
+async function configureURL<B extends Bindings>(
+  ctx: Context<Worker<B>>,
   api: CloudflareApi,
   workerName: string,
   url: boolean,
@@ -675,7 +669,7 @@ async function configureURL(
       // Add a delay when the subdomain is first created.
       // This is to prevent an issue where a negative cache-hit
       // causes the subdomain to be unavailable for 30 seconds.
-      if (ctx.event === "create" || !ctx.output?.url) {
+      if (ctx.phase === "create" || !ctx.output?.url) {
         await new Promise((resolve) => setTimeout(resolve, 3000));
       }
     }

package/src/cloudflare/wrangler.json.ts

@@ -0,0 +1,309 @@
+import * as fs from "fs/promises";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+
+/**
+ * Properties for wrangler.json configuration file
+ */
+export interface WranglerJsonProps {
+  /**
+   * The name of your worker
+   */
+  name: string;
+
+  /**
+   * The directory containing your worker entry point
+   * @default "src"
+   */
+  main?: string;
+
+  /**
+   * The entry point for your worker
+   * @default "index.ts" or "index.js"
+   */
+  entrypoint?: string;
+
+  /**
+   * The directory to store build artifacts
+   * @default "dist"
+   */
+  outdir?: string;
+
+  /**
+   * The directory to serve static assets from
+   */
+  assets?: string;
+
+  /**
+   * Minify the worker script
+   * @default true
+   */
+  minify?: boolean;
+
+  /**
+   * Node.js compatibility mode
+   * @default false
+   */
+  node_compat?: boolean;
+
+  /**
+   * First-party worker service bindings
+   */
+  services?: Array<{
+    /**
+     * Binding name
+     */
+    name: string;
+    /**
+     * Service environment
+     */
+    environment?: string;
+  }>;
+
+  /**
+   * Worker environment variables
+   */
+  vars?: Record<string, string>;
+
+  /**
+   * KV Namespace bindings
+   */
+  kv_namespaces?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * KV namespace ID
+     */
+    id: string;
+    /**
+     * Preview KV namespace ID
+     */
+    preview_id?: string;
+  }>;
+
+  /**
+   * R2 bucket bindings
+   */
+  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
+     */
+    binding: string;
+    /**
+     * Database name
+     */
+    database_name: string;
+    /**
+     * Database ID
+     */
+    database_id: string;
+    /**
+     * Preview database ID
+     */
+    preview_database_id?: string;
+  }>;
+
+  /**
+   * Durable Object bindings
+   */
+  durable_objects?: {
+    /**
+     * Durable Object bindings
+     */
+    bindings: Array<{
+      /**
+       * Binding name
+       */
+      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
+   */
+  analytics_engine_datasets?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * Dataset name
+     */
+    dataset?: string;
+  }>;
+
+  /**
+   * Route configuration
+   */
+  routes?: Array<string>;
+
+  /**
+   * Triggers configuration
+   */
+  triggers?: {
+    /**
+     * Cron triggers
+     */
+    crons: Array<string>;
+  };
+
+  /**
+   * Worker compatibility date
+   */
+  compatibility_date?: string;
+
+  /**
+   * Worker compatibility flags
+   */
+  compatibility_flags?: Array<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.
+   */
+  usage_model?: "bundled" | "unbound";
+
+  /**
+   * Path to the wrangler.json file
+   * @internal
+   */
+  path?: string;
+}
+
+/**
+ * Output returned after WranglerJson creation/update
+ */
+export interface WranglerJson
+  extends Resource<"cloudflare::WranglerJson">,
+    WranglerJsonProps {
+  /**
+   * Time at which the file was created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the file was last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * 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") {
+      try {
+        await fs.unlink(filePath);
+      } catch (error) {
+        // Ignore errors if file doesn't exist
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw error;
+        }
+      }
+      return this.destroy();
+    }
+
+    // Create or update the file
+    const config = {
+      ...props,
+      // Remove internal path property
+      path: undefined,
+    };
+
+    // Write the file
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+
+    // Return the resource
+    return this({
+      ...props,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+  },
+);