@vercube/vite 1.2.1 → 1.3.0

package/README.md

@@ -73,13 +73,14 @@ node dist/index.mjs   # runs the built server
 
 ## Options
 
-| Option       | Type                   | Default         | Description                                                                                                       |
-| ------------ | ---------------------- | --------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `rootDir`    | `string`               | Vite `root`     | Project root used to resolve `scanDirs` and `setupFile`.                                                          |
-| `scanDirs`   | `string[]`             | `['src']`       | Directories scanned (recursively) for `@Controller` and `@Injectable` classes.                                    |
-| `setupFile`  | `string`               | `undefined`     | Module whose default export `(app: App) => void \| Promise<void>` runs as `createApp`'s setup hook (before init). |
-| `runner`     | `string`               | `'node-worker'` | The `env-runner` runner used to execute server code in dev.                                                       |
-| `noExternal` | `(string \| RegExp)[]` | `undefined`     | Extra package patterns merged after `@vercube/*` for dev and production bundling (see below).                     |
+| Option       | Type                   | Default         | Description                                                                                                                                                                    |
+| ------------ | ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `rootDir`    | `string`               | Vite `root`     | Project root used to resolve `scanDirs` and `setupFile`.                                                                                                                       |
+| `scanDirs`   | `string[]`             | `['src']`       | Directories scanned (recursively) for `@Controller` and `@Injectable` classes.                                                                                                 |
+| `setupFile`  | `string`               | `undefined`     | Module whose default export `(app: App) => void \| Promise<void>` runs as `createApp`'s setup hook (before init).                                                              |
+| `appConfig`  | `ConfigTypes.Config`   | `undefined`     | App config passed to `createApp({ cfg })` in the generated entry, so it ships with the build instead of a `vercube.config` read at runtime. Plain data only (written as JSON). |
+| `runner`     | `string`               | `'node-worker'` | The `env-runner` runner used to execute server code in dev.                                                                                                                    |
+| `noExternal` | `(string \| RegExp)[]` | `undefined`     | Extra package patterns merged after `@vercube/*` for dev and production bundling (see below).                                                                                  |
 
 ### `noExternal`
 

package/dist/{context-sG04QQCS.mjs → context-D4q0XCl9.mjs}

@@ -1,15 +1,16 @@
-import { dirname, isAbsolute, resolve } from "pathe";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "pathe";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { scanSource } from "@vercube/scan";
 //#region src/entry.ts
 /**
 * Generates the source of the server entry module.
 *
-* The module creates a Vercube app, binds every auto-discovered controller and
-* service into its DI container, runs the optional setup file, flushes the
-* container queue (which registers routes via decorator initialization), and
-* exports the app's `fetch` handler. Imports and binds are deduplicated by class
-* name.
+* The module creates a Vercube app (with the plugin's `appConfig`, if any),
+* binds every auto-discovered controller and service into its DI container,
+* runs the optional setup file, flushes the container queue (which registers
+* routes via decorator initialization), and exports the app's `fetch` handler.
+* Imports and binds are deduplicated by class name.
 *
 * The entry is written to a real file rather than served as a `\0`-virtual
 * module: Vite resolves bare imports from virtual modules inconsistently with
@@ -31,7 +32,9 @@ function generateServerEntry(ctx) {
 	const setupBody = [];
 	if (ctx.setupFile) setupBody.push("  await __vercubeSetup__(app);");
 	if (ctx.hasClient) setupBody.push("  if (import.meta.main) {", "    const dir = fileURLToPath(new URL('./public', import.meta.url));", "    app.container.get(HttpServer).addPlugin(serveStaticFiles(dir));", "  }");
-	if (setupBody.length > 0) lines.push("const app = await createApp({ setup: async (app) => {", ...setupBody, "} });", "");
+	const cfg = ctx.pluginConfig.appConfig ? `cfg: ${JSON.stringify(ctx.pluginConfig.appConfig)}` : void 0;
+	if (setupBody.length > 0) lines.push(`const app = await createApp({ ${cfg ? `${cfg}, ` : ""}setup: async (app) => {`, ...setupBody, "} });", "");
+	else if (cfg) lines.push(`const app = await createApp({ ${cfg} });`, "");
 	else lines.push("const app = await createApp();", "");
 	lines.push(...[...imports.keys()].map((name) => `app.container.bind(${name});`), "");
 	lines.push("app.container.flushQueue();", "");
@@ -49,13 +52,61 @@ function generateServerEntry(ctx) {
 */
 function writeServerEntry(ctx) {
 	mkdirSync(dirname(ctx.serverEntry), { recursive: true });
-	writeFileSync(ctx.serverEntry, generateServerEntry(ctx), "utf8");
+	writeFileAtomic(ctx.serverEntry, generateServerEntry(ctx));
+	writeDiscoveryManifest(ctx);
+}
+/**
+* Writes a file through a temporary sibling that is renamed into place, so a
+* reader never observes it truncated. The worker can re-import the entry while a
+* rescan is rewriting it, when files are edited in quick succession.
+*
+* @param path - The destination path.
+* @param content - The file content.
+*/
+function writeFileAtomic(path, content) {
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, content, "utf8");
+	renameSync(tmp, path);
+}
+/**
+* Writes what the scanner found as JSON, next to the generated server entry.
+*
+* The server entry is executable code keyed only by class name: it discards the
+* file each class came from, the routes read out of the source and the HTTP
+* methods. That information exists at build time and is exactly what a runtime
+* inspector cannot recover, so it is persisted here and picked up by core's
+* `discovery` introspection section.
+*
+* @param ctx - The plugin context holding the discovery result.
+*/
+function writeDiscoveryManifest(ctx) {
+	const manifest = {
+		root: ctx.root,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		controllers: ctx.controllers.map((entry) => ({
+			name: entry.importClassName,
+			path: entry.path
+		})),
+		services: ctx.services.map((entry) => ({
+			name: entry.importClassName,
+			path: entry.path
+		})),
+		middlewares: (ctx.middlewares ?? []).map((entry) => ({
+			name: entry.importClassName,
+			path: entry.path
+		})),
+		routes: ctx.routes.map((route) => ({
+			method: route.method,
+			path: route.route,
+			controller: route.importClassName,
+			file: route.path
+		}))
+	};
+	writeFileAtomic(join(dirname(ctx.serverEntry), "discovery.json"), `${JSON.stringify(manifest, null, 2)}\n`);
 }
 //#endregion
 //#region src/context.ts
 const DEFAULT_SCAN_DIRS = ["src"];
-/** Location of the generated server entry, kept inside node_modules so it stays out of source control and file watchers. */
-const SERVER_ENTRY_REL = "node_modules/.vercube/server-entry.mjs";
 /** Build output directory (relative to root) for the frontend client, served by the built server in production. */
 const CLIENT_OUT_DIR = "dist/public";
 /**
@@ -71,12 +122,13 @@ function createContext(pluginConfig) {
 		pluginConfig,
 		root,
 		scanDirs: [],
-		serverEntry: resolve(root, SERVER_ENTRY_REL),
+		serverEntry: serverEntryPath(root),
 		dev: true,
 		hasClient: false,
 		controllers: [],
 		routes: [],
-		services: []
+		services: [],
+		middlewares: []
 	};
 }
 /**
@@ -89,7 +141,7 @@ function createContext(pluginConfig) {
 async function setupContext(ctx, options) {
 	ctx.root = ctx.pluginConfig.rootDir ? resolveFrom(options.root, ctx.pluginConfig.rootDir) : options.root;
 	ctx.dev = options.dev;
-	ctx.serverEntry = resolve(ctx.root, SERVER_ENTRY_REL);
+	ctx.serverEntry = serverEntryPath(ctx.root);
 	ctx.hasClient = existsSync(resolve(ctx.root, "index.html"));
 	ctx.scanDirs = (ctx.pluginConfig.scanDirs ?? DEFAULT_SCAN_DIRS).map((dir) => resolveFrom(ctx.root, dir));
 	ctx.setupFile = ctx.pluginConfig.setupFile ? resolveFrom(ctx.root, ctx.pluginConfig.setupFile) : void 0;
@@ -102,13 +154,31 @@ async function setupContext(ctx, options) {
 * @param ctx - The plugin context to refresh.
 */
 async function scanProject(ctx) {
-	const { controllers, routes, services } = await scanSource({ dirs: ctx.scanDirs });
+	const { controllers, routes, services, middlewares } = await scanSource({ dirs: ctx.scanDirs });
 	ctx.controllers = controllers;
 	ctx.routes = routes;
 	ctx.services = services;
+	ctx.middlewares = middlewares;
 	writeServerEntry(ctx);
 }
 /**
+* Location of the generated server entry, kept inside node_modules so it stays
+* out of source control and file watchers.
+*
+* The file name carries a hash of the project root. The entry imports discovered
+* classes by absolute path, so two dev servers reaching one checkout through
+* different paths (the host and a container with the project mounted at
+* `/var/www`) would otherwise overwrite each other's entry, and whichever reloads
+* next would import paths that do not exist on its side.
+*
+* @param root - The absolute project root.
+* @returns The absolute path of the server entry for that root.
+*/
+function serverEntryPath(root) {
+	const hash = createHash("sha256").update(root).digest("hex").slice(0, 8);
+	return resolve(root, `node_modules/.vercube/server-entry.${hash}.mjs`);
+}
+/**
 * Resolves `target` against `base` when it is relative, leaving absolute paths untouched.
 */
 function resolveFrom(base, target) {

package/dist/{dev-BH8qW7Zc.mjs → dev-D4kFrI6U.mjs}

@@ -1,4 +1,4 @@
-import { r as scanProject } from "./context-sG04QQCS.mjs";
+import { r as scanProject } from "./context-D4q0XCl9.mjs";
 import { t as VERCUBE_ENV } from "./types-Cpd32Lkt.mjs";
 import { createViteHotChannel } from "env-runner/vite";
 import { watch } from "chokidar";