@b9g/platform-bun 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.10",
+  "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.15",
-    "@b9g/cache": "^0.1.5",
-    "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.12",
+    "@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,7 +3,8 @@
  *
  * Provides built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-import { BasePlatform, type PlatformConfig, type Handler, type Server, type ServerOptions, type ServiceWorkerOptions, type ServiceWorkerInstance, type EntryWrapperOptions, type PlatformEsbuildConfig, 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";
 import { CustomDirectoryStorage } from "@b9g/filesystem";
 export interface BunPlatformOptions extends PlatformConfig {
@@ -15,6 +16,8 @@ export interface BunPlatformOptions extends PlatformConfig {
     cwd?: string;
     /** Number of worker threads (default: 1) */
     workers?: number;
+    /** Shovel configuration (caches, directories, etc.) */
+    config?: ShovelConfig;
 }
 /**
  * Bun platform implementation
@@ -27,20 +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 (in-memory by default)
+     * Create cache storage using config from shovel.json
+     * Merges with runtime defaults (actual class references) for fallback behavior
      */
     createCaches(): Promise<CustomCacheStorage>;
     /**
-     * Create directory storage for the given base directory
+     * Create directory storage using config from shovel.json
+     * Merges with runtime defaults (actual class references) for fallback behavior
      */
-    createDirectories(baseDir: string): CustomDirectoryStorage;
+    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
      */
@@ -58,28 +77,45 @@ export declare class BunPlatform extends BasePlatform {
     /**
      * Get virtual entry wrapper for Bun
      *
-     * Returns production server entry template that uses:
-     * - shovel:config virtual module for configuration
-     * - Bun.serve with reusePort for multi-worker scaling
-     * - Direct import of user's server code
+     * @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)
      *
-     * The template is a real .ts file (entry-template.ts) for better
-     * IDE support and linting. It's imported with {type: "text"}.
+     * 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;
+    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;
+    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,19 +1,29 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
 import {
   BasePlatform,
   ServiceWorkerPool,
   SingleThreadedRuntime,
-  CustomLoggerStorage
+  CustomLoggerStorage,
+  CustomDatabaseStorage,
+  createDatabaseFactory
 } from "@b9g/platform";
+import {
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
 import { MemoryCache } from "@b9g/cache/memory";
-import { NodeDirectory } from "@b9g/filesystem/node";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { NodeFSDirectory } from "@b9g/filesystem/node-fs";
 import { InternalServerError, isHTTPError } from "@b9g/http-errors";
 import { getLogger } from "@logtape/logtape";
 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
@@ -22,16 +32,19 @@ import BunPlatform from "@b9g/platform-bun";
 // Configure logging before anything else
 await configureLogging(config.logging);
 
-const logger = getLogger(["platform"]);
+const logger = getLogger(["shovel", "platform"]);
 
 // Configuration from shovel:config
 const PORT = config.port;
 const HOST = config.host;
 const WORKERS = config.workers;
-const isWorker = !Bun.isMainThread;
 
-// Worker thread entry - each worker runs its own Bun.serve with reusePort
-if (isWorker) {
+// 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);
@@ -39,47 +52,105 @@ if (isWorker) {
 	Bun.serve({
 		port: PORT,
 		hostname: HOST,
-		reusePort: true,
+		// 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 - spawn worker threads, each binds to same port with reusePort
-	if (WORKERS > 1) {
-		for (let i = 0; i < WORKERS; i++) {
-			new Worker(import.meta.path);
+	// 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);
 		}
-		logger.info("Spawned workers", {count: WORKERS, port: PORT});
-	} else {
-		// Single worker mode - run directly in main thread
-		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);
+	};
+	await checkPort();
+
+	let shuttingDown = false;
+	const workers = [];
+	let readyCount = 0;
 
-		const server = platform.createServer(serviceWorker.handleRequest, {
-			port: PORT,
-			host: HOST,
+	for (let i = 0; i < WORKERS; i++) {
+		const worker = new Worker(import.meta.path, {
+			env: {...process.env, SHOVEL_SPAWNED_WORKER: "1"},
 		});
-		await server.listen();
 
-		logger.info("Server started", {url: server.url});
+		worker.onmessage = (event) => {
+			if (event.data.type === "ready") {
+				readyCount++;
+				if (readyCount === WORKERS) {
+					logger.info("All workers ready", {count: WORKERS, port: PORT});
+				}
+			}
+		};
 
-		// Graceful shutdown
-		const shutdown = async () => {
-			logger.info("Shutting down");
-			await serviceWorker.dispose();
-			await platform.dispose();
-			await server.close();
-			process.exit(0);
+		worker.onerror = (error) => {
+			logger.error("Worker error", {error: error.message});
 		};
 
-		process.on("SIGINT", shutdown);
-		process.on("SIGTERM", shutdown);
+		// 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 logger = getLogger(["platform"]);
+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;
@@ -87,6 +158,7 @@ var BunPlatform = class extends BasePlatform {
   #singleThreadedRuntime;
   #cacheStorage;
   #directoryStorage;
+  #databaseStorage;
   constructor(options = {}) {
     super(options);
     this.name = "bun";
@@ -96,7 +168,7 @@ var BunPlatform = class extends BasePlatform {
       host: options.host ?? "localhost",
       workers: options.workers ?? 1,
       cwd,
-      ...options
+      config: options.config
     };
   }
   /**
@@ -115,26 +187,61 @@ var BunPlatform = class extends BasePlatform {
     this.#workerPool = pool;
   }
   /**
-   * Create cache storage (in-memory by default)
+   * Create cache storage using config from shovel.json
+   * Merges with runtime defaults (actual class references) for fallback behavior
    */
   async createCaches() {
-    return new CustomCacheStorage((name) => new MemoryCache(name));
+    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 for the given base directory
+   * Create directory storage using config from shovel.json
+   * Merges with runtime defaults (actual class references) for fallback behavior
    */
-  createDirectories(baseDir) {
-    return new CustomDirectoryStorage((name) => {
-      let dirPath;
-      if (name === "static") {
-        dirPath = Path.resolve(baseDir, "../static");
-      } else if (name === "server") {
-        dirPath = baseDir;
-      } else {
-        dirPath = Path.resolve(baseDir, `../${name}`);
-      }
-      return Promise.resolve(new NodeDirectory(dirPath));
-    });
+  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
@@ -193,12 +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) {
-      this.#directoryStorage = this.createDirectories(entryDir);
+      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();
@@ -211,7 +361,8 @@ var BunPlatform = class extends BasePlatform {
     this.#singleThreadedRuntime = new SingleThreadedRuntime({
       caches: this.#cacheStorage,
       directories: this.#directoryStorage,
-      loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
+      databases: this.#databaseStorage,
+      loggers: new CustomLoggerStorage((cats) => getLogger(cats))
     });
     await this.#singleThreadedRuntime.init();
     await this.#singleThreadedRuntime.load(entryPath);
@@ -271,12 +422,9 @@ var BunPlatform = class extends BasePlatform {
     this.#workerPool = new ServiceWorkerPool(
       poolOptions,
       entryPath,
-      this.#cacheStorage,
-      {}
-      // Empty config - use defaults
+      this.#cacheStorage
     );
     await this.#workerPool.init();
-    await this.#workerPool.reloadWorkers(entryPath);
     const workerPool = this.#workerPool;
     const platform = this;
     const instance = {
@@ -323,15 +471,19 @@ var BunPlatform = class extends BasePlatform {
   /**
    * Get virtual entry wrapper for Bun
    *
-   * Returns production server entry template that uses:
-   * - shovel:config virtual module for configuration
-   * - Bun.serve with reusePort for multi-worker scaling
-   * - Direct import of user's server code
+   * @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)
    *
-   * The template is a real .ts file (entry-template.ts) for better
-   * IDE support and linting. It's imported with {type: "text"}.
+   * Returns:
+   * - "production": Server entry with Bun.serve and reusePort
+   * - "worker": Worker entry that sets up runtime and message loop
    */
-  getEntryWrapper(_entryPath, _options) {
+  getEntryWrapper(entryPath, options) {
+    if (options?.type === "worker") {
+      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
+    }
     return entryTemplate;
   }
   /**
@@ -340,10 +492,43 @@ var BunPlatform = class extends BasePlatform {
    * 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() {
+  getESBuildConfig() {
     return {
       platform: "node",
-      external: ["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]"
+        }
+      }
     };
   }
   /**
@@ -362,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
 };