@timber-js/app 0.2.0-alpha.15 → 0.2.0-alpha.150

package/src/adapters/cloudflare.ts

@@ -3,36 +3,39 @@
 // Primary deployment target. Generates a Workers-compatible entry point
 // and wrangler.jsonc configuration. See design/11-platform.md §"Cloudflare Workers".
 
-import { writeFile, mkdir, cp } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { join, relative } from 'node:path';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { TimberPlatformAdapter, TimberConfig } from './types';
-// Inlined from server/asset-headers.ts — adapters are loaded by Node at
-// Vite startup time, before Vite's module resolver is available, so cross-
-// directory .ts imports don't resolve.
-const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable';
-const STATIC_CACHE = 'public, max-age=3600, must-revalidate';
-
-function generateHeadersFile(): string {
-  return `# Auto-generated by @timber-js/app — static asset cache headers.
-# See design/25-production-deployments.md §"CDN / Edge Cache"
-
-/assets/*
-  Cache-Control: ${IMMUTABLE_CACHE}
-
-/*
-  Cache-Control: ${STATIC_CACHE}
-`;
-}
+import { runSharedBuildSteps } from './build-output-helper.js';
 
 // ─── Bindings passthrough ─────────────────────────────────────────────────
 // ALS stores the env object per-request so server components and middleware
 // can access KV, D1, DO, R2, Queues, etc. via getCloudflareBindings().
 // No global fallback — if called outside a request, it throws.
 // See design/11-platform.md §"Platform Target" and design/25-production-deployments.md.
-
-const bindingsAls = new AsyncLocalStorage<Record<string, unknown>>();
+//
+// The ALS is stored on globalThis via Symbol.for so it survives Vite's
+// module instance split in dev mode. The Vite host process (where
+// cloudflareDevBindings → runWithBindings runs) and the RSC module runner
+// (where getCloudflareBindings runs) load separate instances of this file,
+// each with their own module-level variables. globalThis + Symbol.for
+// ensures both share the same ALS — same pattern React uses for
+// Symbol.for('react.element').
+
+const BINDINGS_ALS_KEY = Symbol.for('timber:cf-bindings-als');
+
+function getBindingsAls(): AsyncLocalStorage<Record<string, unknown>> {
+  let als = (globalThis as any)[BINDINGS_ALS_KEY] as
+    | AsyncLocalStorage<Record<string, unknown>>
+    | undefined;
+  if (!als) {
+    als = new AsyncLocalStorage<Record<string, unknown>>();
+    (globalThis as any)[BINDINGS_ALS_KEY] = als;
+  }
+  return als;
+}
 
 /**
  * Get Cloudflare Worker bindings for the current request.
@@ -55,10 +58,8 @@ const bindingsAls = new AsyncLocalStorage<Record<string, unknown>>();
  * }
  * ```
  */
-export function getCloudflareBindings<
-  T extends Record<string, unknown> = Record<string, unknown>,
->(): T {
-  const env = bindingsAls.getStore();
+export function getCloudflareBindings<T = Record<string, unknown>>(): T {
+  const env = getBindingsAls().getStore();
   if (!env) {
     throw new Error(
       'getCloudflareBindings() called outside a Cloudflare Workers request context. ' +
@@ -71,10 +72,88 @@ export function getCloudflareBindings<
 
 /**
  * Run a function with Cloudflare bindings available via getCloudflareBindings().
- * @internal Used by wrapWithExecutionContext.
+ * @internal Used by cloudflareDevBindings() to wrap dev-server requests.
  */
 export function runWithBindings<T>(env: Record<string, unknown>, fn: () => T): T {
-  return bindingsAls.run(env, fn);
+  return getBindingsAls().run(env, fn);
+}
+
+// ─── Binding configuration types ──────────────────────────────────────────────
+// Declarative binding config that maps to wrangler.jsonc binding sections.
+// See design/35-cloudflare-primitives.md §"Binding Declarations in Adapter Config".
+
+/** KV namespace binding. `id` defaults to `''` (filled in by wrangler or dashboard). */
+export interface CloudflareKVBinding {
+  name: string;
+  id?: string;
+}
+
+/** D1 database binding. `database_id` is required (from Cloudflare dashboard). */
+export interface CloudflareD1Binding {
+  name: string;
+  database_id: string;
+}
+
+/** R2 bucket binding. `bucket_name` must match the bucket created in Cloudflare. */
+export interface CloudflareR2Binding {
+  name: string;
+  bucket_name: string;
+}
+
+/** Queue producer binding. `queue` is the queue name in Cloudflare. */
+export interface CloudflareQueueProducer {
+  name: string;
+  queue: string;
+}
+
+/** Queue consumer declaration. Attached to the worker, not a binding name. */
+export interface CloudflareQueueConsumer {
+  queue: string;
+  max_batch_size?: number;
+  max_retries?: number;
+  dead_letter_queue?: string;
+}
+
+/** Durable Object binding. `script_name` is for external DO references. */
+export interface CloudflareDurableObjectBinding {
+  name: string;
+  class_name: string;
+  script_name?: string;
+}
+
+/**
+ * Declarative Cloudflare bindings configuration.
+ *
+ * These are converted to the appropriate wrangler.jsonc sections
+ * (`kv_namespaces`, `d1_databases`, `r2_buckets`, `queues`, `durable_objects`).
+ * The `wrangler` escape hatch overrides any generated binding sections
+ * if there's a conflict.
+ *
+ * @example
+ * ```ts
+ * cloudflare({
+ *   bindings: {
+ *     kv: [{ name: 'TIMBER_CACHE' }],
+ *     d1: [{ name: 'MY_DB', database_id: 'xxxx' }],
+ *     r2: [{ name: 'MY_BUCKET', bucket_name: 'my-bucket' }],
+ *     queues: {
+ *       producers: [{ name: 'EMAIL_QUEUE', queue: 'email-queue' }],
+ *       consumers: [{ queue: 'email-queue', max_batch_size: 10 }],
+ *     },
+ *     durableObjects: [{ name: 'MY_DO', class_name: 'MyDurableObject' }],
+ *   },
+ * })
+ * ```
+ */
+export interface CloudflareBindings {
+  kv?: CloudflareKVBinding[];
+  d1?: CloudflareD1Binding[];
+  r2?: CloudflareR2Binding[];
+  queues?: {
+    producers?: CloudflareQueueProducer[];
+    consumers?: CloudflareQueueConsumer[];
+  };
+  durableObjects?: CloudflareDurableObjectBinding[];
 }
 
 /** Options for the Cloudflare Workers adapter. */
@@ -91,11 +170,42 @@ export interface CloudflareAdapterOptions {
    */
   compatibilityFlags?: string[];
 
+  /**
+   * Declarative Cloudflare bindings. Generates the appropriate
+   * `kv_namespaces`, `d1_databases`, `r2_buckets`, `queues`, and
+   * `durable_objects` sections in wrangler.jsonc.
+   *
+   * If both `bindings` and `wrangler` specify the same section,
+   * `wrangler` wins (it's the escape hatch).
+   */
+  bindings?: CloudflareBindings;
+
   /**
    * Custom wrangler.jsonc fields to merge.
-   * Overrides generated values.
+   * Overrides generated values (including bindings-generated sections).
    */
   wrangler?: Record<string, unknown>;
+
+  /**
+   * Path to a module that exports additional Worker handlers (queue, scheduled, email, etc.).
+   * The module is imported in the generated `_worker.js` and its named exports are
+   * spread into the default export alongside `fetch`.
+   *
+   * The module receives `(batch/event, env, ctx)` — standard Cloudflare handler signatures.
+   * It does NOT have access to timber's request pipeline (no ALS, no getCloudflareBindings).
+   * Use `env` directly for bindings.
+   *
+   * @example
+   * ```ts
+   * // timber.config.ts
+   * adapter: cloudflare({ workerHandlers: './src/worker-handlers.ts' })
+   *
+   * // src/worker-handlers.ts
+   * export async function queue(batch, env) { ... }
+   * export async function scheduled(controller, env, ctx) { ... }
+   * ```
+   */
+  workerHandlers?: string;
 }
 
 /**
@@ -117,43 +227,45 @@ export function cloudflare(options: CloudflareAdapterOptions = {}): TimberPlatfo
 
     async buildOutput(config: TimberConfig, buildDir: string) {
       const outDir = join(buildDir, 'cloudflare');
-      await mkdir(outDir, { recursive: true });
-
-      // Copy client assets to static output.
-      // When client JavaScript is disabled, skip .js files — only CSS,
-      // fonts, images, and other static assets are needed.
-      const clientDir = join(buildDir, 'client');
-      const staticDir = join(outDir, 'static');
-      await mkdir(staticDir, { recursive: true });
-      await cp(clientDir, staticDir, {
-        recursive: true,
-        filter: config.clientJavascriptDisabled ? (src: string) => !src.endsWith('.js') : undefined,
-      }).catch(() => {
-        // Client dir may not exist when client JavaScript is disabled
+
+      // Steps 1–5: shared across all adapters (mkdir, copy client/rsc/ssr,
+      // write _headers, write manifest-init).
+      await runSharedBuildSteps({
+        config,
+        buildDir,
+        outDir,
+        publicDirName: 'static',
       });
 
-      // Write _headers file for static asset cache control.
-      // Cloudflare Workers Static Assets reads this to set Cache-Control
-      // headers on responses. Hashed assets get immutable; others get 1h.
-      await writeFile(join(staticDir, '_headers'), generateHeadersFile());
-
-      // Copy server bundles (rsc + ssr) into the output directory.
-      // These are already fully bundled by Vite with resolve.noExternal: true.
-      const rscDir = join(buildDir, 'rsc');
-      const ssrDir = join(buildDir, 'ssr');
-      await cp(rscDir, join(outDir, 'rsc'), { recursive: true });
-      await cp(ssrDir, join(outDir, 'ssr'), { recursive: true });
-
-      // Write the build manifest init module (if manifest data was produced).
-      // This must be imported before the RSC handler so the global is set
-      // when virtual:timber-build-manifest evaluates.
-      if (config.manifestInit) {
-        await writeFile(join(outDir, '_timber-manifest-init.js'), config.manifestInit);
+      // Compile optional worker handlers (queue, scheduled, etc.)
+      // Uses Vite's build API to bundle the TypeScript source into ESM.
+      let hasWorkerHandlers = false;
+      if (options.workerHandlers) {
+        const handlersEntry = join(process.cwd(), options.workerHandlers);
+        const { build: viteBuild } = await import('vite');
+        await viteBuild({
+          configFile: false,
+          logLevel: 'info',
+          build: {
+            lib: {
+              entry: handlersEntry,
+              formats: ['es'],
+              fileName: () => '_worker-handlers.js',
+            },
+            outDir,
+            emptyOutDir: false,
+            minify: false,
+            rollupOptions: {
+              external: [/^node:/],
+            },
+          },
+        });
+        hasWorkerHandlers = true;
       }
 
       // Generate the Workers entry point
       const hasManifestInit = !!config.manifestInit;
-      const workerEntry = generateWorkerEntry(outDir, outDir, hasManifestInit);
+      const workerEntry = generateWorkerEntry(outDir, outDir, hasManifestInit, hasWorkerHandlers);
       await writeFile(join(outDir, '_worker.js'), workerEntry);
 
       // Generate wrangler.jsonc
@@ -166,45 +278,11 @@ export function cloudflare(options: CloudflareAdapterOptions = {}): TimberPlatfo
       await spawnPreviewProcess(cmd.command, cmd.args, cmd.cwd);
     },
 
-    // Default no-op. wrapWithExecutionContext() replaces this per-request
-    // with a function that routes to ctx.waitUntil().
-    waitUntil(_promise: Promise<unknown>) {},
-  };
-}
-
-/**
- * Wrap a timber request handler to bind the Cloudflare execution context
- * for `waitUntil()` support and env bindings passthrough.
- * Called from the generated worker entry.
- *
- * This function:
- * 1. Binds `adapter.waitUntil()` to `ctx.waitUntil()` per-request
- * 2. Makes `env` accessible via `getCloudflareBindings()` per-request via ALS
- */
-export function wrapWithExecutionContext(
-  adapter: TimberPlatformAdapter,
-  handler: (req: Request) => Promise<Response>
-): ExportedHandler<Record<string, unknown>> {
-  return {
-    async fetch(
-      request: Request,
-      env: Record<string, unknown>,
-      ctx: ExecutionContext
-    ): Promise<Response> {
-      // Bind the adapter's waitUntil to the Workers execution context
-      const originalWaitUntil = adapter.waitUntil;
-      adapter.waitUntil = (promise: Promise<unknown>) => {
-        ctx.waitUntil(promise);
-      };
-
-      try {
-        // Run the handler within ALS so getCloudflareBindings() works
-        return await runWithBindings(env, () => handler(request));
-      } finally {
-        // Restore (in case adapter is reused across isolate resets)
-        adapter.waitUntil = originalWaitUntil;
-      }
-    },
+    // No adapter-level waitUntil: on Workers there is no ambient
+    // ExecutionContext outside a request, so support is provided
+    // per-request by the generated _worker.js, which bridges
+    // ctx.waitUntil() into the ALS via runWithWaitUntil().
+    // See design/11-platform.md §"waitUntil()".
   };
 }
 
@@ -214,7 +292,8 @@ export function wrapWithExecutionContext(
 export function generateWorkerEntry(
   buildDir: string,
   outDir: string,
-  hasManifestInit = false
+  hasManifestInit = false,
+  hasWorkerHandlers = false
 ): string {
   // The RSC entry is the main request handler — it exports the fetch handler as default.
   // The Vite RSC plugin outputs it to rsc/index.js.
@@ -229,20 +308,176 @@ export function generateWorkerEntry(
   // ESM guarantees imports are evaluated in order.
   const manifestImport = hasManifestInit ? "import './_timber-manifest-init.js'\n" : '';
 
+  // Optional additional Worker handlers (queue, scheduled, email, etc.)
+  // Compiled by buildOutput via Vite's build API into _worker-handlers.js.
+  // The module's named exports are spread into the default export alongside fetch.
+  const handlersImport = hasWorkerHandlers
+    ? "import * as workerHandlers from './_worker-handlers.js'\n"
+    : '';
+  const handlersSpread = hasWorkerHandlers ? '  ...workerHandlers,\n' : '';
+
   return `// Generated by @timber-js/app/adapters/cloudflare
 // Do not edit — this file is regenerated on each build.
 
-${manifestImport}import handler from '${rscEntryRelative}'
-
+import { AsyncLocalStorage } from 'node:async_hooks'
+${manifestImport}import handler, { runWithWaitUntil } from '${rscEntryRelative}'
+${handlersImport}
 // Set TIMBER_RUNTIME for instrumentation.ts conditional SDK initialization.
 // See design/25-production-deployments.md §"TIMBER_RUNTIME".
 globalThis.process ??= { env: {} }
 process.env.TIMBER_RUNTIME = 'cloudflare'
 
-export default { fetch: handler }
+// Bind Cloudflare env to ALS so getCloudflareBindings() works at runtime.
+// Uses the same Symbol.for key as getCloudflareBindings() reads from.
+const ALS_KEY = Symbol.for('timber:cf-bindings-als')
+let bindingsAls = globalThis[ALS_KEY]
+if (!bindingsAls) {
+  bindingsAls = new AsyncLocalStorage()
+  globalThis[ALS_KEY] = bindingsAls
+}
+
+export default {
+${handlersSpread}  async fetch(request, env, ctx) {
+    // Bridge ctx.waitUntil into the per-request ALS so waitUntil() calls in
+    // user code keep the isolate alive after the response is sent.
+    // See design/11-platform.md §"waitUntil()".
+    return bindingsAls.run(env, () =>
+      runWithWaitUntil((promise) => ctx.waitUntil(promise), () => handler(request))
+    )
+  }
+}
 `;
 }
 
+/** Wrangler binding sections generated from `CloudflareBindings`. */
+export interface WranglerBindingsConfig {
+  kv_namespaces?: Array<{ binding: string; id: string }>;
+  d1_databases?: Array<{ binding: string; database_id: string }>;
+  r2_buckets?: Array<{ binding: string; bucket_name: string }>;
+  queues?: {
+    producers?: Array<{ binding: string; queue: string }>;
+    consumers?: Array<Record<string, unknown>>;
+  };
+  durable_objects?: {
+    bindings: Array<Record<string, string>>;
+  };
+}
+
+/**
+ * Convert declarative `CloudflareBindings` into wrangler.jsonc binding sections.
+ *
+ * Maps:
+ * - `kv`             → `kv_namespaces`
+ * - `d1`             → `d1_databases`
+ * - `r2`             → `r2_buckets`
+ * - `queues`         → `queues` (producers + consumers)
+ * - `durableObjects` → `durable_objects`
+ *
+ * Empty arrays are omitted from the output.
+ *
+ * @internal Exported for testing.
+ */
+export function generateBindingsConfig(
+  bindings: CloudflareBindings | undefined
+): WranglerBindingsConfig {
+  if (!bindings) return {};
+
+  const result: WranglerBindingsConfig = {};
+
+  // KV namespaces
+  if (bindings.kv && bindings.kv.length > 0) {
+    result.kv_namespaces = bindings.kv.map((kv) => ({
+      binding: kv.name,
+      id: kv.id ?? '',
+    }));
+  }
+
+  // D1 databases
+  if (bindings.d1 && bindings.d1.length > 0) {
+    result.d1_databases = bindings.d1.map((d1) => ({
+      binding: d1.name,
+      database_id: d1.database_id,
+    }));
+  }
+
+  // R2 buckets
+  if (bindings.r2 && bindings.r2.length > 0) {
+    result.r2_buckets = bindings.r2.map((r2) => ({
+      binding: r2.name,
+      bucket_name: r2.bucket_name,
+    }));
+  }
+
+  // Queues (producers and/or consumers)
+  if (bindings.queues) {
+    const queues: Record<string, unknown> = {};
+    if (bindings.queues.producers && bindings.queues.producers.length > 0) {
+      queues.producers = bindings.queues.producers.map((p) => ({
+        binding: p.name,
+        queue: p.queue,
+      }));
+    }
+    if (bindings.queues.consumers && bindings.queues.consumers.length > 0) {
+      queues.consumers = bindings.queues.consumers.map((c) => {
+        const consumer: Record<string, unknown> = { queue: c.queue };
+        if (c.max_batch_size !== undefined) consumer.max_batch_size = c.max_batch_size;
+        if (c.max_retries !== undefined) consumer.max_retries = c.max_retries;
+        if (c.dead_letter_queue !== undefined) consumer.dead_letter_queue = c.dead_letter_queue;
+        return consumer;
+      });
+    }
+    if (Object.keys(queues).length > 0) {
+      result.queues = queues;
+    }
+  }
+
+  // Durable Objects
+  if (bindings.durableObjects && bindings.durableObjects.length > 0) {
+    result.durable_objects = {
+      bindings: bindings.durableObjects.map((dobj) => {
+        const entry: Record<string, string> = {
+          name: dobj.name,
+          class_name: dobj.class_name,
+        };
+        if (dobj.script_name) entry.script_name = dobj.script_name;
+        return entry;
+      }),
+    };
+  }
+
+  return result;
+}
+
+/**
+ * One-level deep merge: for each key in `override`, if both the base and
+ * override values are plain objects (not arrays, not null), merge their
+ * keys with override winning on conflicts. Everything else (primitives,
+ * arrays, null) is replaced outright — matching the intuitive behavior
+ * where `kv_namespaces: [...]` replaces fully but
+ * `durable_objects: { migrations }` merges with generated `bindings`.
+ */
+function shallowDeepMerge(
+  base: Record<string, unknown>,
+  override: Record<string, unknown>
+): Record<string, unknown> {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = result[key];
+    const overVal = override[key];
+    if (isPlainObject(baseVal) && isPlainObject(overVal)) {
+      result[key] = { ...baseVal, ...overVal };
+    } else {
+      result[key] = overVal;
+    }
+  }
+  return result;
+}
+
+/** True for `{}` literals — false for arrays, null, Date, etc. */
+function isPlainObject(val: unknown): val is Record<string, unknown> {
+  return val !== null && typeof val === 'object' && !Array.isArray(val);
+}
+
 /** @internal Exported for testing. */
 export function generateWranglerConfig(
   config: TimberConfig,
@@ -267,12 +502,20 @@ export function generateWranglerConfig(
     },
   };
 
-  // Merge user overrides
+  // Layer 1: merge bindings-generated sections into base
+  const bindingsConfig = generateBindingsConfig(options.bindings);
+  const merged = { ...base, ...bindingsConfig };
+
+  // Layer 2: wrangler escape hatch with deep merge for nested plain objects.
+  // A shallow spread would replace entire sections like durable_objects and
+  // queues — e.g. adding migrations via wrangler would drop the generated
+  // durable_objects.bindings. Deep merge preserves generated keys while
+  // letting wrangler override on actual key-level conflicts.
   if (options.wrangler) {
-    return { ...base, ...options.wrangler };
+    return shallowDeepMerge(merged, options.wrangler);
   }
 
-  return base;
+  return merged;
 }
 
 // ─── Preview ─────────────────────────────────────────────────────────────────
@@ -310,16 +553,13 @@ function spawnPreviewProcess(command: string, args: string[], cwd: string): Prom
 }
 
 // ─── Cloudflare Workers type stubs ───────────────────────────────────────────
-// Minimal type declarations so this file compiles without @cloudflare/workers-types.
-// In production builds, users install @cloudflare/workers-types themselves.
-
-declare global {
-  interface ExecutionContext {
-    waitUntil(promise: Promise<unknown>): void;
-    passThroughOnException(): void;
-  }
-
-  interface ExportedHandler<Env = Record<string, unknown>> {
-    fetch?(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> | Response;
-  }
+// Local type declarations so this file compiles without @cloudflare/workers-types.
+// These are NOT declared globally — that would clash with @cloudflare/workers-types
+// when users install it. Instead, they're module-scoped and used only within
+// this file's function signatures.
+
+/** @internal Minimal stub — use @cloudflare/workers-types for full types. */
+export interface CfExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
 }