alchemy 0.1.17 → 0.2.0

package/src/cloudflare/durable-object-namespace.ts

@@ -1,5 +1,3 @@
-import type { Resolved } from "../output";
-
 export interface DurableObjectNamespaceInput {
   className: string;
   scriptName?: string | undefined;
@@ -8,14 +6,6 @@ export interface DurableObjectNamespaceInput {
   namespaceId?: string | undefined;
 }
 
-export function isDurableObjectNamespace(
-  binding: any,
-): binding is Resolved<DurableObjectNamespace> {
-  return (
-    typeof binding === "object" && binding.type === "durable_object_namespace"
-  );
-}
-
 export class DurableObjectNamespace implements DurableObjectNamespaceInput {
   public readonly type = "durable_object_namespace" as const;
   // alias for bindingName to be consistent with other bindings

package/src/cloudflare/generate-asset-manifest.ts

@@ -2,7 +2,7 @@ import crypto from "crypto";
 import { promises as fs } from "fs";
 import { glob } from "glob";
 import path from "path";
-import { getContentType } from "../utils/content-type";
+import { getContentType } from "../util/content-type";
 import type {
   AssetManifest,
   AssetManifestEntry,

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,
       routes,
-    };
-
-    return output;
+    });
   },
-) {}
+);

package/src/cloudflare/worker.ts

@@ -1,21 +1,25 @@
 import * as fs from "fs/promises";
-import { apply } from "../apply";
-import { Bundle, type BundleProps } from "../esbuild";
-import type { Resolved } from "../output";
-import { type Context, Resource } from "../resource";
-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 { isBucket } from "./bucket";
+import {
+  type Bindings,
+  type WorkerBindingSpec,
+  isDurableObjectNamespace,
+} from "./bindings";
+import type { Bound } from "./bound";
 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";
 /**
  * Properties for creating or updating a Worker
  */
-export interface WorkerProps {
+export interface WorkerProps<B extends Bindings = Bindings> {
   /**
    * The worker script content (JavaScript or WASM)
    * One of script, entryPoint, or bundle must be provided
@@ -58,7 +62,7 @@ export interface WorkerProps {
   /**
    * Bindings to attach to the worker
    */
-  bindings?: Bindings;
+  bindings?: B;
 
   /**
    * Environment variables to attach to the worker
@@ -97,7 +101,9 @@ export interface WorkerProps {
 /**
  * Output returned after Worker creation/update
  */
-export interface WorkerOutput extends Omit<WorkerProps, "url"> {
+export interface Worker<B extends Bindings = Bindings>
+  extends Resource<"cloudflare::Worker">,
+    Omit<WorkerProps<B>, "url"> {
   type: "service";
 
   /**
@@ -124,19 +130,24 @@ export interface WorkerOutput extends Omit<WorkerProps, "url"> {
   /**
    * The bindings that were created
    */
-  bindings: Bindings;
-}
+  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 extends Resource(
+export const Worker = Resource(
   "cloudflare::Worker",
   {
     alwaysUpdate: true,
   },
-  async (ctx: Context<WorkerOutput>, props: WorkerProps) => {
+  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();
 
@@ -148,32 +159,36 @@ export class Worker extends Resource(
       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);
+    if (this.phase === "delete") {
+      await deleteWorker(this, api, workerName);
+      return this.destroy();
+    } else if (this.phase === "create") {
+      await assertWorkerDoesNotExist(this, api, workerName);
     }
 
-    const oldBindings = await ctx.get<Bindings>("bindings");
+    const oldBindings = await this.get<Bindings>("bindings");
 
-    const scriptMetadata = await prepareWorkerMetadata(ctx, oldBindings, props);
+    const scriptMetadata = await prepareWorkerMetadata(
+      this,
+      oldBindings,
+      props,
+    );
 
     // Get the script content - either from props.script, or by bundling
-    const scriptContent =
-      props.script ?? (await bundleWorkerScript(ctx, props));
+    const scriptContent = props.script ?? (await bundleWorkerScript(props));
 
     // Upload the worker script
-    await putWorker(ctx, api, workerName, scriptContent, scriptMetadata);
+    await putWorker(api, workerName, scriptContent, scriptMetadata);
 
     // TODO: it is less than ideal that this can fail, resulting in state problem
-    await ctx.set("bindings", props.bindings);
+    await this.set("bindings", props.bindings);
 
     // Handle routes if requested
     await setupRoutes(api, workerName, props.routes || []);
 
     // Handle worker URL if requested
     const workerUrl = await configureURL(
-      ctx,
+      this,
       api,
       workerName,
       props.url ?? false,
@@ -183,27 +198,27 @@ export class Worker extends Resource(
     const now = Date.now();
 
     // Construct the output
-    const output: WorkerOutput = {
+    return this({
       type: "service",
-      id: workerName,
+      id,
       name: workerName,
       script: scriptContent,
       format: props.format || "esm", // Include format in the output
       routes: props.routes || [],
-      bindings: props.bindings ?? {},
+      bindings: props.bindings ?? ({} as B),
       env: props.env,
       observability: scriptMetadata.observability,
       createdAt: now,
       updatedAt: now,
       url: workerUrl,
-    };
-
-    return output;
+      // phantom property
+      Env: undefined!,
+    });
   },
-) {}
+);
 
-async function deleteWorker(
-  ctx: Context<WorkerOutput>,
+async function deleteWorker<B extends Bindings>(
+  ctx: Context<Worker<B>>,
   api: CloudflareApi,
   workerName: string,
 ) {
@@ -272,7 +287,6 @@ async function deleteWorker(
 }
 
 async function putWorker(
-  ctx: Context<WorkerOutput>,
   api: CloudflareApi,
   workerName: string,
   scriptContent: string,
@@ -297,8 +311,6 @@ async function putWorker(
         scriptName,
       );
 
-      // console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
-
       // Add metadata as JSON
       formData.append(
         "metadata",
@@ -363,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> {
@@ -374,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 ?? [],
@@ -384,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)) {
@@ -394,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({
@@ -408,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;
 
@@ -439,11 +452,17 @@ 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 (isSecret(binding)) {
+      meta.bindings.push({
+        type: "secret_text",
+        name: bindingName,
+        text: binding.unencrypted,
       });
     } else {
       // @ts-expect-error - we should never reach here
@@ -476,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,
 ) {
@@ -498,7 +517,7 @@ async function assertWorkerDoesNotExist(
 
     if (
       metadata.default_environment?.script.tags.includes(
-        `alchemy:id:${ctx.resourceFQN}`,
+        `alchemy:id:${slugify(ctx.fqn)}`,
       )
     ) {
       return true;
@@ -514,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
@@ -538,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");
@@ -617,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,
@@ -657,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));
       }
     }