@b9g/platform 0.1.12 → 0.1.14-beta.0

package/src/index.js

@@ -1,21 +1,13 @@
 /// <reference types="./index.d.ts" />
-import {
-  __require
-} from "../chunk-P57PW2II.js";
-
 // src/index.ts
-import * as Path from "path";
-import { existsSync } from "fs";
-import { fileURLToPath } from "url";
-import { CustomCacheStorage } from "@b9g/cache";
-import { MemoryCache } from "@b9g/cache/memory";
 import { getLogger } from "@logtape/logtape";
+import { CustomLoggerStorage } from "./runtime.js";
+import { validateConfig, ConfigValidationError } from "./config.js";
 import {
-  ServiceWorkerGlobals,
-  ShovelServiceWorkerRegistration,
-  CustomLoggerStorage
+  CustomDatabaseStorage,
+  createDatabaseFactory
 } from "./runtime.js";
-var logger = getLogger(["platform"]);
+var logger = getLogger(["shovel", "platform"]);
 function detectRuntime() {
   if (typeof Bun !== "undefined" || process.versions?.bun) {
     return "bun";
@@ -66,27 +58,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`
       );
   }
 }
@@ -96,15 +81,21 @@ var BasePlatform = class {
     this.config = config;
   }
   /**
-   * Create cache storage
-   * Returns empty CacheStorage - applications create caches on-demand via caches.open()
+   * Dispose of platform resources
+   * Subclasses should override to clean up worker pools, connections, etc.
    */
-  async createCaches() {
-    return new CustomCacheStorage(
-      (name) => new MemoryCache(name)
-    );
+  async dispose() {
   }
 };
+function mergeConfigWithDefaults(defaults, userConfig) {
+  const user = userConfig ?? {};
+  const allNames = /* @__PURE__ */ new Set([...Object.keys(defaults), ...Object.keys(user)]);
+  const merged = {};
+  for (const name of allNames) {
+    merged[name] = { ...defaults[name], ...user[name] };
+  }
+  return merged;
+}
 var DefaultPlatformRegistry = class {
   #platforms;
   constructor() {
@@ -161,124 +152,6 @@ 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,
-      loggers: options.loggers
-    });
-    logger.info("SingleThreadedRuntime created");
-  }
-  /**
-   * Initialize the runtime (install ServiceWorker globals)
-   */
-  async init() {
-    this.#scope.install();
-    logger.info("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.info("Reloading ServiceWorker", {
-        oldEntrypoint: this.#entrypoint,
-        newEntrypoint: entrypoint
-      });
-      this.#registration._serviceWorker._setState("parsed");
-    } else {
-      logger.info("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.info("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"
-      );
-    }
-    return this.#registration.handleRequest(request);
-  }
-  /**
-   * Graceful shutdown
-   */
-  async terminate() {
-    this.#ready = false;
-    logger.info("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;
-  }
-};
-function resolveWorkerScript(entrypoint) {
-  if (entrypoint) {
-    const entryDir = Path.dirname(entrypoint);
-    const bundledWorker = Path.join(entryDir, "worker.js");
-    try {
-      if (typeof Bun !== "undefined") {
-        const file = Bun.file(bundledWorker);
-        if (file.size > 0) {
-          logger.info("Using bundled worker", { bundledWorker });
-          return bundledWorker;
-        }
-      } else if (typeof __require !== "undefined") {
-        if (existsSync(bundledWorker)) {
-          logger.info("Using bundled worker", { bundledWorker });
-          return bundledWorker;
-        }
-      }
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  try {
-    const workerURL = import.meta.resolve("@b9g/platform/worker.js");
-    let workerScript;
-    if (workerURL.startsWith("file://")) {
-      workerScript = fileURLToPath(workerURL);
-    } else {
-      workerScript = workerURL;
-    }
-    logger.info("Using worker entry script", { workerScript });
-    return workerScript;
-  } catch (error) {
-    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "worker.js") : "worker.js";
-    throw new Error(
-      `Could not resolve worker.js. Checked bundled path: ${bundledPath} and package: @b9g/platform/worker.js. Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
 async function createWebWorker(workerScript) {
   if (typeof Worker !== "undefined") {
     return new Worker(workerScript, { type: "module" });
@@ -327,22 +200,21 @@ var ServiceWorkerPool = class {
   #currentWorker;
   #requestID;
   #pendingRequests;
-  #pendingWorkerInit;
+  #pendingWorkerReady;
   #options;
   #appEntrypoint;
   #cacheStorage;
-  // CustomCacheStorage for cache coordination
-  #config;
-  // ShovelConfig from config.ts
-  constructor(options = {}, appEntrypoint, cacheStorage, config) {
+  // 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.#pendingWorkerInit = /* @__PURE__ */ new Map();
+    this.#pendingWorkerReady = /* @__PURE__ */ new Map();
+    this.#workerAvailableWaiters = [];
     this.#appEntrypoint = appEntrypoint;
     this.#cacheStorage = cacheStorage;
-    this.#config = config || {};
     this.#options = {
       workerCount: 1,
       requestTimeout: 3e4,
@@ -353,27 +225,35 @@ var ServiceWorkerPool = class {
    * Initialize workers (must be called after construction)
    */
   async init() {
-    await this.#initWorkers();
-  }
-  async #initWorkers() {
+    const promises = [];
     for (let i = 0; i < this.#options.workerCount; i++) {
-      await this.#createWorker();
+      promises.push(this.#createWorker(this.#appEntrypoint));
     }
+    await Promise.all(promises);
   }
-  async #createWorker() {
-    const workerScript = resolveWorkerScript(this.#appEntrypoint);
-    const worker = await createWebWorker(workerScript);
-    let rejectWorkerReady;
-    let workerReadyTimeoutId;
-    const workerReadyPromise = new Promise((resolve, reject) => {
-      rejectWorkerReady = reject;
-      workerReadyTimeoutId = setTimeout(() => {
-        reject(new Error("Worker failed to send ready signal within 30000ms"));
+  /**
+   * Create a worker from the unified bundle
+   * The bundle self-initializes and sends "ready" when done
+   */
+  async #createWorker(entrypoint) {
+    const worker = this.#options.createWorker ? await this.#options.createWorker(entrypoint) : 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.#pendingWorkerInit.set(worker, {
-        workerReady: () => {
-          clearTimeout(workerReadyTimeoutId);
+      this.#pendingWorkerReady.set(worker, {
+        resolve: () => {
+          clearTimeout(timeoutId);
           resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
         }
       });
     });
@@ -382,74 +262,49 @@ var ServiceWorkerPool = class {
     });
     worker.addEventListener("error", (event) => {
       const errorMessage = event.message || event.error?.message || "Unknown worker error";
-      const error = new Error(`Worker failed to start: ${errorMessage}`);
+      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
       });
-      clearTimeout(workerReadyTimeoutId);
-      rejectWorkerReady(error);
+      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.info("Waiting for worker-ready signal");
-    await workerReadyPromise;
-    logger.info("Received worker-ready signal");
-    const initializedPromise = new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(
-          new Error("Worker failed to send initialized signal within 30000ms")
-        );
-      }, 3e4);
-      const pending = this.#pendingWorkerInit.get(worker) || {};
-      pending.initialized = () => {
-        clearTimeout(timeoutId);
-        resolve();
-      };
-      this.#pendingWorkerInit.set(worker, pending);
-    });
-    if (!this.#appEntrypoint) {
-      throw new Error(
-        "ServiceWorkerPool requires an entrypoint to derive baseDir"
-      );
+    logger.debug("Worker ready", { entrypoint });
+    const waiters = this.#workerAvailableWaiters;
+    this.#workerAvailableWaiters = [];
+    for (const waiter of waiters) {
+      waiter.resolve();
     }
-    const baseDir = Path.dirname(this.#appEntrypoint);
-    const initMessage = {
-      type: "init",
-      config: this.#config,
-      baseDir
-    };
-    logger.info("Sending init message", { config: this.#config, baseDir });
-    worker.postMessage(initMessage);
-    logger.info("Sent init message, waiting for initialized response");
-    await initializedPromise;
-    logger.info("Received initialized response");
-    this.#pendingWorkerInit.delete(worker);
     return worker;
   }
   #handleWorkerMessage(worker, message) {
     logger.debug("Worker message received", { type: message.type });
-    const pending = this.#pendingWorkerInit.get(worker);
-    if (message.type === "worker-ready" && pending?.workerReady) {
-      pending.workerReady();
-    } else if (message.type === "initialized" && pending?.initialized) {
-      pending.initialized();
-      return;
-    }
     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;
-      case "ready":
-      case "worker-ready":
-        this.#handleReady(message);
-        break;
-      case "initialized":
-        break;
       default:
         if (message.type?.startsWith("cache:")) {
           logger.debug("Cache message received", { type: message.type });
@@ -497,23 +352,38 @@ var ServiceWorkerPool = class {
         pending.reject(new Error(message.error));
         this.#pendingRequests.delete(message.requestID);
       }
-    } else {
-      logger.error("Worker error: {error}", { error: message.error });
-    }
-  }
-  #handleReady(message) {
-    if (message.type === "ready") {
-      logger.info("ServiceWorker ready", { entrypoint: message.entrypoint });
-    } else if (message.type === "worker-ready") {
-      logger.info("Worker initialized", {});
     }
   }
   /**
    * 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.info("Dispatching to worker", {
+    logger.debug("Dispatching to worker", {
       workerIndex: this.#currentWorker + 1,
       totalWorkers: this.#workers.length
     });
@@ -530,9 +400,6 @@ var ServiceWorkerPool = class {
       this.#sendRequest(worker, request, requestID).catch(reject);
     });
   }
-  /**
-   * Send request to worker (async helper to avoid async promise executor)
-   */
   async #sendRequest(worker, request, requestID) {
     let body = null;
     if (request.body) {
@@ -555,75 +422,89 @@ var ServiceWorkerPool = class {
     }
   }
   /**
-   * Reload ServiceWorker with new entrypoint (hot reload)
-   * The entrypoint path contains a content hash for cache busting
+   * Gracefully shutdown a worker by closing all resources first
    */
-  async reloadWorkers(entrypoint) {
-    logger.info("Reloading ServiceWorker", { entrypoint });
-    this.#appEntrypoint = entrypoint;
-    const loadPromises = this.#workers.map((worker) => {
-      return new Promise((resolve, reject) => {
-        let timeoutId;
-        const cleanup = () => {
-          worker.removeEventListener("message", handleReady);
-          worker.removeEventListener("error", handleError);
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-          }
-        };
-        const handleReady = (event) => {
-          const message = event.data || event;
-          if (message.type === "ready" && message.entrypoint === entrypoint) {
-            cleanup();
+  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();
-          } else if (message.type === "error") {
-            cleanup();
-            reject(
-              new Error(
-                `Worker failed to load ServiceWorker: ${message.error}`
-              )
-            );
           }
-        };
-        const handleError = (error) => {
-          cleanup();
-          const errorMsg = error?.error?.message || error?.message || JSON.stringify(error);
-          reject(new Error(`Worker failed to load ServiceWorker: ${errorMsg}`));
-        };
-        timeoutId = setTimeout(() => {
-          cleanup();
-          reject(
-            new Error(
-              `Worker failed to load ServiceWorker within 30000ms (entrypoint ${entrypoint})`
-            )
-          );
-        }, 3e4);
-        logger.info("Sending load message", {
-          entrypoint
-        });
-        worker.addEventListener("message", handleReady);
-        worker.addEventListener("error", handleError);
-        const loadMessage = {
-          type: "load",
-          entrypoint
-        };
-        logger.debug("[WorkerPool] Sending load message", {
-          entrypoint
-        });
-        worker.postMessage(loadMessage);
-      });
+        }
+      };
+      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);
     });
-    await Promise.all(loadPromises);
-    logger.info("All workers reloaded", { entrypoint });
+  }
+  /**
+   * 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
@@ -640,15 +521,19 @@ var ServiceWorkerPool = class {
 };
 export {
   BasePlatform,
+  ConfigValidationError,
+  CustomDatabaseStorage,
   CustomLoggerStorage,
   ServiceWorkerPool,
-  SingleThreadedRuntime,
+  createDatabaseFactory,
   createPlatform,
   detectDeploymentPlatform,
   detectDevelopmentPlatform,
   detectRuntime,
   getPlatform,
   getPlatformAsync,
+  mergeConfigWithDefaults,
   platformRegistry,
-  resolvePlatform
+  resolvePlatform,
+  validateConfig
 };