@b9g/platform-bun 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,11 +12,14 @@
     "jsx"
   ],
   "dependencies": {
-    "@b9g/platform": "^0.1.10",
-    "@b9g/assets": "^0.1.13"
+    "@b9g/assets": "^0.1.15",
+    "@b9g/cache": "^0.1.5",
+    "@b9g/http-errors": "^0.1.5",
+    "@b9g/platform": "^0.1.12",
+    "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
+    "@b9g/libuild": "^0.1.18",
     "bun-types": "latest"
   },
   "type": "module",

package/src/index.d.ts

@@ -3,9 +3,9 @@
  *
  * 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 Handler, type Server, type ServerOptions, type ServiceWorkerOptions, type ServiceWorkerInstance, type EntryWrapperOptions, type PlatformEsbuildConfig, ServiceWorkerPool } from "@b9g/platform";
 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 +13,8 @@ export interface BunPlatformOptions extends PlatformConfig {
     host?: string;
     /** Working directory for file resolution */
     cwd?: string;
+    /** Number of worker threads (default: 1) */
+    workers?: number;
 }
 /**
  * Bun platform implementation
@@ -32,10 +34,13 @@ export declare class BunPlatform extends BasePlatform {
     get workerPool(): ServiceWorkerPool | undefined;
     set workerPool(pool: ServiceWorkerPool | undefined);
     /**
-     * Create cache storage
-     * Uses config from package.json shovel field
+     * Create cache storage (in-memory by default)
      */
     createCaches(): Promise<CustomCacheStorage>;
+    /**
+     * Create directory storage for the given base directory
+     */
+    createDirectories(baseDir: string): CustomDirectoryStorage;
     /**
      * Create HTTP server using Bun.serve
      */
@@ -50,6 +55,25 @@ 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
+     *
+     * 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
+     *
+     * The template is a real .ts file (entry-template.ts) for better
+     * IDE support and linting. It's imported with {type: "text"}.
+     */
+    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;
     /**
      * Dispose of platform resources
      */

package/src/index.js

@@ -4,29 +4,97 @@ import {
   BasePlatform,
   ServiceWorkerPool,
   SingleThreadedRuntime,
-  loadConfig,
-  createCacheFactory
+  CustomLoggerStorage
 } from "@b9g/platform";
 import { CustomCacheStorage } from "@b9g/cache";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { MemoryCache } from "@b9g/cache/memory";
+import { NodeDirectory } from "@b9g/filesystem/node";
 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";
+var entryTemplate = `// Bun Production Server Entry
+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(["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) {
+	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,
+		reusePort: true,
+		fetch: serviceWorker.handleRequest,
+	});
+
+	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);
+		}
+		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);
+
+		const server = platform.createServer(serviceWorker.handleRequest, {
+			port: PORT,
+			host: HOST,
+		});
+		await server.listen();
+
+		logger.info("Server started", {url: server.url});
+
+		// Graceful shutdown
+		const shutdown = async () => {
+			logger.info("Shutting down");
+			await serviceWorker.dispose();
+			await platform.dispose();
+			await server.close();
+			process.exit(0);
+		};
+
+		process.on("SIGINT", shutdown);
+		process.on("SIGTERM", shutdown);
+	}
+}
+`;
+var logger = getLogger(["platform"]);
 var BunPlatform = class extends BasePlatform {
   name;
   #options;
   #workerPool;
   #singleThreadedRuntime;
   #cacheStorage;
-  #config;
+  #directoryStorage;
   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
     };
@@ -47,46 +115,61 @@ var BunPlatform = class extends BasePlatform {
     this.#workerPool = pool;
   }
   /**
-   * Create cache storage
-   * Uses config from package.json shovel field
+   * Create cache storage (in-memory by default)
    */
   async createCaches() {
-    return new CustomCacheStorage(createCacheFactory({ config: this.#config }));
+    return new CustomCacheStorage((name) => new MemoryCache(name));
+  }
+  /**
+   * Create directory storage for the given base directory
+   */
+  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));
+    });
   }
   /**
    * 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 +181,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);
     }
@@ -114,6 +197,9 @@ var BunPlatform = class extends BasePlatform {
     if (!this.#cacheStorage) {
       this.#cacheStorage = await this.createCaches();
     }
+    if (!this.#directoryStorage) {
+      this.#directoryStorage = this.createDirectories(entryDir);
+    }
     if (this.#singleThreadedRuntime) {
       await this.#singleThreadedRuntime.terminate();
     }
@@ -123,12 +209,12 @@ 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,
+      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 = {
@@ -186,7 +272,8 @@ var BunPlatform = class extends BasePlatform {
       poolOptions,
       entryPath,
       this.#cacheStorage,
-      this.#config
+      {}
+      // Empty config - use defaults
     );
     await this.#workerPool.init();
     await this.#workerPool.reloadWorkers(entryPath);
@@ -230,9 +317,35 @@ 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
+   *
+   * 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
+   *
+   * The template is a real .ts file (entry-template.ts) for better
+   * IDE support and linting. It's imported with {type: "text"}.
+   */
+  getEntryWrapper(_entryPath, _options) {
+    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:*"]
+    };
+  }
   /**
    * Dispose of platform resources
    */