@b9g/platform-node 0.1.14-beta.0 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.14-beta.0",
+  "version": "0.1.15",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -11,10 +11,10 @@
     "esbuild"
   ],
   "dependencies": {
-    "@b9g/cache": "^0.2.0-beta.0",
-    "@b9g/http-errors": "^0.2.0-beta.0",
-    "@b9g/node-webworker": "^0.2.0-beta.1",
-    "@b9g/platform": "^0.1.14-beta.0",
+    "@b9g/cache": "^0.2.0",
+    "@b9g/http-errors": "^0.2.0",
+    "@b9g/node-webworker": "^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 hot reloading, ESBuild integration, and optimized caching for Node.js 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 NodePlatformOptions extends PlatformConfig {
+export interface NodePlatformOptions {
     /** Port for development server (default: 3000) */
     port?: number;
     /** Host for development server (default: localhost) */
@@ -68,7 +66,7 @@ export declare class NodeServiceWorkerContainer extends EventTarget implements S
  * Node.js platform implementation
  * ServiceWorker entrypoint loader for Node.js with ESBuild VM system
  */
-export declare class NodePlatform extends BasePlatform {
+export declare class NodePlatform {
     #private;
     readonly name: string;
     readonly serviceWorker: NodeServiceWorkerContainer;
@@ -97,39 +95,7 @@ export declare class NodePlatform extends BasePlatform {
         config?: ShovelConfig;
     };
     /**
-     * Create cache storage for Node.js
-     *
-     * 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 Node.js
-     *
-     * 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 Node.js
-     *
-     * Uses LogTape for structured logging.
-     */
-    createLoggers(): Promise<CustomLoggerStorage>;
-    /**
-     * Create database storage for Node.js
-     *
-     * Returns undefined if no databases configured in shovel.json.
-     * Supports SQLite via better-sqlite3.
-     */
-    createDatabases(configOverride?: NodePlatformOptions["config"]): CustomDatabaseStorage | undefined;
-    /**
-     * SUPPORTING UTILITY - Create HTTP server for Node.js
+     * Create HTTP server for Node.js
      */
     createServer(handler: Handler, options?: ServerOptions): Server;
     /**
@@ -139,13 +105,16 @@ export declare class NodePlatform 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 message loop (develop command acts as supervisor)
      *
-     * Node.js produces two files:
+     * Production mode:
      * - index.js: Supervisor that spawns workers and owns the HTTP server
      * - worker.js: Worker that handles requests via message loop
      */
-    getProductionEntryPoints(userEntryPath: string): ProductionEntryPoints;
+    getEntryPoints(userEntryPath: string, mode: "development" | "production"): EntryPoints;
     /**
      * Get Node.js-specific esbuild configuration
      *

package/src/index.js

@@ -6,25 +6,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 NodeServiceWorkerContainer = class extends EventTarget {
   #platform;
@@ -140,14 +131,12 @@ var NodeServiceWorkerContainer = class extends EventTarget {
     await this.#pool?.reloadWorkers(entrypoint);
   }
 };
-var NodePlatform = class extends BasePlatform {
+var NodePlatform = class {
   name;
   serviceWorker;
   #options;
-  #databaseStorage;
   #server;
   constructor(options = {}) {
-    super(options);
     this.name = "node";
     const cwd = options.cwd || process.cwd();
     this.#options = {
@@ -195,66 +184,7 @@ var NodePlatform = class extends BasePlatform {
     return this.#options;
   }
   /**
-   * Create cache storage for Node.js
-   *
-   * 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 Node.js
-   *
-   * 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 Node.js
-   *
-   * Uses LogTape for structured logging.
-   */
-  async createLoggers() {
-    return new CustomLoggerStorage((categories) => getLogger(categories));
-  }
-  /**
-   * Create database storage for Node.js
-   *
-   * Returns undefined if no databases configured in shovel.json.
-   * Supports SQLite via better-sqlite3.
-   */
-  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;
-  }
-  /**
-   * SUPPORTING UTILITY - Create HTTP server for Node.js
+   * Create HTTP server for Node.js
    */
   createServer(handler, options = {}) {
     const port = options.port ?? this.#options.port;
@@ -291,8 +221,15 @@ var NodePlatform = class extends BasePlatform {
         }
       } 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";
         const response = httpError.toResponse(isDev);
         res.statusCode = response.status;
@@ -351,13 +288,45 @@ var NodePlatform = 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 message loop (develop command acts as supervisor)
    *
-   * Node.js produces two files:
+   * Production mode:
    * - index.js: Supervisor that spawns workers and owns the HTTP server
    * - worker.js: Worker that handles requests via message loop
    */
-  getProductionEntryPoints(userEntryPath) {
+  getEntryPoints(userEntryPath, mode) {
+    const workerCode = `// Node.js Worker
+import {parentPort} from "node:worker_threads";
+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 (stage from config.lifecycle if present)
+await runLifecycle(registration, config.lifecycle?.stage);
+
+// Start message loop for request handling, or signal ready and exit in lifecycle-only mode
+if (config.lifecycle) {
+	parentPort?.postMessage({type: "ready"});
+	// Clean shutdown after lifecycle
+	if (databases) await databases.closeAll();
+	process.exit(0);
+} else {
+	startWorkerMessageLoop({registration, databases});
+}
+`;
+    if (mode === "development") {
+      return { worker: workerCode };
+    }
     const supervisorCode = `// Node.js Production Supervisor
 import {Worker} from "@b9g/node-webworker";
 import {getLogger} from "@logtape/logtape";
@@ -390,35 +359,9 @@ const handleShutdown = async () => {
 };
 process.on("SIGINT", handleShutdown);
 process.on("SIGTERM", handleShutdown);
-`;
-    const workerCode = `// Node.js Production Worker
-import {parentPort} from "node:worker_threads";
-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 (stage from config.lifecycle if present)
-await runLifecycle(registration, config.lifecycle?.stage);
-
-// Start message loop for request handling, or signal ready and exit in lifecycle-only mode
-if (config.lifecycle) {
-	parentPort?.postMessage({type: "ready"});
-	// Clean shutdown after lifecycle
-	if (databases) await databases.closeAll();
-	process.exit(0);
-} else {
-	startWorkerMessageLoop({registration, databases});
-}
 `;
     return {
-      index: supervisorCode,
+      supervisor: supervisorCode,
       worker: workerCode
     };
   }
@@ -477,10 +420,6 @@ if (config.lifecycle) {
   async dispose() {
     await this.close();
     await this.serviceWorker.terminate();
-    if (this.#databaseStorage) {
-      await this.#databaseStorage.closeAll();
-      this.#databaseStorage = void 0;
-    }
   }
   // =========================================================================
   // Config Expression Method Overrides
@@ -494,7 +433,7 @@ if (config.lifecycle) {
 };
 var src_default = NodePlatform;
 export {
-  MemoryCache2 as DefaultCache,
+  MemoryCache as DefaultCache,
   NodePlatform,
   NodeServiceWorkerContainer,
   src_default as default

package/src/platform.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Node.js Platform Module
+ *
+ * Build-time and dev-time functions for Node.js.
+ * Runtime functions are in ./runtime.ts
+ */
+import type { EntryPoints, ESBuildConfig, PlatformDefaults, DevServerOptions, DevServer } from "@b9g/platform/module";
+export declare const name = "node";
+/**
+ * Get entry points for bundling.
+ *
+ * Development mode:
+ * - worker.js: Single worker with message loop (develop command acts as supervisor)
+ *
+ * Production mode:
+ * - supervisor.js: Spawns workers and owns the HTTP server
+ * - worker.js: Handles requests via message loop
+ */
+export declare function getEntryPoints(userEntryPath: string, mode: "development" | "production"): EntryPoints;
+/**
+ * Get ESBuild configuration for Node.js.
+ *
+ * Note: Node.js doesn't support import.meta.env natively, so we alias it
+ * to process.env for compatibility with code that uses Vite-style env access.
+ */
+export declare function getESBuildConfig(): ESBuildConfig;
+/**
+ * Get platform defaults for config generation.
+ *
+ * Provides default directories (server, public, tmp) that work
+ * out of the box for Node.js 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,146 @@
+/// <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 = "node";
+function getEntryPoints(userEntryPath, mode) {
+  const safePath = JSON.stringify(userEntryPath);
+  const workerCode = `// Node.js Worker
+import {parentPort} from "node:worker_threads";
+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 (stage from config.lifecycle if present)
+await runLifecycle(registration, config.lifecycle?.stage);
+
+// Start message loop for request handling, or signal ready and exit in lifecycle-only mode
+if (config.lifecycle) {
+	parentPort?.postMessage({type: "ready"});
+	// Clean shutdown after lifecycle
+	if (databases) await databases.closeAll();
+	process.exit(0);
+} else {
+	startWorkerMessageLoop({registration, databases});
+}
+`;
+  if (mode === "development") {
+    return { worker: workerCode };
+  }
+  const supervisorCode = `// Node.js Production Supervisor
+import {Worker} from "@b9g/node-webworker";
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import NodePlatform from "@b9g/platform-node";
+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
+// Override createWorker to use the imported Worker class (avoids require() issues with ESM)
+const platform = new NodePlatform({port: config.port, host: config.host, workers: config.workers});
+platform.createWorker = (entrypoint) => new Worker(entrypoint);
+await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
+await platform.serviceWorker.ready;
+
+// Start HTTP server
+await platform.listen();
+
+logger.info("Server started", {port: config.port, host: config.host, workers: config.workers});
+
+// Graceful shutdown
+const handleShutdown = async () => {
+	logger.info("Shutting down");
+	await platform.close();
+	process.exit(0);
+};
+process.on("SIGINT", handleShutdown);
+process.on("SIGTERM", handleShutdown);
+`;
+  return {
+    supervisor: supervisorCode,
+    worker: workerCode
+  };
+}
+function getESBuildConfig() {
+  return {
+    platform: "node",
+    external: ["node:*", ...builtinModules],
+    define: {
+      // Node.js doesn't support import.meta.env, alias to process.env
+      "import.meta.env": "process.env"
+    }
+  };
+}
+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 Node.js dev server", { workerPath, workers });
+  const { default: NodePlatform } = await import("./index.js");
+  const platform = new NodePlatform({
+    port,
+    host,
+    workers
+  });
+  await platform.serviceWorker.register(workerPath);
+  await platform.serviceWorker.ready;
+  await platform.listen();
+  logger.info("Node.js 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 Node.js dev server");
+      await platform.dispose();
+    }
+  };
+}
+export {
+  createDevServer,
+  getDefaults,
+  getESBuildConfig,
+  getEntryPoints,
+  name
+};