alchemy 0.1.18 → 0.2.0

package/src/cloudflare/kv-namespace.ts

@@ -1,8 +1,14 @@
-import type { Resolved } from "../output";
-import { type Context, Resource } from "../resource";
-import { withExponentialBackoff } from "../utils/retry";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { withExponentialBackoff } from "../util/retry";
 import { createCloudflareApi } from "./api";
 
+export function isKVNamespace(resource: any): resource is KVNamespace {
+  return (
+    resource && typeof resource === "object" && resource.type === "kv_namespace"
+  );
+}
+
 /**
  * Properties for creating or updating a KV Namespace
  */
@@ -52,12 +58,14 @@ export interface KVPair {
 /**
  * Output returned after KV Namespace creation/update
  */
-export interface KVNamespaceOutput extends KVNamespaceProps {
+export interface KVNamespace
+  extends Resource<"cloudflare::KVNamespace">,
+    KVNamespaceProps {
   type: "kv_namespace";
   /**
    * The ID of the namespace
    */
-  id: string;
+  namespaceId: string;
 
   /**
    * Time at which the namespace was created
@@ -70,23 +78,19 @@ export interface KVNamespaceOutput extends KVNamespaceProps {
   modifiedAt: number;
 }
 
-export function isKVNamespace(
-  resource: any,
-): resource is Resolved<KVNamespace> {
-  return (
-    resource && typeof resource === "object" && resource.type === "kv_namespace"
-  );
-}
-
-export class KVNamespace extends Resource(
+export const KVNamespace = Resource(
   "cloudflare::KVNamespace",
-  async (ctx: Context<KVNamespaceOutput>, props: KVNamespaceProps) => {
+  async function (
+    this: Context<KVNamespace>,
+    id: string,
+    props: KVNamespaceProps,
+  ) {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
 
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
       // For delete operations, we need to check if the namespace ID exists in the output
-      const namespaceId = ctx.output?.id;
+      const namespaceId = this.output?.namespaceId;
       if (namespaceId) {
         // Delete KV namespace
         const deleteResponse = await api.delete(
@@ -104,19 +108,22 @@ export class KVNamespace extends Resource(
       }
 
       // Return minimal output for deleted state
-      return;
+      return this.destroy();
     } else {
       // For create or update operations
-      // If ctx.event is "update", we expect ctx.output to exist
-      let namespaceId = ctx.event === "update" ? ctx.output?.id || "" : "";
+      // If this.phase is "update", we expect this.output to exist
+      let namespaceId =
+        this.phase === "update" ? this.output?.namespaceId || "" : "";
       let createdAt =
-        ctx.event === "update"
-          ? ctx.output?.createdAt || Date.now()
+        this.phase === "update"
+          ? this.output?.createdAt || Date.now()
           : Date.now();
 
-      if (ctx.event === "update" && namespaceId) {
+      if (this.phase === "update" && namespaceId) {
         // Can't update a KV namespace title directly, just work with existing ID
       } else {
+        // TODO: if it already exists, then check the tags to see if we own it and continue
+
         // Create new KV namespace
         const createResponse = await api.post(
           `/accounts/${api.accountId}/storage/kv/namespaces`,
@@ -207,19 +214,14 @@ export class KVNamespace extends Resource(
         }
       }
 
-      const now = Date.now();
-
-      // Construct the output
-      const output: KVNamespaceOutput = {
+      return this({
         type: "kv_namespace",
-        id: namespaceId,
+        namespaceId: namespaceId,
         title: props.title,
         values: props.values,
         createdAt: createdAt,
-        modifiedAt: now,
-      };
-
-      return output;
+        modifiedAt: Date.now(),
+      });
     }
   },
-) {}
+);

package/src/cloudflare/static-site-router.ts

@@ -34,14 +34,12 @@ export default {
       isInit = true;
       for (const [key, value] of Object.entries(env)) {
         if (key.startsWith("ROUTE_")) {
-          console.log(key, value);
           const service = value as Service;
           const patternKey = `__${key}`;
           if (!(patternKey in env)) {
             throw new Error(`Missing pattern key: ${patternKey}`);
           }
           const pattern = (env as any)[`__${key}`];
-          console.log("pattern", pattern);
           // TODO(sam): we should support narrowing down METHOD
           app.all(pattern, (ctx) => service.fetch(ctx.req.raw));
         }
@@ -53,7 +51,6 @@ export default {
 
 // fall back to assuming the request is a static file
 app.notFound(async (ctx) => {
-  console.log("not found");
   const request = ctx.req;
   const env = ctx.env;
   const url = new URL(request.url);

package/src/cloudflare/static-site.ts

@@ -2,10 +2,9 @@ import { exec } from "child_process";
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
-import { apply } from "../apply";
-import type { BundleProps } from "../esbuild";
-import type { Input } from "../input";
-import { type Context, Resource } from "../resource";
+import type { Context } from "../context";
+import type { BundleProps } from "../esbuild/bundle";
+import { Resource } from "../resource";
 import { createCloudflareApi } from "./api";
 import type { Bindings } from "./bindings";
 import { generateAssetManifest } from "./generate-asset-manifest";
@@ -131,12 +130,7 @@ export interface StaticSiteProps {
 /**
  * Output returned after StaticSite creation/update
  */
-export interface StaticSiteOutput {
-  /**
-   * The ID of the site
-   */
-  id: string;
-
+export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
   /**
    * The ID of the worker
    */
@@ -208,16 +202,20 @@ export interface StaticSiteOutput {
   routes?: Record<string, string>;
 }
 
-export class StaticSite extends Resource(
+export const StaticSite = Resource(
   "cloudflare::StaticSite",
   {
     alwaysUpdate: true,
   },
-  async (ctx: Context<StaticSiteOutput>, props: StaticSiteProps) => {
-    if (ctx.event === "delete") {
+  async function (
+    this: Context<StaticSite>,
+    id: string,
+    props: StaticSiteProps,
+  ) {
+    if (this.phase === "delete") {
       // For delete operations, we'll rely on the Worker delete to clean up
       // Return empty output for deleted state
-      return;
+      return this.destroy();
     }
 
     // Validate that a name is provided
@@ -246,7 +244,7 @@ export class StaticSite extends Resource(
     // Run build command if provided
     if (props.build?.command) {
       try {
-        if (!ctx.quiet) {
+        if (!this.quiet) {
           console.log(props.build.command);
         }
         const execAsync = promisify(exec);
@@ -254,7 +252,7 @@ export class StaticSite extends Resource(
           cwd: process.cwd(),
         });
 
-        if (stdout && !ctx.quiet) console.log(stdout);
+        if (stdout && !this.quiet) console.log(stdout);
       } catch (error: any) {
         // Log detailed error information
         console.error(`Build command failed with exit code ${error.code}`);
@@ -276,22 +274,18 @@ export class StaticSite extends Resource(
     const api = await createCloudflareApi();
 
     // Step 1: Create or get the KV namespace for assets
-    const kv = new KVNamespace("assets", {
-      title: `${siteName}-assets`,
-    });
-
-    const [{ id: kvNamespaceId }, assetManifest] = await Promise.all([
-      apply(kv, {
-        quiet: ctx.quiet,
+    const [kv, assetManifest] = await Promise.all([
+      KVNamespace("assets", {
+        title: `${siteName}-assets`,
       }),
       generateAssetManifest(props.dir),
     ]);
 
     // Step 3: Upload assets to KV
-    await uploadAssetManifest(api, kvNamespaceId, assetManifest);
+    await uploadAssetManifest(api, kv.namespaceId, assetManifest);
 
     // Prepare the bindings for the worker
-    const bindings: Input<Bindings> = {
+    const bindings: Bindings = {
       ASSETS: kv,
       INDEX_PAGE: indexPage,
       // Add error page binding if specified
@@ -335,39 +329,31 @@ export class StaticSite extends Resource(
       // TypeScript file doesn't exist, use JavaScript (default)
     }
 
-    const worker = new Worker(
-      "worker",
-      {
-        name: siteName,
-        url: true,
-        format: props.format || "esm",
-        // If a custom worker script is provided, use it, otherwise use the entrypoint from router
-        ...(props.workerScript
-          ? { script: props.workerScript }
-          : {
-              entrypoint: path.resolve(__dirname, entrypointFile),
-              bundle: bundleOptions,
-            }),
-        bindings,
-        env: {
-          ...Object.fromEntries(
-            Object.entries(routes).map(([key, value]) => [
-              `__ROUTE_${value}`,
-              key,
-            ]),
-          ),
-        },
+    const worker = await Worker("worker", {
+      name: siteName,
+      url: true,
+      format: props.format || "esm",
+      // If a custom worker script is provided, use it, otherwise use the entrypoint from router
+      ...(props.workerScript
+        ? { script: props.workerScript }
+        : {
+            entrypoint: path.resolve(__dirname, entrypointFile),
+            bundle: bundleOptions as any,
+          }),
+      bindings,
+      env: {
+        ...Object.fromEntries(
+          Object.entries(routes).map(([key, value]) => [
+            `__ROUTE_${value}`,
+            key,
+          ]),
+        ),
       },
-      // place a dependency on the namespace
-      kv.id,
-    );
+    });
 
-    // Get current timestamp
     const now = Date.now();
 
-    // Construct the output
-    const output: Input<StaticSiteOutput> = {
-      id: siteName,
+    return this({
       workerId: worker.id,
       name: siteName,
       directory: props.dir,
@@ -375,14 +361,12 @@ export class StaticSite extends Resource(
       errorPage: props.errorPage,
       indexPage,
       assets: assetManifest.map((item) => item.key),
-      createdAt: ctx.output?.createdAt || now,
+      createdAt: this.output?.createdAt || now,
       updatedAt: now,
       domain: props.domain,
       production: props.production !== false,
-      url: worker.url as Input<string | undefined>,
+      url: worker.url,
       routes,
-    };
-
-    return output;
+    });
   },
-) {}
+);

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;
@@ -532,10 +533,7 @@ async function assertWorkerDoesNotExist(
   }
 }
 
-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));
       }
     }