alchemy 0.1.12 → 0.1.13

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

@@ -0,0 +1,43 @@
+import type { WorkerBinding } from "./bindings";
+
+export interface DurableObjectNamespaceInput {
+  bindingName: string;
+  className: string;
+  scriptName?: string | undefined;
+  environment?: string | undefined;
+  sqlite?: boolean | undefined;
+  namespaceId?: string | undefined;
+}
+
+export function isDurableObjectNamespace(
+  binding: WorkerBinding,
+): binding is DurableObjectNamespace {
+  return (
+    binding.type === "durable_object_namespace" &&
+    typeof (binding as any).bindingName === "string"
+  );
+}
+
+export class DurableObjectNamespace implements DurableObjectNamespaceInput {
+  public readonly type = "durable_object_namespace" as const;
+  // alias for bindingName to be consistent with other bindings
+  public readonly name: string;
+  public readonly bindingName: string;
+  public readonly className: string;
+  public readonly scriptName?: string | undefined;
+  public readonly environment?: string | undefined;
+  public readonly sqlite?: boolean | undefined;
+  public readonly namespaceId?: string | undefined;
+
+  constructor(
+    public readonly id: string,
+    input: DurableObjectNamespaceInput,
+  ) {
+    this.bindingName = input.bindingName;
+    this.name = this.bindingName;
+    this.className = input.className;
+    this.scriptName = input.scriptName;
+    this.environment = input.environment;
+    this.sqlite = input.sqlite;
+  }
+}

package/src/cloudflare/index.ts

@@ -1,4 +1,5 @@
 export * from "./bindings";
+export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./state";
 export * from "./static-site";

package/src/cloudflare/kv-namespace.ts

@@ -121,7 +121,7 @@ export class KVNamespace extends Resource(
             errors: [{ message: createResponse.statusText }],
           }));
           throw new Error(
-            `Error creating KV namespace: ${errorData.errors?.[0]?.message || createResponse.statusText}`,
+            `Error creating KV namespace '${props.title}': ${errorData.errors?.[0]?.message || createResponse.statusText}`,
           );
         }
 

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

@@ -1,108 +1,150 @@
+import { Hono } from "hono";
+
 // see: https://developers.cloudflare.com/workers/runtime-apis/cache/
-declare var caches: any;
+declare var caches: {
+  default: Cache;
+};
 
 // injected by src/cloudflare/static-site.ts
 declare var __ASSET_MANIFEST__: Record<string, string>;
 
-export interface Env {
+export type Env = {
   ASSETS: KVNamespace;
   INDEX_PAGE: string;
   ERROR_PAGE?: string;
-}
+  /**
+   * Optional backend worker bound to this static site
+   * Used to handle requests that don't match any static files
+   */
+  BACKEND_WORKER?: Service;
+} & {
+  // the binding to route the fetch call to
+  [key in `ROUTE_${string}`]: Service;
+} & {
+  // the route to match on, e.g. /api/*
+  [key in `__ROUTE_${string}`]: string;
+};
+
+let isInit = false;
+const app = new Hono<{ Bindings: Env }>();
 
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
-    const url = new URL(request.url);
-    console.log("url", request.url);
-    const pathname = url.pathname.replace(/^\//, "");
-    const filePath = pathname === "" ? env.INDEX_PAGE : pathname;
-
-    // Return from cache if available
-    const cachedResponse = await lookupCache();
-    if (cachedResponse) return cachedResponse;
-
-    // Fetch from KV
-    {
-      const object = await env.ASSETS.getWithMetadata(filePath);
-      if (object.value) return await respond(200, filePath, object);
+    if (!isInit) {
+      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));
+        }
+      }
     }
-    {
-      const guess =
-        filePath + (filePath.endsWith("/") ? "" : "/") + "index.html";
-      const object = await env.ASSETS.getWithMetadata(guess);
-      if (object.value) return await respond(200, guess, object);
+    return app.fetch(request, env);
+  },
+};
+
+// 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);
+  const pathname = url.pathname.replace(/^\//, "");
+  const filePath = pathname === "" ? env.INDEX_PAGE : pathname;
+
+  // Return from cache if available
+  const cachedResponse = await lookupCache();
+  if (cachedResponse) {
+    return cachedResponse;
+  }
+
+  // Fetch from KV
+  {
+    const object = await env.ASSETS.getWithMetadata(filePath);
+    if (object.value) {
+      return await respond(200, filePath, object);
     }
-    {
-      const guess = filePath + ".html";
-      const object = await env.ASSETS.getWithMetadata(guess);
-      if (object.value) return await respond(200, guess, object);
+  }
+  {
+    const guess = filePath + (filePath.endsWith("/") ? "" : "/") + "index.html";
+    const object = await env.ASSETS.getWithMetadata(guess);
+    if (object.value) {
+      return await respond(200, guess, object);
     }
-
-    // Handle error page
-    if (env.ERROR_PAGE) {
-      const object = await env.ASSETS.getWithMetadata(env.ERROR_PAGE);
-      if (object.value) return await respond(404, env.ERROR_PAGE, object);
-    } else {
-      const object = await env.ASSETS.getWithMetadata(env.INDEX_PAGE);
-      if (object.value) return await respond(200, env.INDEX_PAGE, object);
+  }
+  {
+    const guess = filePath + ".html";
+    const object = await env.ASSETS.getWithMetadata(guess);
+    if (object.value) {
+      return await respond(200, guess, object);
     }
+  }
 
-    // Handle failed to render error page
-    return new Response("Page Not Found", { status: 404 });
+  // Handle error page
+  if (env.ERROR_PAGE) {
+    const object = await env.ASSETS.getWithMetadata(env.ERROR_PAGE);
+    if (object.value) {
+      return await respond(404, env.ERROR_PAGE, object);
+    }
+  } else {
+    const object = await env.ASSETS.getWithMetadata(env.INDEX_PAGE);
+    if (object.value) {
+      return await respond(200, env.INDEX_PAGE, object);
+    }
+  }
 
-    async function lookupCache() {
-      const cache = caches.default;
-      const r = await cache.match(request);
+  return new Response("Page Not Found", { status: 404 });
 
-      // cache does not exist
-      if (!r) return;
+  async function lookupCache() {
+    const cache = caches.default;
+    const r = await cache.match(request.url);
 
-      // cache exists but etag does not match
-      if (r.headers.get("etag") !== __ASSET_MANIFEST__[filePath]) return;
+    // cache does not exist
+    if (!r) return;
 
-      // cache exists
-      return r;
-    }
+    // cache exists but etag does not match
+    if (r.headers.get("etag") !== __ASSET_MANIFEST__[filePath]) return;
 
-    async function saveCache(response: Response) {
-      const cache = caches.default;
-      await cache.put(request, response.clone());
-    }
+    // cache exists
+    return r;
+  }
 
-    async function respond(
-      status: number,
-      filePath: string,
-      object: KVNamespaceGetWithMetadataResult<any, any>,
-    ) {
-      // build response
-      const headers = new Headers();
-      if (__ASSET_MANIFEST__[filePath]) {
-        headers.set("etag", __ASSET_MANIFEST__[filePath]);
-        headers.set("content-type", object.metadata.contentType);
-        headers.set("cache-control", object.metadata.cacheControl);
-      }
-      // TODO: do we need base64 encoded here?
-      // const response = new Response(base64ToArrayBuffer(object.value), {
-      const response = new Response(object.value, {
-        status,
-        headers,
-      });
-
-      if (request.method === "GET") {
-        await saveCache(response);
-      }
+  async function saveCache(response: Response) {
+    const cache = caches.default;
+    await cache.put(request.url, response.clone());
+  }
 
-      return response;
+  async function respond(
+    status: number,
+    filePath: string,
+    object: KVNamespaceGetWithMetadataResult<any, any>,
+  ) {
+    // build response
+    const headers = new Headers();
+    if (__ASSET_MANIFEST__[filePath]) {
+      headers.set("etag", __ASSET_MANIFEST__[filePath]);
+      headers.set("content-type", object.metadata.contentType);
+      headers.set("cache-control", object.metadata.cacheControl);
+    }
+    // TODO: do we need base64 encoded here?
+    // const response = new Response(base64ToArrayBuffer(object.value), {
+    const response = new Response(object.value, {
+      status,
+      headers,
+    });
+
+    if (request.method === "GET") {
+      await saveCache(response);
     }
-  },
-};
 
-function base64ToArrayBuffer(base64: any) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
+    return response;
   }
-  return bytes.buffer;
-}
+});

package/src/cloudflare/static-site.ts

@@ -4,15 +4,17 @@ 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 { createCloudflareApi } from "./api";
-import type { WorkerBinding } from "./bindings";
+import type { WorkerBindingSpec } from "./bindings";
 import { generateAssetManifest } from "./generate-asset-manifest";
 import { KVNamespace } from "./kv-namespace";
 import { uploadAssetManifest } from "./upload-asset-manifest";
-import type { WorkerProps } from "./worker";
 import { Worker } from "./worker";
 
+const __dirname = import.meta.dirname;
+
 /**
  * Idea of using KV with timeout inspired by SST: https://github.com/sst/sst/blob/dev/platform/src/components/cloudflare/static-site.ts
  */
@@ -32,12 +34,6 @@ export interface StaticSiteProps {
    */
   dir: string;
 
-  /**
-   * Routes to associate with this site
-   * Format: example.com/* or *.example.com/*
-   */
-  routes?: string[];
-
   /**
    * Custom Worker script to serve the site
    * If not provided, a default script will be used
@@ -95,11 +91,6 @@ export interface StaticSiteProps {
     }[];
   };
 
-  /**
-   * Additional Worker bindings to include
-   */
-  additionalBindings?: WorkerProps["bindings"];
-
   /**
    * Whether the site should be deployed to production
    * @default true
@@ -124,7 +115,17 @@ export interface StaticSiteProps {
     command?: string;
   };
 
+  /**
+   * Bundle options for the worker script
+   */
   bundle?: Partial<BundleProps>;
+
+  /**
+   * Additional workers to route requests to.
+   */
+  routes?: {
+    [key: string]: Worker;
+  };
 }
 
 /**
@@ -151,11 +152,6 @@ export interface StaticSiteOutput {
    */
   directory: string;
 
-  /**
-   * Routes to associate with this site
-   */
-  routes?: string[];
-
   /**
    * Worker script format
    */
@@ -205,6 +201,11 @@ export interface StaticSiteOutput {
    * The URL of the deployed site
    */
   url?: string;
+
+  /**
+   * Information about the backend worker if configured
+   */
+  routes?: Record<string, string>;
 }
 
 export class StaticSite extends Resource(
@@ -245,13 +246,15 @@ export class StaticSite extends Resource(
     // Run build command if provided
     if (props.build?.command) {
       try {
-        console.log(props.build.command);
+        if (!ctx.quiet) {
+          console.log(props.build.command);
+        }
         const execAsync = promisify(exec);
         const { stdout, stderr } = await execAsync(props.build.command, {
           cwd: process.cwd(),
         });
 
-        if (stdout) console.log(stdout);
+        if (stdout && !ctx.quiet) console.log(stdout);
       } catch (error: any) {
         // Log detailed error information
         console.error(`Build command failed with exit code ${error.code}`);
@@ -278,18 +281,17 @@ export class StaticSite extends Resource(
     });
 
     const [{ id: kvNamespaceId }, assetManifest] = await Promise.all([
-      apply(namespace),
+      apply(namespace, {
+        quiet: ctx.quiet,
+      }),
       generateAssetManifest(props.dir),
     ]);
 
     // Step 3: Upload assets to KV
     await uploadAssetManifest(api, kvNamespaceId, assetManifest);
 
-    // Define the worker script path
-    const routerScriptPath = path.resolve(__dirname, "static-site-router.ts");
-
     // Prepare the bindings for the worker
-    const bindings: WorkerBinding[] = [
+    const bindings: Input<WorkerBindingSpec>[] = [
       {
         name: "ASSETS",
         type: "kv_namespace",
@@ -311,9 +313,18 @@ export class StaticSite extends Resource(
       });
     }
 
-    // Add any additional bindings
-    if (props.additionalBindings) {
-      bindings.push(...props.additionalBindings);
+    const routes: Record<string, string> = {};
+    // Create backend worker if configured
+    if (props.routes) {
+      for (const [path, entrypoint] of Object.entries(props.routes)) {
+        // @ts-ignore - TODO: need to use Resolved<Worker> to get the string ...
+        routes[path] = entrypoint.id;
+        bindings.push({
+          type: "service",
+          name: `ROUTE_${entrypoint.id}`,
+          service: entrypoint.id,
+        });
+      }
     }
 
     // Create asset manifest banner for static site router
@@ -321,48 +332,52 @@ export class StaticSite extends Resource(
       Object.fromEntries(assetManifest.map((item) => [item.key, item.hash])),
     )};\n`;
 
+    const bundleOptions = {
+      ...props.bundle,
+      options: {
+        ...props.bundle?.options,
+        banner: {
+          js: assetManifestBanner,
+          ...props.bundle?.options?.banner,
+        },
+      },
+    };
     const worker = new Worker(
       "worker",
       {
         name: siteName,
         url: true,
         format: props.format || "esm",
-        routes: props.routes || [],
         // If a custom worker script is provided, use it, otherwise use the entrypoint from router
         ...(props.workerScript
           ? { script: props.workerScript }
           : {
-              entrypoint: routerScriptPath,
-              bundleOptions: {
-                ...props.bundle,
-                options: {
-                  ...props.bundle?.options,
-                  banner: {
-                    js: assetManifestBanner,
-                    ...props.bundle?.options?.banner,
-                  },
-                },
-              },
+              entrypoint: path.resolve(__dirname, "static-site-router.ts"),
+              bundle: bundleOptions,
             }),
         bindings,
+        env: {
+          ...Object.fromEntries(
+            Object.entries(routes).map(([key, value]) => [
+              `__ROUTE_${value}`,
+              key,
+            ]),
+          ),
+        },
       },
       // place a dependency on the namespace
       namespace.id,
     );
 
-    // Step 4: Create or update the worker
-    const { id: workerId, url } = await apply(worker);
-
     // Get current timestamp
     const now = Date.now();
 
     // Construct the output
-    const output: StaticSiteOutput = {
+    const output: Input<StaticSiteOutput> = {
       id: siteName,
-      workerId,
+      workerId: worker.id,
       name: siteName,
       directory: props.dir,
-      routes: props.routes || [],
       format: props.format || "esm",
       errorPage: props.errorPage,
       indexPage,
@@ -371,7 +386,8 @@ export class StaticSite extends Resource(
       updatedAt: now,
       domain: props.domain,
       production: props.production !== false,
-      url,
+      url: worker.url,
+      routes,
     };
 
     return output;

package/src/cloudflare/worker-metadata.ts

@@ -0,0 +1,154 @@
+/**
+ * Metadata returned by Cloudflare API for a worker script
+ */
+export interface WorkerScriptMetadata {
+  /**
+   * Worker ID
+   */
+  id: string;
+
+  /**
+   * Default environment information
+   */
+  default_environment?: WorkerDefaultEnvironment;
+
+  /**
+   * Worker creation timestamp
+   */
+  created_on: string;
+
+  /**
+   * Worker last modification timestamp
+   */
+  modified_on: string;
+
+  /**
+   * Worker usage model
+   */
+  usage_model: string;
+
+  /**
+   * Worker environments
+   */
+  environments?: WorkerEnvironment[];
+}
+
+/**
+ * Worker script information
+ */
+export interface WorkerScriptInfo {
+  /**
+   * Script creation timestamp
+   */
+  created_on: string;
+
+  /**
+   * Script last modification timestamp
+   */
+  modified_on: string;
+
+  /**
+   * Script ID
+   */
+  id: string;
+
+  /**
+   * Script tag
+   */
+  tag: string;
+
+  /**
+   * Script tags
+   */
+  tags: string[];
+
+  /**
+   * Deployment ID
+   */
+  deployment_id: string;
+
+  /**
+   * Tail consumers
+   */
+  tail_consumers: any;
+
+  /**
+   * Whether logpush is enabled
+   */
+  logpush: boolean;
+
+  /**
+   * Observability settings
+   */
+  observability: {
+    /**
+     * Whether observability is enabled
+     */
+    enabled: boolean;
+
+    /**
+     * Head sampling rate
+     */
+    head_sampling_rate: number | null;
+  };
+
+  /**
+   * Whether the script has assets
+   */
+  has_assets: boolean;
+
+  /**
+   * Whether the script has modules
+   */
+  has_modules: boolean;
+
+  /**
+   * Script etag
+   */
+  etag: string;
+
+  /**
+   * Script handlers
+   */
+  handlers: string[];
+
+  /**
+   * Where the script was last deployed from
+   */
+  last_deployed_from: string;
+
+  /**
+   * Script usage model
+   */
+  usage_model: string;
+}
+
+/**
+ * Worker environment information
+ */
+export interface WorkerEnvironment {
+  /**
+   * Environment name
+   */
+  environment: string;
+
+  /**
+   * Environment creation timestamp
+   */
+  created_on: string;
+
+  /**
+   * Environment last modification timestamp
+   */
+  modified_on: string;
+}
+
+/**
+ * Default environment with script information
+ */
+export interface WorkerDefaultEnvironment extends WorkerEnvironment {
+  /**
+   * Script information
+   */
+  script: WorkerScriptInfo;
+}