@b9g/platform-bun 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,15 +12,14 @@
     "jsx"
   ],
   "dependencies": {
-    "@b9g/assets": "^0.1.14",
-    "@b9g/cache": "^0.1.4",
-    "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.10",
+    "@b9g/assets": "^0.2.0-beta.0",
+    "@b9g/cache": "^0.2.0-beta.0",
+    "@b9g/http-errors": "^0.2.0-beta.0",
+    "@b9g/platform": "^0.1.13",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.18",
-    "bun-types": "latest"
+    "@b9g/libuild": "^0.1.18"
   },
   "type": "module",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -3,9 +3,10 @@
  *
  * Provides built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-import { BasePlatform, PlatformConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, ServiceWorkerPool } from "@b9g/platform";
+import { BasePlatform, type PlatformConfig, type PlatformDefaults, type Handler, type Server, type ServerOptions, type ServiceWorkerOptions, type ServiceWorkerInstance, type EntryWrapperOptions, type PlatformESBuildConfig, ServiceWorkerPool, CustomLoggerStorage, CustomDatabaseStorage } from "@b9g/platform";
+import { type ShovelConfig } from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
-export type { Platform, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, } from "@b9g/platform";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
 export interface BunPlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -13,6 +14,10 @@ export interface BunPlatformOptions extends PlatformConfig {
     host?: string;
     /** Working directory for file resolution */
     cwd?: string;
+    /** Number of worker threads (default: 1) */
+    workers?: number;
+    /** Shovel configuration (caches, directories, etc.) */
+    config?: ShovelConfig;
 }
 /**
  * Bun platform implementation
@@ -25,17 +30,36 @@ export declare class BunPlatform extends BasePlatform {
     /**
      * Get options for testing
      */
-    get options(): Required<BunPlatformOptions>;
+    get options(): {
+        port: number;
+        host: string;
+        cwd: string;
+        workers: number;
+        config?: ShovelConfig;
+    };
     /**
      * Get/set worker pool for testing
      */
     get workerPool(): ServiceWorkerPool | undefined;
     set workerPool(pool: ServiceWorkerPool | undefined);
     /**
-     * Create cache storage
-     * Uses config from package.json shovel field
+     * Create cache storage using config from shovel.json
+     * Merges with runtime defaults (actual class references) for fallback behavior
      */
     createCaches(): Promise<CustomCacheStorage>;
+    /**
+     * Create directory storage using config from shovel.json
+     * Merges with runtime defaults (actual class references) for fallback behavior
+     */
+    createDirectories(): Promise<CustomDirectoryStorage>;
+    /**
+     * Create logger storage using config from shovel.json
+     */
+    createLoggers(): Promise<CustomLoggerStorage>;
+    /**
+     * Create database storage from declarative config in shovel.json
+     */
+    createDatabases(configOverride?: BunPlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
      * Create HTTP server using Bun.serve
      */
@@ -50,12 +74,48 @@ export declare class BunPlatform extends BasePlatform {
      * @param entrypoint - Path to the new entrypoint (hashed filename)
      */
     reloadWorkers(entrypoint: string): Promise<void>;
+    /**
+     * Get virtual entry wrapper for Bun
+     *
+     * @param entryPath - Absolute path to user's entrypoint file
+     * @param options - Entry wrapper options
+     * @param options.type - "production" (default) or "worker"
+     * @param options.outDir - Output directory (required for "worker" type)
+     *
+     * Returns:
+     * - "production": Server entry with Bun.serve and reusePort
+     * - "worker": Worker entry that sets up runtime and message loop
+     */
+    getEntryWrapper(entryPath: string, options?: EntryWrapperOptions): string;
+    /**
+     * Get Bun-specific esbuild configuration
+     *
+     * Note: Bun natively supports import.meta.env, so no define alias is needed.
+     * We use platform: "node" since Bun is Node-compatible for module resolution.
+     */
+    getESBuildConfig(): PlatformESBuildConfig;
+    /**
+     * Get Bun-specific defaults for config generation
+     *
+     * Provides default directories (server, public, tmp) that work
+     * out of the box for Bun deployments.
+     */
+    getDefaults(): PlatformDefaults;
     /**
      * Dispose of platform resources
      */
     dispose(): Promise<void>;
+    /**
+     * Get the OS temp directory (Bun-specific implementation using node:os)
+     */
+    tmpdir(): string;
 }
 /**
  * Default export for easy importing
  */
 export default BunPlatform;
+/**
+ * Platform's default cache implementation.
+ * Re-exported so config can reference: { module: "@b9g/platform-bun", export: "DefaultCache" }
+ */
+export { MemoryCache as DefaultCache } from "@b9g/cache/memory";

package/src/index.js

@@ -1,34 +1,174 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
 import {
   BasePlatform,
   ServiceWorkerPool,
   SingleThreadedRuntime,
-  loadConfig,
-  createCacheFactory
+  CustomLoggerStorage,
+  CustomDatabaseStorage,
+  createDatabaseFactory
 } from "@b9g/platform";
+import {
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
+import { MemoryCache } from "@b9g/cache/memory";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { NodeFSDirectory } from "@b9g/filesystem/node-fs";
 import { InternalServerError, isHTTPError } from "@b9g/http-errors";
-import * as Path from "path";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["platform-bun"]);
+import * as Path from "path";
+import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
+var entryTemplate = `// Bun Production Server Entry
+import {tmpdir} from "os"; // For [tmpdir] config expressions
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import {config} from "shovel:config"; // Virtual module - resolved at build time
+import BunPlatform from "@b9g/platform-bun";
+
+// Configure logging before anything else
+await configureLogging(config.logging);
+
+const logger = getLogger(["shovel", "platform"]);
+
+// Configuration from shovel:config
+const PORT = config.port;
+const HOST = config.host;
+const WORKERS = config.workers;
+
+// Use explicit marker instead of Bun.isMainThread
+// This handles the edge case where Shovel's build output is embedded in another worker
+const isShovelWorker = process.env.SHOVEL_SPAWNED_WORKER === "1";
+
+if (isShovelWorker) {
+	// Worker thread: runs BOTH server AND ServiceWorker
+	const platform = new BunPlatform({port: PORT, host: HOST, workers: 1});
+	const userCodePath = new URL("./server.js", import.meta.url).pathname;
+	const serviceWorker = await platform.loadServiceWorker(userCodePath);
+
+	Bun.serve({
+		port: PORT,
+		hostname: HOST,
+		// Only need reusePort for multi-worker (multiple listeners on same port)
+		reusePort: WORKERS > 1,
+		fetch: serviceWorker.handleRequest,
+	});
+
+	// Signal ready to main thread
+	postMessage({type: "ready", thread: Bun.threadId});
+	logger.info("Worker started", {port: PORT, thread: Bun.threadId});
+} else {
+	// Main thread: supervisor only - ALWAYS spawn workers (even for workers:1)
+	// This ensures ServiceWorker code always runs in a worker thread for dev/prod parity
+
+	// Port availability check - fail fast if port is in use
+	// Prevents accidental port sharing with other processes
+	const checkPort = async () => {
+		try {
+			const testServer = Bun.serve({port: PORT, hostname: HOST, fetch: () => new Response()});
+			testServer.stop();
+		} catch (err) {
+			logger.error("Port unavailable", {port: PORT, host: HOST, error: err});
+			process.exit(1);
+		}
+	};
+	await checkPort();
+
+	let shuttingDown = false;
+	const workers = [];
+	let readyCount = 0;
+
+	for (let i = 0; i < WORKERS; i++) {
+		const worker = new Worker(import.meta.path, {
+			env: {...process.env, SHOVEL_SPAWNED_WORKER: "1"},
+		});
+
+		worker.onmessage = (event) => {
+			if (event.data.type === "ready") {
+				readyCount++;
+				if (readyCount === WORKERS) {
+					logger.info("All workers ready", {count: WORKERS, port: PORT});
+				}
+			}
+		};
+
+		worker.onerror = (error) => {
+			logger.error("Worker error", {error: error.message});
+		};
+
+		// If a worker crashes, fail fast - let process supervisor handle restarts
+		worker.addEventListener("close", () => {
+			if (shuttingDown) return;
+			logger.error("Worker crashed, exiting");
+			process.exit(1);
+		});
+
+		workers.push(worker);
+	}
+
+	logger.info("Spawned workers", {count: WORKERS, port: PORT});
+
+	// Graceful shutdown
+	const shutdown = async () => {
+		shuttingDown = true;
+		logger.info("Shutting down workers");
+		for (const worker of workers) {
+			worker.terminate();
+		}
+		process.exit(0);
+	};
+
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+`;
+var workerEntryTemplate = `// Worker Entry for ServiceWorkerPool
+// This file sets up the ServiceWorker runtime and message loop
+import {tmpdir} from "os"; // For [tmpdir] config expressions
+import {config} from "shovel:config";
+import {initWorkerRuntime, startWorkerMessageLoop, configureLogging} from "@b9g/platform/runtime";
+
+// Configure logging before anything else
+await configureLogging(config.logging);
+
+// Initialize the worker runtime (installs ServiceWorker globals)
+// Platform defaults and paths are already resolved at build time
+const {registration, databases} = await initWorkerRuntime({config});
+
+// Import user code (registers event handlers via addEventListener)
+// Must use dynamic import to ensure globals are installed first
+await import("__USER_ENTRY__");
+
+// Run ServiceWorker lifecycle
+await registration.install();
+await registration.activate();
+
+// Start the message loop (handles request/response messages from main thread)
+// Pass databases so they can be closed on graceful shutdown
+startWorkerMessageLoop({registration, databases});
+`;
+var logger = getLogger(["shovel", "platform"]);
 var BunPlatform = class extends BasePlatform {
   name;
   #options;
   #workerPool;
   #singleThreadedRuntime;
   #cacheStorage;
-  #config;
+  #directoryStorage;
+  #databaseStorage;
   constructor(options = {}) {
     super(options);
     this.name = "bun";
     const cwd = options.cwd || process.cwd();
-    this.#config = loadConfig(cwd);
     this.#options = {
-      port: options.port ?? this.#config.port,
-      host: options.host ?? this.#config.host,
+      port: options.port ?? 3e3,
+      host: options.host ?? "localhost",
+      workers: options.workers ?? 1,
       cwd,
-      ...options
+      config: options.config
     };
   }
   /**
@@ -47,46 +187,96 @@ var BunPlatform = class extends BasePlatform {
     this.#workerPool = pool;
   }
   /**
-   * Create cache storage
-   * Uses config from package.json shovel field
+   * Create cache storage using config from shovel.json
+   * Merges with runtime defaults (actual class references) for fallback behavior
    */
   async createCaches() {
-    return new CustomCacheStorage(createCacheFactory({ config: this.#config }));
+    const runtimeDefaults = {
+      default: { impl: MemoryCache }
+    };
+    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 using config from shovel.json
+   * Merges with runtime defaults (actual class references) for fallback behavior
+   */
+  async createDirectories() {
+    const runtimeDefaults = {
+      server: { impl: NodeFSDirectory, path: this.#options.cwd },
+      public: { impl: NodeFSDirectory, path: this.#options.cwd },
+      tmp: { impl: NodeFSDirectory, path: tmpdir() }
+    };
+    const userDirs = this.#options.config?.directories ?? {};
+    const configs = {};
+    const allNames = /* @__PURE__ */ new Set([
+      ...Object.keys(runtimeDefaults),
+      ...Object.keys(userDirs)
+    ]);
+    for (const name of allNames) {
+      configs[name] = { ...runtimeDefaults[name], ...userDirs[name] };
+    }
+    return new CustomDirectoryStorage(createDirectoryFactory(configs));
+  }
+  /**
+   * Create logger storage using config from shovel.json
+   */
+  async createLoggers() {
+    return new CustomLoggerStorage((categories) => getLogger(categories));
+  }
+  /**
+   * Create database storage from declarative config in shovel.json
+   */
+  createDatabases(configOverride) {
+    const config = configOverride ?? this.#options.config;
+    if (config?.databases && Object.keys(config.databases).length > 0) {
+      const factory = createDatabaseFactory(config.databases);
+      return new CustomDatabaseStorage(factory);
+    }
+    return void 0;
   }
   /**
    * Create HTTP server using Bun.serve
    */
   createServer(handler, options = {}) {
-    const port = options.port ?? this.#options.port;
+    const requestedPort = options.port ?? this.#options.port;
     const hostname = options.host ?? this.#options.host;
     const server = Bun.serve({
-      port,
+      port: requestedPort,
       hostname,
       async fetch(request) {
         try {
           return await handler(request);
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));
-          logger.error("Request error", {
-            error: err.message,
-            stack: err.stack
-          });
+          logger.error("Request error: {error}", { error: err });
           const httpError = isHTTPError(error) ? error : new InternalServerError(err.message, { cause: err });
           const isDev = import.meta.env?.MODE !== "production";
           return httpError.toResponse(isDev);
         }
       }
     });
+    const actualPort = server.port;
     return {
       async listen() {
-        logger.info("Bun server running", { url: `http://${hostname}:${port}` });
+        logger.info("Bun server running", {
+          url: `http://${hostname}:${actualPort}`
+        });
       },
       async close() {
         server.stop();
       },
-      address: () => ({ port, host: hostname }),
+      address: () => ({ port: actualPort, host: hostname }),
       get url() {
-        return `http://${hostname}:${port}`;
+        return `http://${hostname}:${actualPort}`;
       },
       get ready() {
         return true;
@@ -98,7 +288,7 @@ var BunPlatform = class extends BasePlatform {
    * Uses native Web Workers with the common WorkerPool
    */
   async loadServiceWorker(entrypoint, options = {}) {
-    const workerCount = options.workerCount ?? this.#config.workers ?? 1;
+    const workerCount = options.workerCount ?? this.#options.workers;
     if (workerCount === 1 && !options.hotReload) {
       return this.#loadServiceWorkerDirect(entrypoint, options);
     }
@@ -110,9 +300,55 @@ var BunPlatform = class extends BasePlatform {
    */
   async #loadServiceWorkerDirect(entrypoint, _options) {
     const entryPath = Path.resolve(this.#options.cwd, entrypoint);
-    const entryDir = Path.dirname(entryPath);
+    let config = this.#options.config;
+    const configPath = Path.join(Path.dirname(entryPath), "config.js");
+    try {
+      const configModule = await import(configPath);
+      config = configModule.config ?? config;
+    } catch (err) {
+      logger.debug`Using platform config (no config.js): ${err}`;
+    }
     if (!this.#cacheStorage) {
-      this.#cacheStorage = await this.createCaches();
+      const runtimeCacheDefaults = {
+        default: { impl: MemoryCache }
+      };
+      const userCaches = config?.caches ?? {};
+      const cacheConfigs = {};
+      const allCacheNames = /* @__PURE__ */ new Set([
+        ...Object.keys(runtimeCacheDefaults),
+        ...Object.keys(userCaches)
+      ]);
+      for (const name of allCacheNames) {
+        cacheConfigs[name] = {
+          ...runtimeCacheDefaults[name],
+          ...userCaches[name]
+        };
+      }
+      this.#cacheStorage = new CustomCacheStorage(
+        createCacheFactory({ configs: cacheConfigs })
+      );
+    }
+    if (!this.#directoryStorage) {
+      const runtimeDirDefaults = {
+        server: { impl: NodeFSDirectory },
+        public: { impl: NodeFSDirectory },
+        tmp: { impl: NodeFSDirectory }
+      };
+      const userDirs = config?.directories ?? {};
+      const dirConfigs = {};
+      const allDirNames = /* @__PURE__ */ new Set([
+        ...Object.keys(runtimeDirDefaults),
+        ...Object.keys(userDirs)
+      ]);
+      for (const name of allDirNames) {
+        dirConfigs[name] = { ...runtimeDirDefaults[name], ...userDirs[name] };
+      }
+      this.#directoryStorage = new CustomDirectoryStorage(
+        createDirectoryFactory(dirConfigs)
+      );
+    }
+    if (!this.#databaseStorage) {
+      this.#databaseStorage = this.createDatabases(config);
     }
     if (this.#singleThreadedRuntime) {
       await this.#singleThreadedRuntime.terminate();
@@ -123,12 +359,13 @@ var BunPlatform = class extends BasePlatform {
     }
     logger.info("Creating single-threaded ServiceWorker runtime", { entryPath });
     this.#singleThreadedRuntime = new SingleThreadedRuntime({
-      baseDir: entryDir,
-      cacheStorage: this.#cacheStorage,
-      config: this.#config
+      caches: this.#cacheStorage,
+      directories: this.#directoryStorage,
+      databases: this.#databaseStorage,
+      loggers: new CustomLoggerStorage((cats) => getLogger(cats))
     });
     await this.#singleThreadedRuntime.init();
-    await this.#singleThreadedRuntime.loadEntrypoint(entryPath);
+    await this.#singleThreadedRuntime.load(entryPath);
     const runtime = this.#singleThreadedRuntime;
     const platform = this;
     const instance = {
@@ -185,11 +422,9 @@ var BunPlatform = class extends BasePlatform {
     this.#workerPool = new ServiceWorkerPool(
       poolOptions,
       entryPath,
-      this.#cacheStorage,
-      this.#config
+      this.#cacheStorage
     );
     await this.#workerPool.init();
-    await this.#workerPool.reloadWorkers(entryPath);
     const workerPool = this.#workerPool;
     const platform = this;
     const instance = {
@@ -230,9 +465,72 @@ var BunPlatform = class extends BasePlatform {
     if (this.#workerPool) {
       await this.#workerPool.reloadWorkers(entrypoint);
     } else if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.reloadWorkers(entrypoint);
+      await this.#singleThreadedRuntime.load(entrypoint);
     }
   }
+  /**
+   * Get virtual entry wrapper for Bun
+   *
+   * @param entryPath - Absolute path to user's entrypoint file
+   * @param options - Entry wrapper options
+   * @param options.type - "production" (default) or "worker"
+   * @param options.outDir - Output directory (required for "worker" type)
+   *
+   * Returns:
+   * - "production": Server entry with Bun.serve and reusePort
+   * - "worker": Worker entry that sets up runtime and message loop
+   */
+  getEntryWrapper(entryPath, options) {
+    if (options?.type === "worker") {
+      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
+    }
+    return entryTemplate;
+  }
+  /**
+   * Get Bun-specific esbuild configuration
+   *
+   * Note: Bun natively supports import.meta.env, so no define alias is needed.
+   * We use platform: "node" since Bun is Node-compatible for module resolution.
+   */
+  getESBuildConfig() {
+    return {
+      platform: "node",
+      external: ["node:*", "bun", "bun:*", ...builtinModules]
+    };
+  }
+  /**
+   * Get Bun-specific defaults for config generation
+   *
+   * Provides default directories (server, public, tmp) that work
+   * out of the box for Bun deployments.
+   */
+  getDefaults() {
+    return {
+      caches: {
+        default: {
+          module: "@b9g/cache/memory",
+          export: "MemoryCache"
+        }
+      },
+      directories: {
+        server: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[outdir]/server"
+        },
+        public: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[outdir]/public"
+        },
+        tmp: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[tmpdir]"
+        }
+      }
+    };
+  }
   /**
    * Dispose of platform resources
    */
@@ -249,10 +547,24 @@ var BunPlatform = class extends BasePlatform {
       await this.#cacheStorage.dispose();
       this.#cacheStorage = void 0;
     }
+    if (this.#databaseStorage) {
+      await this.#databaseStorage.closeAll();
+      this.#databaseStorage = void 0;
+    }
+  }
+  // =========================================================================
+  // Config Expression Method Overrides
+  // =========================================================================
+  /**
+   * Get the OS temp directory (Bun-specific implementation using node:os)
+   */
+  tmpdir() {
+    return tmpdir();
   }
 };
 var src_default = BunPlatform;
 export {
   BunPlatform,
+  MemoryCache2 as DefaultCache,
   src_default as default
 };