@b9g/platform 0.1.11 → 0.1.13

package/src/index.js

@@ -1,43 +1,18 @@
 /// <reference types="./index.d.ts" />
-import "../chunk-P57PW2II.js";
-
 // src/index.ts
-import * as Path from "path";
-import { readFileSync } from "fs";
-import { CustomCacheStorage } from "@b9g/cache";
-import { MemoryCache } from "@b9g/cache/memory";
-import {
-  ServiceWorkerPool
-} from "./worker-pool.js";
+import { getLogger } from "@logtape/logtape";
 import {
-  SingleThreadedRuntime
-} from "./single-threaded.js";
-import {
-  ShovelServiceWorkerRegistration,
   ServiceWorkerGlobals,
-  FetchEvent,
-  InstallEvent,
-  ActivateEvent,
-  ExtendableEvent
+  ShovelServiceWorkerRegistration,
+  ShovelFetchEvent,
+  CustomLoggerStorage
 } from "./runtime.js";
+import { validateConfig, ConfigValidationError } from "./config.js";
 import {
-  RequestCookieStore,
-  parseCookieHeader,
-  serializeCookie,
-  parseSetCookieHeader
-} from "./cookie-store.js";
-import { CustomBucketStorage } from "@b9g/filesystem";
-import {
-  loadConfig,
-  configureLogging,
-  getCacheConfig,
-  getBucketConfig,
-  parseConfigExpr,
-  processConfigValue,
-  matchPattern,
-  createBucketFactory,
-  createCacheFactory
-} from "./config.js";
+  CustomDatabaseStorage,
+  createDatabaseFactory
+} from "./runtime.js";
+var logger = getLogger(["shovel", "platform"]);
 function detectRuntime() {
   if (typeof Bun !== "undefined" || process.versions?.bun) {
     return "bun";
@@ -47,53 +22,6 @@ function detectRuntime() {
   }
   return "node";
 }
-function detectPlatformFromPackageJSON(cwd) {
-  if (!cwd && typeof process === "undefined") {
-    return null;
-  }
-  try {
-    const pkgPath = Path.join(cwd || process.cwd(), "package.json");
-    const pkgContent = readFileSync(pkgPath, "utf8");
-    const pkg = JSON.parse(pkgContent);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    return selectPlatformFromDeps(deps);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-    return null;
-  }
-}
-function selectPlatformFromDeps(deps) {
-  const hasBun = deps["@b9g/platform-bun"];
-  const hasNode = deps["@b9g/platform-node"];
-  const hasCloudflare = deps["@b9g/platform-cloudflare"];
-  const installedCount = [hasBun, hasNode, hasCloudflare].filter(
-    Boolean
-  ).length;
-  if (installedCount === 0)
-    return null;
-  if (installedCount === 1) {
-    if (hasBun)
-      return "bun";
-    if (hasNode)
-      return "node";
-    if (hasCloudflare)
-      return "cloudflare";
-  }
-  const runtime = detectRuntime();
-  if (runtime === "bun" && hasBun)
-    return "bun";
-  if (runtime === "node" && hasNode)
-    return "node";
-  if (hasBun)
-    return "bun";
-  if (hasNode)
-    return "node";
-  if (hasCloudflare)
-    return "cloudflare";
-  return null;
-}
 function detectDeploymentPlatform() {
   if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
     return null;
@@ -105,10 +33,6 @@ function detectDeploymentPlatform() {
   return null;
 }
 function detectDevelopmentPlatform() {
-  const pkgPlatform = detectPlatformFromPackageJSON();
-  if (pkgPlatform) {
-    return pkgPlatform;
-  }
   const runtime = detectRuntime();
   switch (runtime) {
     case "bun":
@@ -139,27 +63,20 @@ function resolvePlatform(options) {
 async function createPlatform(platformName, options = {}) {
   switch (platformName) {
     case "node": {
-      const modulePath = import.meta.resolve("@b9g/platform-node");
-      const NodePlatform = await import(modulePath).then((m) => m.default);
+      const { default: NodePlatform } = await import("@b9g/platform-node");
       return new NodePlatform(options);
     }
     case "bun": {
-      const modulePath = import.meta.resolve("@b9g/platform-bun");
-      const BunPlatform = await import(modulePath).then((m) => m.default);
+      const { default: BunPlatform } = await import("@b9g/platform-bun");
       return new BunPlatform(options);
     }
-    case "cloudflare":
-    case "cloudflare-workers":
-    case "cf": {
-      const modulePath = import.meta.resolve("@b9g/platform-cloudflare");
-      const CloudflarePlatform = await import(modulePath).then(
-        (m) => m.default
-      );
+    case "cloudflare": {
+      const { default: CloudflarePlatform } = await import("@b9g/platform-cloudflare");
       return new CloudflarePlatform(options);
     }
     default:
       throw new Error(
-        `Unknown platform: ${platformName}. Available platforms: node, bun, cloudflare`
+        `Unknown platform: ${platformName}. Valid platforms: node, bun, cloudflare`
       );
   }
 }
@@ -168,15 +85,6 @@ var BasePlatform = class {
   constructor(config = {}) {
     this.config = config;
   }
-  /**
-   * Create cache storage
-   * Returns empty CacheStorage - applications create caches on-demand via caches.open()
-   */
-  async createCaches() {
-    return new CustomCacheStorage(
-      (name) => new MemoryCache(name)
-    );
-  }
 };
 var DefaultPlatformRegistry = class {
   #platforms;
@@ -234,36 +142,468 @@ async function getPlatformAsync(name) {
   }
   return platform;
 }
+var SingleThreadedRuntime = class {
+  #registration;
+  #scope;
+  #ready;
+  #entrypoint;
+  constructor(options) {
+    this.#ready = false;
+    this.#registration = new ShovelServiceWorkerRegistration();
+    this.#scope = new ServiceWorkerGlobals({
+      registration: this.#registration,
+      caches: options.caches,
+      directories: options.directories,
+      databases: options.databases,
+      loggers: options.loggers
+    });
+    logger.debug("SingleThreadedRuntime created");
+  }
+  /**
+   * Initialize the runtime (install ServiceWorker globals)
+   */
+  async init() {
+    this.#scope.install();
+    logger.debug("SingleThreadedRuntime initialized - globals installed");
+  }
+  /**
+   * Load (or reload) a ServiceWorker entrypoint
+   * @param entrypoint - Path to the entrypoint file (content-hashed filename)
+   */
+  async load(entrypoint) {
+    const isReload = this.#entrypoint !== void 0;
+    if (isReload) {
+      logger.debug("Reloading ServiceWorker", {
+        oldEntrypoint: this.#entrypoint,
+        newEntrypoint: entrypoint
+      });
+      this.#registration._serviceWorker._setState("parsed");
+    } else {
+      logger.debug("Loading ServiceWorker entrypoint", { entrypoint });
+    }
+    this.#entrypoint = entrypoint;
+    this.#ready = false;
+    await import(entrypoint);
+    await this.#registration.install();
+    await this.#registration.activate();
+    this.#ready = true;
+    logger.debug("ServiceWorker loaded and activated", { entrypoint });
+  }
+  /**
+   * Handle an HTTP request
+   * This is the key method - direct call, no postMessage!
+   */
+  async handleRequest(request) {
+    if (!this.#ready) {
+      throw new Error(
+        "SingleThreadedRuntime not ready - ServiceWorker not loaded"
+      );
+    }
+    const event = new ShovelFetchEvent(request);
+    return this.#registration.handleRequest(event);
+  }
+  /**
+   * Graceful shutdown
+   */
+  async terminate() {
+    this.#ready = false;
+    logger.debug("SingleThreadedRuntime terminated");
+  }
+  /**
+   * Get the number of workers (always 1 for single-threaded)
+   */
+  get workerCount() {
+    return 1;
+  }
+  /**
+   * Check if ready to handle requests
+   */
+  get ready() {
+    return this.#ready;
+  }
+};
+async function createWebWorker(workerScript) {
+  if (typeof Worker !== "undefined") {
+    return new Worker(workerScript, { type: "module" });
+  }
+  const isNodeJs = typeof process !== "undefined" && process.versions?.node;
+  if (isNodeJs) {
+    try {
+      const { Worker: NodeWebWorker } = await import("@b9g/node-webworker");
+      logger.info("Using @b9g/node-webworker shim for Node.js", {});
+      return new NodeWebWorker(workerScript, {
+        type: "module"
+      });
+    } catch (shimError) {
+      logger.error(
+        "MISSING WEB STANDARD: Node.js lacks native Web Worker support",
+        {
+          canonicalIssue: "https://github.com/nodejs/node/issues/43583",
+          message: "This is a basic web standard from 2009 - help push for implementation!"
+        }
+      );
+      throw new Error(`\u274C Web Worker not available on Node.js
+
+\u{1F517} Node.js doesn't implement the Web Worker standard yet.
+   CANONICAL ISSUE: https://github.com/nodejs/node/issues/43583
+
+\u{1F5F3}\uFE0F  Please \u{1F44D} react and comment to show demand for this basic web standard!
+
+\u{1F4A1} Immediate workaround:
+   npm install @b9g/node-webworker
+
+   This installs our minimal, reliable Web Worker shim for Node.js.
+
+\u{1F4DA} Learn more: https://developer.mozilla.org/en-US/docs/Web/API/Worker`);
+    }
+  }
+  const runtime = typeof Bun !== "undefined" ? "Bun" : typeof Deno !== "undefined" ? "Deno" : "Unknown";
+  throw new Error(`\u274C Web Worker not available on ${runtime}
+
+This runtime should support Web Workers but the API is not available.
+Please check your runtime version and configuration.
+
+\u{1F4DA} Web Worker standard: https://developer.mozilla.org/en-US/docs/Web/API/Worker`);
+}
+var ServiceWorkerPool = class {
+  #workers;
+  #currentWorker;
+  #requestID;
+  #pendingRequests;
+  #pendingWorkerReady;
+  #options;
+  #appEntrypoint;
+  #cacheStorage;
+  // Waiters for when workers become available (used during reload)
+  #workerAvailableWaiters;
+  constructor(options = {}, appEntrypoint, cacheStorage) {
+    this.#workers = [];
+    this.#currentWorker = 0;
+    this.#requestID = 0;
+    this.#pendingRequests = /* @__PURE__ */ new Map();
+    this.#pendingWorkerReady = /* @__PURE__ */ new Map();
+    this.#workerAvailableWaiters = [];
+    this.#appEntrypoint = appEntrypoint;
+    this.#cacheStorage = cacheStorage;
+    this.#options = {
+      workerCount: 1,
+      requestTimeout: 3e4,
+      ...options
+    };
+  }
+  /**
+   * Initialize workers (must be called after construction)
+   */
+  async init() {
+    const promises = [];
+    for (let i = 0; i < this.#options.workerCount; i++) {
+      promises.push(this.#createWorker(this.#appEntrypoint));
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Create a worker from the unified bundle
+   * The bundle self-initializes and sends "ready" when done
+   */
+  async #createWorker(entrypoint) {
+    const worker = await createWebWorker(entrypoint);
+    const readyPromise = new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.#pendingWorkerReady.delete(worker);
+        reject(
+          new Error(
+            `Worker failed to become ready within 30000ms (${entrypoint})`
+          )
+        );
+      }, 3e4);
+      this.#pendingWorkerReady.set(worker, {
+        resolve: () => {
+          clearTimeout(timeoutId);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      });
+    });
+    worker.addEventListener("message", (event) => {
+      this.#handleWorkerMessage(worker, event.data || event);
+    });
+    worker.addEventListener("error", (event) => {
+      const errorMessage = event.message || event.error?.message || "Unknown worker error";
+      const error = new Error(`Worker error: ${errorMessage}`);
+      logger.error("Worker error: {error}", {
+        error: event.error || errorMessage,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno
+      });
+      const pending = this.#pendingWorkerReady.get(worker);
+      if (pending) {
+        this.#pendingWorkerReady.delete(worker);
+        pending.reject(error);
+      }
+    });
+    logger.debug("Waiting for worker ready signal", { entrypoint });
+    await readyPromise;
+    this.#pendingWorkerReady.delete(worker);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    this.#workers.push(worker);
+    logger.debug("Worker ready", { entrypoint });
+    const waiters = this.#workerAvailableWaiters;
+    this.#workerAvailableWaiters = [];
+    for (const waiter of waiters) {
+      waiter.resolve();
+    }
+    return worker;
+  }
+  #handleWorkerMessage(worker, message) {
+    logger.debug("Worker message received", { type: message.type });
+    switch (message.type) {
+      case "ready": {
+        const pending = this.#pendingWorkerReady.get(worker);
+        if (pending) {
+          pending.resolve();
+        }
+        logger.debug("ServiceWorker ready");
+        break;
+      }
+      case "response":
+        this.#handleResponse(message);
+        break;
+      case "error":
+        this.#handleError(message);
+        break;
+      default:
+        if (message.type?.startsWith("cache:")) {
+          logger.debug("Cache message received", { type: message.type });
+          if (this.#cacheStorage) {
+            const storage = this.#cacheStorage;
+            if (typeof storage.handleMessage === "function") {
+              storage.handleMessage(worker, message).catch((err) => {
+                logger.error("Cache message handling failed: {error}", {
+                  error: err
+                });
+              });
+            }
+          }
+        }
+        break;
+    }
+  }
+  #handleResponse(message) {
+    const pending = this.#pendingRequests.get(message.requestID);
+    if (pending) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      const response = new Response(message.response.body, {
+        status: message.response.status,
+        statusText: message.response.statusText,
+        headers: message.response.headers
+      });
+      pending.resolve(response);
+      this.#pendingRequests.delete(message.requestID);
+    }
+  }
+  #handleError(message) {
+    logger.error("Worker error message received: {error}", {
+      error: message.error,
+      stack: message.stack,
+      requestID: message.requestID
+    });
+    if (message.requestID) {
+      const pending = this.#pendingRequests.get(message.requestID);
+      if (pending) {
+        if (pending.timeoutId) {
+          clearTimeout(pending.timeoutId);
+        }
+        pending.reject(new Error(message.error));
+        this.#pendingRequests.delete(message.requestID);
+      }
+    }
+  }
+  /**
+   * Handle HTTP request using round-robin worker selection
+   */
+  async handleRequest(request) {
+    if (this.#workers.length === 0) {
+      logger.debug("No workers available, waiting for worker to be ready");
+      await new Promise((resolve, reject) => {
+        const waiter = { resolve, reject };
+        this.#workerAvailableWaiters.push(waiter);
+        const timeoutId = setTimeout(() => {
+          const index = this.#workerAvailableWaiters.indexOf(waiter);
+          if (index !== -1) {
+            this.#workerAvailableWaiters.splice(index, 1);
+            reject(new Error("Timeout waiting for worker to become available"));
+          }
+        }, this.#options.requestTimeout);
+        const originalResolve = waiter.resolve;
+        const originalReject = waiter.reject;
+        waiter.resolve = () => {
+          clearTimeout(timeoutId);
+          originalResolve();
+        };
+        waiter.reject = (error) => {
+          clearTimeout(timeoutId);
+          originalReject(error);
+        };
+      });
+    }
+    const worker = this.#workers[this.#currentWorker];
+    logger.debug("Dispatching to worker", {
+      workerIndex: this.#currentWorker + 1,
+      totalWorkers: this.#workers.length
+    });
+    this.#currentWorker = (this.#currentWorker + 1) % this.#workers.length;
+    const requestID = ++this.#requestID;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (this.#pendingRequests.has(requestID)) {
+          this.#pendingRequests.delete(requestID);
+          reject(new Error("Request timeout"));
+        }
+      }, this.#options.requestTimeout);
+      this.#pendingRequests.set(requestID, { resolve, reject, timeoutId });
+      this.#sendRequest(worker, request, requestID).catch(reject);
+    });
+  }
+  async #sendRequest(worker, request, requestID) {
+    let body = null;
+    if (request.body) {
+      body = await request.arrayBuffer();
+    }
+    const workerRequest = {
+      type: "request",
+      request: {
+        url: request.url,
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        body
+      },
+      requestID
+    };
+    if (body) {
+      worker.postMessage(workerRequest, [body]);
+    } else {
+      worker.postMessage(workerRequest);
+    }
+  }
+  /**
+   * Gracefully shutdown a worker by closing all resources first
+   */
+  async #gracefulShutdown(worker, timeout = 5e3) {
+    return new Promise((resolve) => {
+      let resolved = false;
+      const onMessage = (event) => {
+        const message = event.data || event;
+        if (message?.type === "shutdown-complete") {
+          if (!resolved) {
+            resolved = true;
+            worker.removeEventListener("message", onMessage);
+            resolve();
+          }
+        }
+      };
+      worker.addEventListener("message", onMessage);
+      worker.postMessage({ type: "shutdown" });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          worker.removeEventListener("message", onMessage);
+          logger.warn("Worker shutdown timed out, forcing termination");
+          resolve();
+        }
+      }, timeout);
+    });
+  }
+  /**
+   * Reload workers with new entrypoint (hot reload)
+   *
+   * With unified builds, hot reload means:
+   * 1. Gracefully shutdown existing workers (close databases, etc.)
+   * 2. Terminate workers after resources are closed
+   * 3. Create new workers with the new bundle
+   */
+  async reloadWorkers(entrypoint) {
+    logger.debug("Reloading workers", { entrypoint });
+    this.#appEntrypoint = entrypoint;
+    const shutdownPromises = this.#workers.map(
+      (worker) => this.#gracefulShutdown(worker)
+    );
+    await Promise.allSettled(shutdownPromises);
+    const terminatePromises = this.#workers.map((worker) => worker.terminate());
+    await Promise.allSettled(terminatePromises);
+    this.#workers = [];
+    this.#currentWorker = 0;
+    try {
+      const createPromises = [];
+      for (let i = 0; i < this.#options.workerCount; i++) {
+        createPromises.push(this.#createWorker(entrypoint));
+      }
+      await Promise.all(createPromises);
+      logger.debug("All workers reloaded", { entrypoint });
+    } catch (error) {
+      const waiters = this.#workerAvailableWaiters;
+      this.#workerAvailableWaiters = [];
+      const reloadError = error instanceof Error ? error : new Error("Worker creation failed during reload");
+      for (const waiter of waiters) {
+        waiter.reject(reloadError);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Graceful shutdown of all workers
+   */
+  async terminate() {
+    const shutdownPromises = this.#workers.map(
+      (worker) => this.#gracefulShutdown(worker)
+    );
+    await Promise.allSettled(shutdownPromises);
+    const terminatePromises = this.#workers.map((worker) => worker.terminate());
+    await Promise.allSettled(terminatePromises);
+    this.#workers = [];
+    this.#currentWorker = 0;
+    this.#pendingRequests.clear();
+    this.#pendingWorkerReady.clear();
+    const waiters = this.#workerAvailableWaiters;
+    this.#workerAvailableWaiters = [];
+    const terminateError = new Error("Worker pool terminated");
+    for (const waiter of waiters) {
+      waiter.reject(terminateError);
+    }
+  }
+  /**
+   * Get the number of active workers
+   */
+  get workerCount() {
+    return this.#workers.length;
+  }
+  /**
+   * Check if the pool is ready to handle requests
+   */
+  get ready() {
+    return this.#workers.length > 0;
+  }
+};
 export {
-  ActivateEvent,
   BasePlatform,
-  CustomBucketStorage,
-  ExtendableEvent,
-  FetchEvent,
-  InstallEvent,
-  RequestCookieStore,
-  ServiceWorkerGlobals,
+  ConfigValidationError,
+  CustomDatabaseStorage,
+  CustomLoggerStorage,
   ServiceWorkerPool,
-  ShovelServiceWorkerRegistration,
   SingleThreadedRuntime,
-  configureLogging,
-  createBucketFactory,
-  createCacheFactory,
+  createDatabaseFactory,
   createPlatform,
   detectDeploymentPlatform,
   detectDevelopmentPlatform,
   detectRuntime,
-  getBucketConfig,
-  getCacheConfig,
   getPlatform,
   getPlatformAsync,
-  loadConfig,
-  matchPattern,
-  parseConfigExpr,
-  parseCookieHeader,
-  parseSetCookieHeader,
   platformRegistry,
-  processConfigValue,
   resolvePlatform,
-  serializeCookie
+  validateConfig
 };