@b9g/platform-cloudflare 0.1.9 → 0.1.11

package/src/index.js

@@ -2,47 +2,68 @@
 // src/index.ts
 import {
   BasePlatform,
-  loadConfig,
-  createCacheFactory
+  CustomLoggerStorage
 } from "@b9g/platform";
+import { createCacheFactory } from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["platform-cloudflare"]);
+import { CloudflareNativeCache } from "./caches.js";
+var logger = getLogger(["shovel", "platform"]);
 var CloudflarePlatform = class extends BasePlatform {
   name;
   #options;
   #miniflare;
   #assetsMiniflare;
-  // Separate instance for ASSETS binding
-  #config;
   constructor(options = {}) {
     super(options);
     this.#miniflare = null;
     this.#assetsMiniflare = null;
     this.name = "cloudflare";
     const cwd = options.cwd ?? ".";
-    this.#config = loadConfig(cwd);
     this.#options = {
       environment: options.environment ?? "production",
       assetsDirectory: options.assetsDirectory,
-      cwd
+      cwd,
+      config: options.config
     };
   }
   /**
-   * Create cache storage
-   * Uses config from shovel.json with memory cache default.
-   *
-   * Note: This is for the platform/test runner context. Inside actual
-   * Cloudflare Workers, native caches are available via globalThis.caches
-   * (captured by the banner as globalThis.__cloudflareCaches).
+   * Create cache storage using config from shovel.json
+   * Default: Cloudflare's native Cache API
+   * Merges with runtime defaults (actual class references) for fallback behavior
    */
   async createCaches() {
-    return new CustomCacheStorage(
-      createCacheFactory({ config: this.#config, defaultProvider: "cloudflare" })
+    const runtimeDefaults = {
+      default: { impl: CloudflareNativeCache }
+    };
+    const userCaches = this.#options.config?.caches ?? {};
+    const configs = {};
+    const allNames = /* @__PURE__ */ new Set([
+      ...Object.keys(runtimeDefaults),
+      ...Object.keys(userCaches)
+    ]);
+    for (const name of allNames) {
+      configs[name] = { ...runtimeDefaults[name], ...userCaches[name] };
+    }
+    return new CustomCacheStorage(createCacheFactory({ configs }));
+  }
+  /**
+   * Create directory storage for Cloudflare Workers
+   * Directories must be configured via shovel.json (no platform defaults)
+   */
+  async createDirectories() {
+    throw new Error(
+      "Cloudflare Workers do not have default directories. Configure directories in shovel.json using Cloudflare directory classes."
     );
   }
   /**
-   * Create "server" for Cloudflare Workers (which is really just the handler)
+   * Create logger storage for Cloudflare Workers
+   */
+  async createLoggers() {
+    return new CustomLoggerStorage((categories) => getLogger(categories));
+  }
+  /**
+   * Create "server" for Cloudflare Workers (stub for Platform interface)
    */
   createServer(handler, _options = {}) {
     return {
@@ -61,34 +82,22 @@ var CloudflarePlatform = class extends BasePlatform {
       }
     };
   }
-  /**
-   * Load ServiceWorker-style entrypoint using miniflare (workerd)
-   *
-   * Note: In production Cloudflare Workers, the banner/footer wrapper code
-   * handles request dispatch directly - loadServiceWorker is only used for
-   * local development with miniflare.
-   */
-  async loadServiceWorker(entrypoint, _options = {}) {
-    return this.#loadServiceWorkerWithMiniflare(entrypoint);
-  }
   /**
    * Load ServiceWorker using miniflare (workerd) for dev mode
    */
-  async #loadServiceWorkerWithMiniflare(entrypoint) {
+  async loadServiceWorker(entrypoint, _options = {}) {
     logger.info("Starting miniflare dev server", { entrypoint });
     const { Miniflare } = await import("miniflare");
     const miniflareOptions = {
-      modules: false,
-      // ServiceWorker format (not ES modules)
+      modules: true,
       scriptPath: entrypoint,
-      // Enable CF-compatible APIs
       compatibilityDate: "2024-09-23",
       compatibilityFlags: ["nodejs_compat"]
     };
     this.#miniflare = new Miniflare(miniflareOptions);
     await this.#miniflare.ready;
     if (this.#options.assetsDirectory) {
-      logger.info("Setting up separate ASSETS binding", {
+      logger.info("Setting up ASSETS binding", {
         directory: this.#options.assetsDirectory
       });
       this.#assetsMiniflare = new Miniflare({
@@ -101,9 +110,17 @@ var CloudflarePlatform = class extends BasePlatform {
         compatibilityDate: "2024-09-23"
       });
       await this.#assetsMiniflare.ready;
-      logger.info("ASSETS binding available", {});
     }
     const mf = this.#miniflare;
+    const assetsMf = this.#assetsMiniflare;
+    const disposeInstance = async () => {
+      await mf.dispose();
+      this.#miniflare = null;
+      if (assetsMf) {
+        await assetsMf.dispose();
+        this.#assetsMiniflare = null;
+      }
+    };
     const instance = {
       runtime: mf,
       handleRequest: async (request) => {
@@ -124,16 +141,11 @@ var CloudflarePlatform = class extends BasePlatform {
       get ready() {
         return true;
       },
-      dispose: async () => {
-        await mf.dispose();
-      }
+      dispose: disposeInstance
     };
     logger.info("Miniflare dev server ready", {});
     return instance;
   }
-  /**
-   * Dispose of platform resources
-   */
   async dispose() {
     if (this.#miniflare) {
       await this.#miniflare.dispose();
@@ -144,219 +156,84 @@ var CloudflarePlatform = class extends BasePlatform {
       this.#assetsMiniflare = null;
     }
   }
-};
-function createOptionsFromEnv(env) {
-  return {
-    environment: env.ENVIRONMENT || "production"
-  };
-}
-function generateWranglerConfig(options) {
-  const {
-    name,
-    entrypoint,
-    cacheAdapter: _cacheAdapter,
-    filesystemAdapter,
-    kvNamespaces = [],
-    r2Buckets = [],
-    d1Databases = []
-  } = options;
-  const autoKVNamespaces = [];
-  const autoR2Buckets = filesystemAdapter === "r2" ? ["STORAGE_R2"] : [];
-  const allKVNamespaces = [.../* @__PURE__ */ new Set([...kvNamespaces, ...autoKVNamespaces])];
-  const allR2Buckets = [.../* @__PURE__ */ new Set([...r2Buckets, ...autoR2Buckets])];
-  return `# Generated wrangler.toml for Shovel app
-name = "${name}"
-main = "${entrypoint}"
-compatibility_date = "2024-09-23"
-compatibility_flags = ["nodejs_compat"]
+  /**
+   * Get virtual entry wrapper for Cloudflare Workers
+   *
+   * Wraps user code with:
+   * 1. Config import (shovel:config virtual module)
+   * 2. Runtime initialization (ServiceWorkerGlobals)
+   * 3. User code import (registers fetch handlers)
+   * 4. ES module export for Cloudflare Workers format
+   *
+   * Note: Unlike Node/Bun, Cloudflare bundles user code inline, so the
+   * entryPath is embedded directly in the wrapper.
+   */
+  getEntryWrapper(entryPath, _options) {
+    const safePath = JSON.stringify(entryPath);
+    return `// Cloudflare Worker Entry
+import { config } from "shovel:config";
+import { initializeRuntime, createFetchHandler } from "@b9g/platform-cloudflare/runtime";
 
-# ServiceWorker format (since Shovel apps are ServiceWorker-style)
-usage_model = "bundled"
+const registration = await initializeRuntime(config);
 
-# KV bindings${allKVNamespaces.length > 0 ? "\n" + allKVNamespaces.map(
-    (kv) => `[[kv_namespaces]]
-binding = "${kv}"
-id = "your-kv-namespace-id"
-preview_id = "your-preview-kv-namespace-id"`
-  ).join("\n\n") : ""}
+import ${safePath};
 
-# R2 bindings${allR2Buckets.length > 0 ? "\n" + allR2Buckets.map(
-    (bucket) => `[[r2_buckets]]
-binding = "${bucket}"
-bucket_name = "your-bucket-name"`
-  ).join("\n\n") : ""}
+// Run ServiceWorker lifecycle (install/activate events for migrations, cache warmup, etc.)
+await registration.install();
+await registration.activate();
 
-# D1 bindings
-${d1Databases.map(
-    (db) => `[[d1_databases]]
-binding = "${db}"
-database_name = "your-database-name"
-database_id = "your-database-id"`
-  ).join("\n\n")}
+export default { fetch: createFetchHandler(registration) };
 `;
-}
-var cloudflareWorkerBanner = `// Cloudflare Worker ES Module wrapper
-let serviceWorkerGlobals = null;
-
-// Capture native Cloudflare caches before any framework code runs
-const nativeCaches = globalThis.caches;
-
-// Set up ServiceWorker environment
-if (typeof globalThis.self === 'undefined') {
-	globalThis.self = globalThis;
-}
-
-// Store native caches for access via globalThis.__cloudflareCaches
-globalThis.__cloudflareCaches = nativeCaches;
-
-// Capture fetch event handlers
-const fetchHandlers = [];
-const originalAddEventListener = globalThis.addEventListener;
-globalThis.addEventListener = function(type, handler, options) {
-	if (type === 'fetch') {
-		fetchHandlers.push(handler);
-	} else {
-		originalAddEventListener?.call(this, type, handler, options);
-	}
+  }
+  /**
+   * Get Cloudflare-specific esbuild configuration
+   *
+   * Note: Cloudflare Workers natively support import.meta.env, so no define alias
+   * is needed. The nodejs_compat flag enables node:* built-in modules at runtime,
+   * so we externalize them during bundling.
+   */
+  getESBuildConfig() {
+    return {
+      platform: "browser",
+      conditions: ["worker", "browser"],
+      // Externalize node builtins - available at runtime via nodejs_compat flag
+      // Include both node:* prefix and bare module names for compatibility
+      external: [
+        "node:*",
+        "path",
+        "fs",
+        "fs/promises",
+        "crypto",
+        "util",
+        "stream",
+        "buffer",
+        "events"
+      ],
+      // Cloudflare bundles user code inline via `import "user-entry"`
+      bundlesUserCodeInline: true
+    };
+  }
+  /**
+   * Get Cloudflare-specific defaults for config generation
+   */
+  getDefaults() {
+    return {
+      caches: {
+        default: {
+          module: "@b9g/platform-cloudflare/caches"
+        }
+      },
+      directories: {
+        public: {
+          module: "@b9g/platform-cloudflare/directories",
+          export: "CloudflareAssetsDirectory"
+        }
+      }
+    };
+  }
 };
-
-// Create a promise-based FetchEvent that can be awaited
-class FetchEvent {
-	constructor(type, init) {
-		this.type = type;
-		this.request = init.request;
-		this._response = null;
-		this._responsePromise = new Promise((resolve) => {
-			this._resolveResponse = resolve;
-		});
-	}
-	
-	respondWith(response) {
-		this._response = response;
-		this._resolveResponse(response);
-	}
-	
-	async waitUntil(promise) {
-		await promise;
-	}
-}`;
-var cloudflareWorkerFooter = `
-// Export ES Module for Cloudflare Workers
-export default {
-	async fetch(request, env, ctx) {
-		try {
-			// Set up ServiceWorker-like dirs API for bundled deployment
-			if (!globalThis.self.dirs) {
-				// For bundled deployment, assets are served via static middleware
-				// not through the dirs API
-				globalThis.self.dirs = {
-					async open(directoryName) {
-						if (directoryName === 'assets') {
-							// Return a minimal interface that indicates no files available
-							// The assets middleware will fall back to dev mode behavior
-							return {
-								async getFileHandle(fileName) {
-									throw new Error(\`NotFoundError: \${fileName} not found in bundled assets\`);
-								}
-							};
-						}
-						throw new Error(\`Directory \${directoryName} not available in bundled deployment\`);
-					}
-				};
-			}
-			
-			// Set up caches API
-			if (!globalThis.self.caches) {
-				globalThis.self.caches = globalThis.caches;
-			}
-			
-			// Ensure request.url is a string
-			if (typeof request.url !== 'string') {
-				return new Response('Invalid request URL: ' + typeof request.url, { status: 500 });
-			}
-			
-			// Create proper FetchEvent-like object
-			let responseReceived = null;
-			const event = { 
-				request, 
-				respondWith: (response) => { responseReceived = response; }
-			};
-			
-			// Helper for error responses
-			const createErrorResponse = (err) => {
-				const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
-				if (isDev) {
-					const escapeHtml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-					return new Response(\`<!DOCTYPE html>
-<html>
-<head>
-  <title>500 Internal Server Error</title>
-  <style>
-    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-    h1 { color: #c00; }
-    .message { font-size: 1.2em; color: #333; }
-    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }
-  </style>
-</head>
-<body>
-  <h1>500 Internal Server Error</h1>
-  <p class="message">\${escapeHtml(err.message)}</p>
-  <pre>\${escapeHtml(err.stack || "No stack trace available")}</pre>
-</body>
-</html>\`, { status: 500, headers: { "Content-Type": "text/html; charset=utf-8" } });
-				} else {
-					return new Response("Internal Server Error", { status: 500, headers: { "Content-Type": "text/plain" } });
-				}
-			};
-
-			// Dispatch to ServiceWorker fetch handlers
-			for (const handler of fetchHandlers) {
-				try {
-					await handler(event);
-					if (responseReceived) {
-						return responseReceived;
-					}
-				} catch (error) {
-					console.error("Handler error:", error);
-					return createErrorResponse(error);
-				}
-			}
-
-			return new Response('No ServiceWorker handler', { status: 404 });
-		} catch (topLevelError) {
-			console.error("Top-level error:", topLevelError);
-			const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
-			if (isDev) {
-				const escapeHtml = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-				return new Response(\`<!DOCTYPE html>
-<html>
-<head>
-  <title>500 Internal Server Error</title>
-  <style>
-    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-    h1 { color: #c00; }
-    .message { font-size: 1.2em; color: #333; }
-    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }
-  </style>
-</head>
-<body>
-  <h1>500 Internal Server Error</h1>
-  <p class="message">\${escapeHtml(topLevelError.message)}</p>
-  <pre>\${escapeHtml(topLevelError.stack || "No stack trace available")}</pre>
-</body>
-</html>\`, { status: 500, headers: { "Content-Type": "text/html; charset=utf-8" } });
-			} else {
-				return new Response("Internal Server Error", { status: 500, headers: { "Content-Type": "text/plain" } });
-			}
-		}
-	}
-};`;
 var src_default = CloudflarePlatform;
 export {
   CloudflarePlatform,
-  cloudflareWorkerBanner,
-  cloudflareWorkerFooter,
-  createOptionsFromEnv,
-  src_default as default,
-  generateWranglerConfig
+  src_default as default
 };

package/src/runtime.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Cloudflare Worker Runtime
+ *
+ * This module provides runtime initialization for Cloudflare Workers.
+ * It is imported by the entry wrapper, not by user code.
+ */
+import { ShovelServiceWorkerRegistration, ShovelFetchEvent, type ShovelFetchEventInit, type ShovelConfig } from "@b9g/platform/runtime";
+export type { ShovelConfig };
+/**
+ * Cloudflare's ExecutionContext - passed to each request handler
+ */
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/**
+ * Options for CloudflareFetchEvent constructor
+ */
+export interface CloudflareFetchEventInit extends ShovelFetchEventInit {
+    /** Cloudflare environment bindings (KV, R2, D1, etc.) */
+    env: Record<string, unknown>;
+}
+/**
+ * Cloudflare-specific FetchEvent with env bindings.
+ *
+ * Extends ShovelFetchEvent to add the `env` property for accessing
+ * Cloudflare bindings (KV namespaces, R2 buckets, D1 databases, etc.)
+ */
+export declare class CloudflareFetchEvent extends ShovelFetchEvent {
+    /** Cloudflare environment bindings (KV, R2, D1, Durable Objects, etc.) */
+    readonly env: Record<string, unknown>;
+    constructor(request: Request, options: CloudflareFetchEventInit);
+}
+/**
+ * Initialize the Cloudflare runtime with ServiceWorkerGlobals
+ *
+ * @param config - Shovel configuration from shovel:config virtual module
+ * @returns The ServiceWorker registration for handling requests
+ */
+export declare function initializeRuntime(config: ShovelConfig): Promise<ShovelServiceWorkerRegistration>;
+/**
+ * Create the ES module fetch handler for Cloudflare Workers
+ *
+ * Creates a CloudflareFetchEvent with env bindings and waitUntil hook,
+ * then delegates to registration.handleEvent()
+ */
+export declare function createFetchHandler(registration: ShovelServiceWorkerRegistration): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;

package/src/runtime.js

@@ -0,0 +1,65 @@
+/// <reference types="./runtime.d.ts" />
+// src/runtime.ts
+import {
+  ServiceWorkerGlobals,
+  ShovelServiceWorkerRegistration,
+  ShovelFetchEvent,
+  CustomLoggerStorage,
+  configureLogging,
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
+import { CustomCacheStorage } from "@b9g/cache";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { getLogger } from "@logtape/logtape";
+import { envStorage } from "./variables.js";
+var CloudflareFetchEvent = class extends ShovelFetchEvent {
+  /** Cloudflare environment bindings (KV, R2, D1, Durable Objects, etc.) */
+  env;
+  constructor(request, options) {
+    super(request, options);
+    this.env = options.env;
+  }
+};
+var _registration = null;
+var _globals = null;
+async function initializeRuntime(config) {
+  if (_registration) {
+    return _registration;
+  }
+  if (config.logging) {
+    await configureLogging(config.logging);
+  }
+  _registration = new ShovelServiceWorkerRegistration();
+  const caches = new CustomCacheStorage(
+    createCacheFactory({ configs: config.caches ?? {} })
+  );
+  const directories = new CustomDirectoryStorage(
+    createDirectoryFactory(config.directories ?? {})
+  );
+  _globals = new ServiceWorkerGlobals({
+    registration: _registration,
+    caches,
+    directories,
+    loggers: new CustomLoggerStorage((cats) => getLogger(cats))
+  });
+  _globals.install();
+  return _registration;
+}
+function createFetchHandler(registration) {
+  return async (request, env, ctx) => {
+    const event = new CloudflareFetchEvent(request, {
+      env,
+      platformWaitUntil: (promise) => ctx.waitUntil(promise)
+    });
+    return envStorage.run(
+      env,
+      () => registration.handleRequest(event)
+    );
+  };
+}
+export {
+  CloudflareFetchEvent,
+  createFetchHandler,
+  initializeRuntime
+};

package/src/variables.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cloudflare Environment Storage
+ *
+ * Provides per-request access to Cloudflare's env object (KV, R2, D1 bindings, etc.)
+ * via AsyncContext. Used by directory implementations to resolve bindings at runtime.
+ */
+/**
+ * Per-request storage for Cloudflare's env object.
+ * Set by createFetchHandler() via envStorage.run().
+ */
+export declare const envStorage: any;
+/**
+ * Get the current Cloudflare env or throw if not in request context.
+ */
+export declare function getEnv(): Record<string, unknown>;

package/src/variables.js

@@ -0,0 +1,17 @@
+/// <reference types="./variables.d.ts" />
+// src/variables.ts
+import { AsyncContext } from "@b9g/async-context";
+var envStorage = new AsyncContext.Variable();
+function getEnv() {
+  const env = envStorage.get();
+  if (!env) {
+    throw new Error(
+      "Cloudflare env not available. Are you accessing bindings outside of a request context?"
+    );
+  }
+  return env;
+}
+export {
+  envStorage,
+  getEnv
+};

package/src/filesystem-assets.d.ts

@@ -1,55 +0,0 @@
-/**
- * CFAssetsDirectoryHandle - FileSystemDirectoryHandle over CF ASSETS binding
- *
- * Wraps Cloudflare's Workers Static Assets binding to provide the standard
- * File System Access API interface, enabling shovel's `self.dirs.open("dist")`
- * to work seamlessly with bundled static assets.
- *
- * @example
- * ```ts
- * // In production CF Worker
- * const dist = new CFAssetsDirectoryHandle(env.ASSETS, "/assets");
- * const file = await dist.getFileHandle("style.abc123.css");
- * const content = await (await file.getFile()).text();
- * ```
- */
-/**
- * Cloudflare ASSETS binding interface
- */
-export interface CFAssetsBinding {
-    fetch(request: Request | string): Promise<Response>;
-}
-/**
- * FileSystemDirectoryHandle implementation over Cloudflare ASSETS binding.
- *
- * Provides read-only access to static assets deployed with a CF Worker.
- * Directory listing is not supported (ASSETS binding limitation).
- */
-export declare class CFAssetsDirectoryHandle implements FileSystemDirectoryHandle {
-    #private;
-    readonly kind: "directory";
-    readonly name: string;
-    constructor(assets: CFAssetsBinding, basePath?: string);
-    getFileHandle(name: string, _options?: FileSystemGetFileOptions): Promise<FileSystemFileHandle>;
-    getDirectoryHandle(name: string, _options?: FileSystemGetDirectoryOptions): Promise<FileSystemDirectoryHandle>;
-    removeEntry(_name: string, _options?: FileSystemRemoveOptions): Promise<void>;
-    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
-    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
-    keys(): AsyncIterableIterator<string>;
-    values(): AsyncIterableIterator<FileSystemHandle>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileSystemHandle]>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-}
-/**
- * FileSystemFileHandle implementation for CF ASSETS binding files.
- */
-export declare class CFAssetsFileHandle implements FileSystemFileHandle {
-    #private;
-    readonly kind: "file";
-    readonly name: string;
-    constructor(assets: CFAssetsBinding, path: string, name: string);
-    getFile(): Promise<File>;
-    createWritable(_options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
-    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-}