@b9g/platform-node 0.1.11 → 0.1.12

package/README.md

@@ -8,7 +8,7 @@ Node.js platform adapter for Shovel. Runs ServiceWorker applications on Node.js
 - Hot module reloading for development via VM module system
 - Worker thread pool for concurrent request handling
 - Memory and filesystem cache backends
-- File System Access API implementation via NodeBucket
+- File System Access API implementation via NodeDirectory
 - ServiceWorker lifecycle support (install, activate, fetch events)
 
 ## Installation
@@ -112,7 +112,7 @@ Loads and runs a ServiceWorker entrypoint.
 Configured via `caches` option:
 
 - `memory`: In-memory caching (MemoryCache)
-- `filesystem`: File-based caching (NodeBucket)
+- `filesystem`: File-based caching (NodeDirectory)
 
 ## Worker Thread Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -11,9 +11,9 @@
     "esbuild"
   ],
   "dependencies": {
-    "@b9g/cache": "^0.1.4",
+    "@b9g/cache": "^0.1.5",
     "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.10",
+    "@b9g/platform": "^0.1.12",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {

package/src/index.d.ts

@@ -3,9 +3,9 @@
  *
  * Provides hot reloading, ESBuild integration, and optimized caching for Node.js 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 } from "@b9g/platform";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
 export interface NodePlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -13,6 +13,8 @@ export interface NodePlatformOptions extends PlatformConfig {
     host?: string;
     /** Working directory for file resolution */
     cwd?: string;
+    /** Number of worker threads (default: 1) */
+    workers?: number;
 }
 /**
  * Node.js platform implementation
@@ -37,10 +39,13 @@ export declare class NodePlatform extends BasePlatform {
      */
     loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
     /**
-     * SUPPORTING UTILITY - 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;
     /**
      * SUPPORTING UTILITY - Create HTTP server for Node.js
      */
@@ -50,6 +55,25 @@ export declare class NodePlatform extends BasePlatform {
      * @param entrypoint - Path to the new entrypoint (hashed filename)
      */
     reloadWorkers(entrypoint: string): Promise<void>;
+    /**
+     * Get virtual entry wrapper for Node.js
+     *
+     * Returns production server entry template that uses:
+     * - shovel:config virtual module for configuration
+     * - Worker threads via ServiceWorkerPool for multi-worker scaling
+     * - Platform's loadServiceWorker and createServer methods
+     *
+     * 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 Node.js-specific esbuild configuration
+     *
+     * 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.
+     */
+    getEsbuildConfig(): PlatformEsbuildConfig;
     /**
      * Dispose of platform resources
      */

package/src/index.js

@@ -4,31 +4,87 @@ 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 HTTP from "http";
 import * as Path from "path";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["platform-node"]);
+var entryTemplate = `// Node.js Production Server Entry
+// This file is imported as text and used as the entry wrapper template
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import {config} from "shovel:config"; // Virtual module - resolved at build time
+import Platform from "@b9g/platform-node";
+
+// Configure logging before anything else
+await configureLogging(config.logging);
+
+const logger = getLogger(["platform"]);
+
+// Configuration from shovel:config (with process.env fallbacks baked in)
+const PORT = config.port;
+const HOST = config.host;
+const WORKER_COUNT = config.workers;
+
+logger.info("Starting production server", {});
+logger.info("Workers", {count: WORKER_COUNT});
+
+// Create platform instance
+const platform = new Platform();
+
+// Get the path to the user's ServiceWorker code
+const userCodeURL = new URL("./server.js", import.meta.url);
+const userCodePath = userCodeURL.pathname;
+
+// Load ServiceWorker with worker pool
+const serviceWorker = await platform.loadServiceWorker(userCodePath, {
+	workerCount: WORKER_COUNT,
+});
+
+// Create HTTP server
+const server = platform.createServer(serviceWorker.handleRequest, {
+	port: PORT,
+	host: HOST,
+});
+
+await server.listen();
+logger.info("Server running", {url: \`http://\${HOST}:\${PORT}\`});
+logger.info("Load balancing", {workers: WORKER_COUNT});
+
+// Graceful shutdown
+const shutdown = async () => {
+	logger.info("Shutting down server", {});
+	await serviceWorker.dispose();
+	await platform.dispose();
+	await server.close();
+	logger.info("Server stopped", {});
+	process.exit(0);
+};
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+`;
+var logger = getLogger(["platform"]);
 var NodePlatform = class extends BasePlatform {
   name;
   #options;
   #workerPool;
   #singleThreadedRuntime;
   #cacheStorage;
-  #config;
+  #directoryStorage;
   constructor(options = {}) {
     super(options);
     this.name = "node";
     const cwd = options.cwd || process.cwd();
-    this.#config = loadConfig(cwd);
-    logger.info("Loaded configuration", { config: this.#config });
     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
     };
@@ -53,7 +109,7 @@ var NodePlatform = class extends BasePlatform {
    * Uses Worker threads with coordinated cache storage for isolation and standards compliance
    */
   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);
     }
@@ -69,6 +125,9 @@ var NodePlatform = 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();
     }
@@ -78,12 +137,12 @@ var NodePlatform = 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 = {
@@ -143,7 +202,8 @@ var NodePlatform = class extends BasePlatform {
       },
       entryPath,
       this.#cacheStorage,
-      this.#config
+      {}
+      // Empty config - use defaults
     );
     await this.#workerPool.init();
     await this.#workerPool.reloadWorkers(entryPath);
@@ -184,11 +244,26 @@ var NodePlatform = class extends BasePlatform {
     return instance;
   }
   /**
-   * SUPPORTING UTILITY - 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));
+    });
   }
   /**
    * SUPPORTING UTILITY - Create HTTP server for Node.js
@@ -228,10 +303,7 @@ var NodePlatform = class extends BasePlatform {
         }
       } 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";
         const response = httpError.toResponse(isDev);
@@ -290,9 +362,39 @@ var NodePlatform = 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 Node.js
+   *
+   * Returns production server entry template that uses:
+   * - shovel:config virtual module for configuration
+   * - Worker threads via ServiceWorkerPool for multi-worker scaling
+   * - Platform's loadServiceWorker and createServer methods
+   *
+   * 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 Node.js-specific esbuild configuration
+   *
+   * 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.
+   */
+  getEsbuildConfig() {
+    return {
+      platform: "node",
+      external: ["node:*"],
+      define: {
+        // Node.js doesn't support import.meta.env, alias to process.env
+        "import.meta.env": "process.env"
+      }
+    };
+  }
   /**
    * Dispose of platform resources
    */