@b9g/platform-bun 0.1.12-beta.0 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.12-beta.0",
+  "version": "0.1.13",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,10 +12,10 @@
     "jsx"
   ],
   "dependencies": {
-    "@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.14-beta.0",
+    "@b9g/assets": "^0.2.0",
+    "@b9g/cache": "^0.2.0",
+    "@b9g/http-errors": "^0.2.0",
+    "@b9g/platform": "^0.1.15",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
@@ -37,6 +37,14 @@
     "./index.js": {
       "types": "./src/index.d.ts",
       "import": "./src/index.js"
+    },
+    "./platform": {
+      "types": "./src/platform.d.ts",
+      "import": "./src/platform.js"
+    },
+    "./platform.js": {
+      "types": "./src/platform.d.ts",
+      "import": "./src/platform.js"
     }
   }
 }

package/src/index.d.ts

@@ -3,11 +3,9 @@
  *
  * Provides built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-import { CustomCacheStorage } from "@b9g/cache";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
-import { BasePlatform, type PlatformConfig, type PlatformDefaults, type Handler, type Server, type ServerOptions, type PlatformESBuildConfig, type ProductionEntryPoints, ServiceWorkerPool, CustomLoggerStorage, CustomDatabaseStorage } from "@b9g/platform";
+import { type PlatformDefaults, type Handler, type Server, type ServerOptions, type PlatformESBuildConfig, type EntryPoints, ServiceWorkerPool } from "@b9g/platform";
 import { type ShovelConfig } from "@b9g/platform/runtime";
-export interface BunPlatformOptions extends PlatformConfig {
+export interface BunPlatformOptions {
     /** Port for development server (default: 3000) */
     port?: number;
     /** Host for development server (default: localhost) */
@@ -72,7 +70,7 @@ export declare class BunServiceWorkerContainer extends EventTarget implements Se
  * Bun platform implementation
  * ServiceWorker entrypoint loader for Bun with native TypeScript/JSX support
  */
-export declare class BunPlatform extends BasePlatform {
+export declare class BunPlatform {
     #private;
     readonly name: string;
     readonly serviceWorker: BunServiceWorkerContainer;
@@ -87,38 +85,6 @@ export declare class BunPlatform extends BasePlatform {
         workers: number;
         config?: ShovelConfig;
     };
-    /**
-     * Create cache storage for Bun
-     *
-     * Default: MemoryCache (in-process LRU cache).
-     * Override via shovel.json caches config.
-     * Note: Used for dev/testing - production uses generated config module.
-     */
-    createCaches(): Promise<CustomCacheStorage>;
-    /**
-     * Create directory storage for Bun
-     *
-     * Defaults:
-     * - server: NodeFSDirectory at cwd (app files)
-     * - public: NodeFSDirectory at cwd (static assets)
-     * - tmp: NodeFSDirectory at OS temp dir
-     *
-     * Override via shovel.json directories config.
-     */
-    createDirectories(): Promise<CustomDirectoryStorage>;
-    /**
-     * Create logger storage for Bun
-     *
-     * Uses LogTape for structured logging.
-     */
-    createLoggers(): Promise<CustomLoggerStorage>;
-    /**
-     * Create database storage for Bun
-     *
-     * Returns undefined if no databases configured in shovel.json.
-     * Supports SQLite via bun:sqlite.
-     */
-    createDatabases(configOverride?: BunPlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
      * Create HTTP server using Bun.serve
      */
@@ -137,16 +103,19 @@ export declare class BunPlatform extends BasePlatform {
      */
     reloadWorkers(entrypoint: string): Promise<void>;
     /**
-     * Get production entry points for bundling.
+     * Get entry points for bundling.
+     *
+     * Development mode:
+     * - worker.js: Single worker with HTTP server (develop command manages process)
      *
-     * Bun produces two files:
+     * Production mode:
      * - index.js: Supervisor that spawns workers and handles signals
      * - worker.js: Worker with its own HTTP server (uses reusePort for multi-worker)
      *
      * Unlike Node.js, Bun workers each bind their own server with reusePort,
      * allowing the OS to load-balance across workers without message passing overhead.
      */
-    getProductionEntryPoints(userEntryPath: string): ProductionEntryPoints;
+    getEntryPoints(userEntryPath: string, mode: "development" | "production"): EntryPoints;
     /**
      * Get Bun-specific esbuild configuration
      *

package/src/index.js

@@ -5,25 +5,16 @@ import { tmpdir } from "node:os";
 import * as Path from "node:path";
 import { getLogger } from "@logtape/logtape";
 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 {
-  BasePlatform,
-  ServiceWorkerPool,
-  CustomLoggerStorage,
-  CustomDatabaseStorage,
-  createDatabaseFactory,
-  mergeConfigWithDefaults
+  ServiceWorkerPool
 } from "@b9g/platform";
 import {
   ShovelServiceWorkerRegistration,
   kServiceWorker,
-  createCacheFactory,
-  createDirectoryFactory
+  createCacheFactory
 } from "@b9g/platform/runtime";
-import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
+import { MemoryCache } from "@b9g/cache/memory";
 var logger = getLogger(["shovel", "platform"]);
 var BunServiceWorkerContainer = class extends EventTarget {
   #platform;
@@ -139,14 +130,12 @@ var BunServiceWorkerContainer = class extends EventTarget {
     await this.#pool?.reloadWorkers(entrypoint);
   }
 };
-var BunPlatform = class extends BasePlatform {
+var BunPlatform = class {
   name;
   serviceWorker;
   #options;
   #server;
-  #databaseStorage;
   constructor(options = {}) {
-    super(options);
     this.name = "bun";
     const cwd = options.cwd || process.cwd();
     this.#options = {
@@ -164,65 +153,6 @@ var BunPlatform = class extends BasePlatform {
   get options() {
     return this.#options;
   }
-  /**
-   * Create cache storage for Bun
-   *
-   * Default: MemoryCache (in-process LRU cache).
-   * Override via shovel.json caches config.
-   * Note: Used for dev/testing - production uses generated config module.
-   */
-  async createCaches() {
-    const defaults = { default: { impl: MemoryCache } };
-    const configs = mergeConfigWithDefaults(
-      defaults,
-      this.#options.config?.caches
-    );
-    return new CustomCacheStorage(createCacheFactory({ configs }));
-  }
-  /**
-   * Create directory storage for Bun
-   *
-   * Defaults:
-   * - server: NodeFSDirectory at cwd (app files)
-   * - public: NodeFSDirectory at cwd (static assets)
-   * - tmp: NodeFSDirectory at OS temp dir
-   *
-   * Override via shovel.json directories config.
-   */
-  async createDirectories() {
-    const defaults = {
-      server: { impl: NodeFSDirectory, path: this.#options.cwd },
-      public: { impl: NodeFSDirectory, path: this.#options.cwd },
-      tmp: { impl: NodeFSDirectory, path: tmpdir() }
-    };
-    const configs = mergeConfigWithDefaults(
-      defaults,
-      this.#options.config?.directories
-    );
-    return new CustomDirectoryStorage(createDirectoryFactory(configs));
-  }
-  /**
-   * Create logger storage for Bun
-   *
-   * Uses LogTape for structured logging.
-   */
-  async createLoggers() {
-    return new CustomLoggerStorage((categories) => getLogger(categories));
-  }
-  /**
-   * Create database storage for Bun
-   *
-   * Returns undefined if no databases configured in shovel.json.
-   * Supports SQLite via bun:sqlite.
-   */
-  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
    */
@@ -239,8 +169,15 @@ var BunPlatform = class extends BasePlatform {
           return await handler(request);
         } catch (error) {
           const err = error instanceof Error ? error : new Error(String(error));
-          logger.error("Request error: {error}", { error: err });
           const httpError = isHTTPError(error) ? error : new InternalServerError(err.message, { cause: err });
+          if (httpError.status >= 500) {
+            logger.error("Request error: {error}", { error: err });
+          } else {
+            logger.warn("Request error: {status} {error}", {
+              status: httpError.status,
+              error: err
+            });
+          }
           const isDev = import.meta.env?.MODE !== "production";
           return httpError.toResponse(isDev);
         }
@@ -297,44 +234,20 @@ var BunPlatform = class extends BasePlatform {
     await this.serviceWorker.reloadWorkers(entrypoint);
   }
   /**
-   * Get production entry points for bundling.
+   * Get entry points for bundling.
+   *
+   * Development mode:
+   * - worker.js: Single worker with HTTP server (develop command manages process)
    *
-   * Bun produces two files:
+   * Production mode:
    * - index.js: Supervisor that spawns workers and handles signals
    * - worker.js: Worker with its own HTTP server (uses reusePort for multi-worker)
    *
    * Unlike Node.js, Bun workers each bind their own server with reusePort,
    * allowing the OS to load-balance across workers without message passing overhead.
    */
-  getProductionEntryPoints(userEntryPath) {
-    const supervisorCode = `// Bun Production Supervisor
-import {getLogger} from "@logtape/logtape";
-import {configureLogging} from "@b9g/platform/runtime";
-import BunPlatform from "@b9g/platform-bun";
-import {config} from "shovel:config";
-
-await configureLogging(config.logging);
-const logger = getLogger(["shovel", "platform"]);
-
-logger.info("Starting production server", {port: config.port, workers: config.workers});
-
-// Initialize platform and register ServiceWorker (workers handle their own HTTP via reusePort)
-const platform = new BunPlatform({port: config.port, host: config.host, workers: config.workers});
-await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
-await platform.serviceWorker.ready;
-
-logger.info("All workers ready", {port: config.port, workers: config.workers});
-
-// Graceful shutdown
-const handleShutdown = async () => {
-	logger.info("Shutting down");
-	await platform.serviceWorker.terminate();
-	process.exit(0);
-};
-process.on("SIGINT", handleShutdown);
-process.on("SIGTERM", handleShutdown);
-`;
-    const workerCode = `// Bun Production Worker
+  getEntryPoints(userEntryPath, mode) {
+    const prodWorkerCode = `// Bun Production Worker
 import BunPlatform from "@b9g/platform-bun";
 import {getLogger} from "@logtape/logtape";
 import {configureLogging, initWorkerRuntime, runLifecycle, dispatchRequest} from "@b9g/platform/runtime";
@@ -380,10 +293,58 @@ if (!config.lifecycle) {
 
 postMessage({type: "ready"});
 logger.info("Worker started", {port: config.port});
+`;
+    const devWorkerCode = `// Bun Development Worker
+import {configureLogging, initWorkerRuntime, runLifecycle, startWorkerMessageLoop} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+
+// Initialize worker runtime (installs ServiceWorker globals)
+const {registration, databases} = await initWorkerRuntime({config});
+
+// Import user code (registers event handlers)
+await import("${userEntryPath}");
+
+// Run ServiceWorker lifecycle
+await runLifecycle(registration);
+
+// Start message loop for request handling (develop command handles HTTP)
+startWorkerMessageLoop({registration, databases});
+`;
+    if (mode === "development") {
+      return { worker: devWorkerCode };
+    }
+    const supervisorCode = `// Bun Production Supervisor
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import BunPlatform from "@b9g/platform-bun";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+const logger = getLogger(["shovel", "platform"]);
+
+logger.info("Starting production server", {port: config.port, workers: config.workers});
+
+// Initialize platform and register ServiceWorker (workers handle their own HTTP via reusePort)
+const platform = new BunPlatform({port: config.port, host: config.host, workers: config.workers});
+await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
+await platform.serviceWorker.ready;
+
+logger.info("All workers ready", {port: config.port, workers: config.workers});
+
+// Graceful shutdown
+const handleShutdown = async () => {
+	logger.info("Shutting down");
+	await platform.serviceWorker.terminate();
+	process.exit(0);
+};
+process.on("SIGINT", handleShutdown);
+process.on("SIGTERM", handleShutdown);
 `;
     return {
-      index: supervisorCode,
-      worker: workerCode
+      supervisor: supervisorCode,
+      worker: prodWorkerCode
     };
   }
   /**
@@ -437,10 +398,6 @@ logger.info("Worker started", {port: config.port});
   async dispose() {
     await this.close();
     await this.serviceWorker.terminate();
-    if (this.#databaseStorage) {
-      await this.#databaseStorage.closeAll();
-      this.#databaseStorage = void 0;
-    }
   }
   // =========================================================================
   // Config Expression Method Overrides
@@ -456,6 +413,6 @@ var src_default = BunPlatform;
 export {
   BunPlatform,
   BunServiceWorkerContainer,
-  MemoryCache2 as DefaultCache,
+  MemoryCache as DefaultCache,
   src_default as default
 };

package/src/platform.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Bun Platform Module
+ *
+ * Build-time and dev-time functions for Bun.
+ * Runtime functions are in ./runtime.ts
+ */
+import type { EntryPoints, ESBuildConfig, PlatformDefaults, DevServerOptions, DevServer } from "@b9g/platform/module";
+export declare const name = "bun";
+/**
+ * Get entry points for bundling.
+ *
+ * Development mode:
+ * - worker.js: Single worker with message loop (develop command manages process)
+ *
+ * Production mode:
+ * - supervisor.js: Spawns workers and handles signals
+ * - worker.js: Worker with its own HTTP server (uses reusePort for multi-worker)
+ *
+ * Unlike Node.js, Bun workers each bind their own server with reusePort,
+ * allowing the OS to load-balance across workers without message passing overhead.
+ */
+export declare function getEntryPoints(userEntryPath: string, mode: "development" | "production"): EntryPoints;
+/**
+ * Get ESBuild configuration for Bun.
+ *
+ * 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.
+ */
+export declare function getESBuildConfig(): ESBuildConfig;
+/**
+ * Get platform defaults for config generation.
+ *
+ * Provides default directories (server, public, tmp) that work
+ * out of the box for Bun deployments.
+ */
+export declare function getDefaults(): PlatformDefaults;
+/**
+ * Create a dev server using ServiceWorkerPool.
+ *
+ * Dynamically imports the platform class to keep heavy dependencies
+ * out of production bundles.
+ */
+export declare function createDevServer(options: DevServerOptions): Promise<DevServer>;

package/src/platform.js

@@ -0,0 +1,175 @@
+/// <reference types="./platform.d.ts" />
+// src/platform.ts
+import { builtinModules } from "node:module";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["shovel", "platform"]);
+var name = "bun";
+function getEntryPoints(userEntryPath, mode) {
+  const safePath = JSON.stringify(userEntryPath);
+  const devWorkerCode = `// Bun Development Worker
+import {configureLogging, initWorkerRuntime, runLifecycle, startWorkerMessageLoop} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+
+// Initialize worker runtime (installs ServiceWorker globals)
+const {registration, databases} = await initWorkerRuntime({config});
+
+// Import user code (registers event handlers)
+await import(${safePath});
+
+// Run ServiceWorker lifecycle
+await runLifecycle(registration);
+
+// Start message loop for request handling (develop command handles HTTP)
+startWorkerMessageLoop({registration, databases});
+`;
+  if (mode === "development") {
+    return { worker: devWorkerCode };
+  }
+  const prodWorkerCode = `// Bun Production Worker
+import BunPlatform from "@b9g/platform-bun";
+import {getLogger} from "@logtape/logtape";
+import {configureLogging, initWorkerRuntime, runLifecycle, dispatchRequest} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+const logger = getLogger(["shovel", "platform"]);
+
+// Track resources for shutdown
+let server;
+let databases;
+
+// Register shutdown handler before async startup
+self.onmessage = async (event) => {
+	if (event.data.type === "shutdown") {
+		logger.info("Worker shutting down");
+		if (server) await server.close();
+		if (databases) await databases.closeAll();
+		postMessage({type: "shutdown-complete"});
+	}
+};
+
+// Initialize worker runtime (installs ServiceWorker globals)
+const result = await initWorkerRuntime({config});
+const registration = result.registration;
+databases = result.databases;
+
+// Import user code (registers event handlers)
+await import(${safePath});
+
+// Run ServiceWorker lifecycle (stage from config.lifecycle if present)
+await runLifecycle(registration, config.lifecycle?.stage);
+
+// Start server (skip in lifecycle-only mode)
+if (!config.lifecycle) {
+	const platform = new BunPlatform({port: config.port, host: config.host});
+	server = platform.createServer(
+		(request) => dispatchRequest(registration, request),
+		{reusePort: config.workers > 1},
+	);
+	await server.listen();
+}
+
+postMessage({type: "ready"});
+logger.info("Worker started", {port: config.port});
+`;
+  const supervisorCode = `// Bun Production Supervisor
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import BunPlatform from "@b9g/platform-bun";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+const logger = getLogger(["shovel", "platform"]);
+
+logger.info("Starting production server", {port: config.port, workers: config.workers});
+
+// Initialize platform and register ServiceWorker (workers handle their own HTTP via reusePort)
+const platform = new BunPlatform({port: config.port, host: config.host, workers: config.workers});
+await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
+await platform.serviceWorker.ready;
+
+logger.info("All workers ready", {port: config.port, workers: config.workers});
+
+// Graceful shutdown
+const handleShutdown = async () => {
+	logger.info("Shutting down");
+	await platform.serviceWorker.terminate();
+	process.exit(0);
+};
+process.on("SIGINT", handleShutdown);
+process.on("SIGTERM", handleShutdown);
+`;
+  return {
+    supervisor: supervisorCode,
+    worker: prodWorkerCode
+  };
+}
+function getESBuildConfig() {
+  return {
+    platform: "node",
+    external: ["node:*", "bun", "bun:*", ...builtinModules]
+  };
+}
+function 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]"
+      }
+    }
+  };
+}
+async function createDevServer(options) {
+  const { port, host, workerPath, workers = 1 } = options;
+  logger.info("Starting Bun dev server", { workerPath, workers });
+  const { default: BunPlatform } = await import("./index.js");
+  const platform = new BunPlatform({
+    port,
+    host,
+    workers
+  });
+  await platform.serviceWorker.register(workerPath);
+  await platform.serviceWorker.ready;
+  await platform.listen();
+  logger.info("Bun dev server ready");
+  const url = `http://${host}:${port}`;
+  return {
+    url,
+    async reload(newWorkerPath) {
+      logger.info("Reloading workers", { workerPath: newWorkerPath });
+      await platform.serviceWorker.reloadWorkers(newWorkerPath);
+      logger.info("Workers reloaded");
+    },
+    async close() {
+      logger.info("Stopping Bun dev server");
+      await platform.dispose();
+    }
+  };
+}
+export {
+  createDevServer,
+  getDefaults,
+  getESBuildConfig,
+  getEntryPoints,
+  name
+};