@vercube/core 0.0.48 → 1.0.0-beta.1

package/dist/index.mjs

@@ -6,7 +6,7 @@ import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
 import { extname, join, normalize } from "node:path";
 import { BaseLogger, Logger } from "@vercube/logger";
-import { ConsoleProvider } from "@vercube/logger/drivers/ConsoleProvider";
+import { createMiddlewareLogger, extractSafeHeaders } from "@vercube/logger/toolkit";
 import { loadConfig, setupDotenv } from "c12";
 import { defu } from "defu";
 //#region src/Services/Config/RuntimeConfig.ts
@@ -336,12 +336,24 @@ var MetadataResolver = class {
 	* @public
 	*/
 	async resolveArgs(args, event) {
-		args.sort((a, b) => a.idx - b.idx);
-		const resolvedArgs = args.map(async (arg) => ({
-			...arg,
-			resolved: await this.resolveArg(arg, event)
-		}));
-		return await Promise.all(resolvedArgs);
+		let list = args;
+		if (args.length > 1) {
+			for (let i = 1; i < args.length; i++) if (args[i - 1].idx > args[i].idx) {
+				list = [...args].sort((a, b) => a.idx - b.idx);
+				break;
+			}
+		}
+		const resolvedArgs = [];
+		for (let i = 0; i < list.length; i++) {
+			const arg = list[i];
+			let resolved = this.resolveArg(arg, event);
+			if (resolved instanceof Promise) resolved = await resolved;
+			resolvedArgs.push({
+				...arg,
+				resolved
+			});
+		}
+		return resolvedArgs;
 	}
 	/**
 	* Resolves an argument for a given event.
@@ -523,7 +535,7 @@ var RequestContext = class {
 	}
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.130.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -559,7 +571,15 @@ var RequestHandler = class {
 		const method = this.gMetadataResolver.resolveMethod(prototype, propertyName);
 		const middlewares = this.gMetadataResolver.resolveMiddlewares(prototype, propertyName);
 		const globalMiddlewares = this.gGlobalMiddlewareRegistry.middlewares;
-		const resolvedMiddlewares = [...middlewares, ...globalMiddlewares].filter((m, index, self) => self.findIndex((t) => t.middleware === m.middleware) === index).map((m) => ({
+		const combined = [...middlewares, ...globalMiddlewares];
+		const seen = /* @__PURE__ */ new Set();
+		const uniqueMiddlewares = [];
+		for (const m of combined) {
+			if (seen.has(m.middleware)) continue;
+			seen.add(m.middleware);
+			uniqueMiddlewares.push(m);
+		}
+		const resolvedMiddlewares = uniqueMiddlewares.map((m) => ({
 			...m,
 			middleware: this.gContainer.resolve(m.middleware)
 		}));
@@ -570,7 +590,7 @@ var RequestHandler = class {
 		return {
 			instance,
 			propertyName,
-			args: method.args,
+			args: method.args.length <= 1 ? method.args : [...method.args].sort((a, b) => a.idx - b.idx),
 			middlewares: {
 				beforeMiddlewares,
 				afterMiddlewares
@@ -785,7 +805,7 @@ var RequestHandler = class {
 	async executeMiddlewares(middlewares, options) {
 		const { request, response, methodArgs, handlerResponse, executeRequest, executeResponse } = options;
 		let currentResponse = response;
-		for await (const hook of middlewares) try {
+		for (const hook of middlewares) try {
 			if (executeRequest) {
 				const requestResult = await this.executeMiddlewareRequest(hook, request, currentResponse, methodArgs);
 				if (requestResult instanceof Response) return {
@@ -1039,11 +1059,11 @@ var Router = class {
 	* @returns {RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined} The matched route or undefined if no match found
 	*/
 	resolve(route) {
-		let url = route.path;
-		try {
-			url = new URL(route.path).pathname;
+		let pathname = route.path;
+		if (/^https?:\/\//i.test(pathname)) try {
+			pathname = new URL(pathname).pathname;
 		} catch {}
-		return findRoute(this.fRouterContext, route.method.toUpperCase(), url);
+		return findRoute(this.fRouterContext, route.method.toUpperCase(), pathname);
 	}
 };
 __decorate([Inject(HooksService)], Router.prototype, "gHooksService", void 0);
@@ -1225,8 +1245,9 @@ var HttpServer = class {
 	*/
 	async handleRequest(request) {
 		try {
+			const pathname = new URL(request.url).pathname;
 			const route = this.gRouter.resolve({
-				path: request.url,
+				path: pathname,
 				method: request.method
 			});
 			if (!route && request.method === "OPTIONS") return this.gRequestHandler.handlePreflight(request);
@@ -1248,17 +1269,19 @@ __decorate([Inject(StaticRequestHandler)], HttpServer.prototype, "gStaticRequest
 //#endregion
 //#region src/Services/Plugins/BasePlugin.ts
 /**
-* Represents a Plugin.
+* Base class for class-based plugins registered via `defineConfig({ plugins })` or `app.addPlugin()`.
+*
+* @typeParam T - Options type passed into `configure`, `setup` / `use`, and `hooks` when provided.
 */
 var BasePlugin = class {
-	/**
-	* The name of the plugin.
-	*/
+	/** Stable identifier used by the plugin registry and logging. */
 	name;
 	/**
-	* Uses the plugin with the given app.
-	* @param {App} app - The application instance.
-	* @returns {void | Promise<void>} - A void or a promise that resolves to void.
+	* Legacy runtime attach when the plugin is not registered with a `setup` implementation.
+	*
+	* @param app - Running application instance.
+	* @param options - Optional plugin options from registration or config tuple.
+	* @returns Void or a promise that settles when attachment is done.
 	*/
 	use(app, options) {}
 };
@@ -1389,12 +1412,20 @@ var App = class {
 		return this.gHttpServer.handleRequest(request);
 	}
 	/**
-	* Resolves and initializes the plugins for the application.
+	* Initializes registry plugins, then runs `setup` on each normalized config plugin in order.
 	*
-	* @private
+	* @returns Resolves when all plugin `setup` hooks have been awaited.
 	*/
 	async resolvePlugins() {
 		await this.gPluginsRegistry.init(this);
+		const plugins = this.fConfig.plugins;
+		if (!plugins?.length) return;
+		const env = {
+			cwd: typeof process === "undefined" ? "." : process.cwd(),
+			dev: this.fConfig.dev,
+			production: this.fConfig.production
+		};
+		for (const plugin of plugins) await plugin.setup?.(this, env);
 	}
 };
 __decorate([Inject(Router)], App.prototype, "gRouter", void 0);
@@ -1403,6 +1434,68 @@ __decorate([Inject(HttpServer)], App.prototype, "gHttpServer", void 0);
 __decorate([Inject(StaticRequestHandler)], App.prototype, "gStaticRequestHandler", void 0);
 __decorate([Inject(RuntimeConfig)], App.prototype, "gRuntimeConfig", void 0);
 //#endregion
+//#region src/Middleware/EvlogMiddleware.ts
+/**
+* Key under which the request-scoped evlog logger is stored in {@link RequestContext}.
+*/
+const EVLOG_REQUEST_LOGGER_KEY = "evlog:requestLogger";
+/**
+* Key under which the evlog `finish` callback is stored in {@link RequestContext}.
+*/
+const EVLOG_FINISH_KEY = "evlog:finish";
+/**
+* Global middleware that emits one structured wide event per request using
+* evlog (https://evlog.dev).
+*
+* On each request it creates a request-scoped logger via evlog's toolkit and
+* stores it in {@link RequestContext} (so handlers can enrich the event), then
+* emits the accumulated wide event - including method, path, status and
+* duration - when the response is produced.
+*
+* Registered automatically by the framework; disable via `requestLogging: false`
+* in the application config.
+*/
+var EvlogMiddleware = class extends BaseMiddleware {
+	/**
+	* Request context used to carry the request-scoped logger across the lifecycle.
+	*/
+	gRequestContext;
+	/**
+	* Creates a request-scoped evlog logger and stores it in the request context.
+	*
+	* @param request - The incoming HTTP request
+	* @param _response - The current response (unused)
+	* @param args - Middleware options (evlog include/exclude/drain/enrich/keep)
+	*/
+	onRequest(request, _response, args) {
+		if (!this.gRequestContext) return;
+		const options = args?.middlewareArgs ?? {};
+		const url = new URL(request.url);
+		const { logger, finish, skipped } = createMiddlewareLogger({
+			method: request.method,
+			path: url.pathname,
+			requestId: request.headers.get("x-request-id") ?? crypto.randomUUID(),
+			headers: extractSafeHeaders(request.headers),
+			...options
+		});
+		if (skipped) return;
+		this.gRequestContext.set(EVLOG_REQUEST_LOGGER_KEY, logger);
+		this.gRequestContext.set(EVLOG_FINISH_KEY, finish);
+	}
+	/**
+	* Emits the request wide event with the final response status.
+	*
+	* @param _request - The HTTP request (unused)
+	* @param response - The final HTTP response
+	*/
+	async onResponse(_request, response) {
+		if (!this.gRequestContext) return;
+		const finish = this.gRequestContext.get(EVLOG_FINISH_KEY);
+		if (finish) await finish({ status: response.status }).catch(() => {});
+	}
+};
+__decorate([InjectOptional(RequestContext)], EvlogMiddleware.prototype, "gRequestContext", void 0);
+//#endregion
 //#region src/Errors/Http/InternalServerError.ts
 /**
 * Represents an Internal Server error (HTTP 500).
@@ -1488,13 +1581,7 @@ function createContainer(config) {
 	const container = new Container();
 	container.bindInstance(Container, container);
 	container.bind(Logger, BaseLogger);
-	container.get(Logger).configure({
-		logLevel: config.logLevel ?? "debug",
-		providers: [{
-			name: "console",
-			provider: ConsoleProvider
-		}]
-	});
+	container.get(Logger).configure({ logLevel: config.logLevel ?? "debug" });
 	container.bind(ErrorHandlerProvider, DefaultErrorHandlerProvider);
 	container.bind(HttpServer);
 	container.bind(StaticRequestHandler);
@@ -1507,9 +1594,212 @@ function createContainer(config) {
 	container.bind(GlobalMiddlewareRegistry);
 	container.bind(RequestContext);
 	container.bind(ValidationProvider, StandardSchemaValidationProvider);
+	if (config.requestLogging !== false) container.get(GlobalMiddlewareRegistry).registerGlobalMiddleware(EvlogMiddleware);
 	return container;
 }
 //#endregion
+//#region src/Plugins/VercubePlugin.ts
+/**
+* Tracks cleanup callbacks for plugin-registered dev hooks per hookable instance.
+* This prevents listener accumulation across config reloads in `vercube dev`.
+*/
+const pluginDevHookCleanupMap = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the same plugin object; narrows the type for object literals.
+*
+* @param plugin - Plugin definition with optional hooks.
+* @returns The input plugin unchanged.
+*/
+function defineVercubePlugin(plugin) {
+	return plugin;
+}
+/**
+* Builds a `[PluginClass, options]` tuple with options typed from the class `BasePlugin` generic.
+*
+* @param PluginClass - Constructor extending `BasePlugin<TOptions>`.
+* @param options - Options object matching `TOptions` for that class.
+* @returns Tuple consumed by the config `plugins` pipeline.
+*/
+function withPluginOptions(PluginClass, options) {
+	return [PluginClass, options];
+}
+/**
+* @param value - Any value to test.
+* @returns True if `value` is a constructor whose prototype extends `BasePlugin`.
+*/
+function isBasePluginClass(value) {
+	return typeof value === "function" && value.prototype instanceof BasePlugin;
+}
+/**
+* Adapts a `BasePlugin` subclass into a `VercubePlugin` for `defineConfig({ plugins })`.
+*
+* @param PluginClass - Plugin class constructor.
+* @param options - Optional value passed into `configure`, `setup` / `use`, and `hooks`.
+* @param displayName - Optional name; defaults to `PluginClass.name`.
+* @returns Object implementing `VercubePlugin` that delegates to the class.
+*/
+function vercubePluginFromClass(PluginClass, options, displayName) {
+	return {
+		name: displayName ?? PluginClass.name,
+		config: async (cfg, _env) => {
+			const sample = new PluginClass();
+			const configure = sample.configure;
+			if (typeof configure === "function") return configure.call(sample, cfg, options);
+		},
+		setup: async (app) => {
+			const instance = app.container.resolve(PluginClass);
+			if (typeof instance.setup === "function") return instance.setup.call(instance, app, options);
+			return instance.use(app, options);
+		},
+		cli: async (ctx) => {
+			const sample = new PluginClass();
+			if (typeof sample.setupCLI === "function") return sample.setupCLI.call(sample, ctx);
+		},
+		hooks: async (ctx) => {
+			const sample = new PluginClass();
+			if (typeof sample.hooks === "function") return sample.hooks.call(sample, ctx, options);
+		}
+	};
+}
+/**
+* Resolves async plugin factories and normalizes class entries into `VercubePlugin` objects.
+*
+* @param inputs - Raw `plugins` array from config, or undefined.
+* @returns Resolved plugins in source order (before `enforce` sorting elsewhere).
+* @throws {Error} If an array entry is neither `[Class]`, `[Class, options]`, nor a valid plugin shape.
+*/
+async function normalizeVercubePluginInputs(inputs) {
+	if (!inputs?.length) return [];
+	const out = [];
+	for (const entry of inputs) {
+		if (Array.isArray(entry)) {
+			if (entry.length > 0 && isBasePluginClass(entry[0])) {
+				out.push(vercubePluginFromClass(entry[0], entry[1]));
+				continue;
+			}
+			if (entry.length === 1) {
+				out.push(...await normalizeVercubePluginInputs([entry[0]]));
+				continue;
+			}
+			throw new Error("Invalid plugin entry: use a BasePlugin class, [Class, options?], a factory function, or a plugin object");
+		}
+		if (isBasePluginClass(entry)) {
+			out.push(vercubePluginFromClass(entry));
+			continue;
+		}
+		const resolved = typeof entry === "function" && !isBasePluginClass(entry) ? await entry() : await Promise.resolve(entry);
+		out.push(resolved);
+	}
+	return out;
+}
+/**
+* @param plugins - Resolved plugins in user list order.
+* @returns Same plugins reordered: `enforce: 'pre'`, then unspecified, then `enforce: 'post'`.
+*/
+function sortByEnforce(plugins) {
+	const pre = [];
+	const mid = [];
+	const post = [];
+	for (const p of plugins) if (p.enforce === "pre") pre.push(p);
+	else if (p.enforce === "post") post.push(p);
+	else mid.push(p);
+	return [
+		...pre,
+		...mid,
+		...post
+	];
+}
+/**
+* Runs each plugin's `config` hook (merge order), normalizes `plugins` to resolved objects, runs `cli` hooks, and merges registered commands into `config.cli.commands`.
+*
+* @param config - Full Vercube config (may contain raw plugin inputs).
+* @param env - Working directory and CLI context flags.
+* @returns Config with `plugins` normalized and CLI commands aggregated.
+*/
+async function applyVercubePluginHooks(config, env) {
+	const rawPlugins = config.plugins;
+	if (!rawPlugins?.length) return config;
+	const ordered = sortByEnforce(await normalizeVercubePluginInputs(rawPlugins));
+	let next = {
+		...config,
+		plugins: ordered
+	};
+	for (const plugin of ordered) {
+		const patch = await plugin.config?.(next, env);
+		if (patch && typeof patch === "object") {
+			const { plugins: _ignored, ...rest } = patch;
+			const merged = defu(next, rest);
+			merged.plugins = ordered;
+			next = merged;
+		}
+	}
+	const commands = [...next.cli?.commands ?? []];
+	const register = (...cmds) => {
+		commands.push(...cmds);
+	};
+	const cliCtx = {
+		cwd: env.cwd,
+		command: env.command,
+		config: next,
+		register
+	};
+	for (const plugin of ordered) await plugin.cli?.(cliCtx);
+	next = {
+		...next,
+		cli: {
+			...next.cli,
+			commands
+		}
+	};
+	return next;
+}
+/**
+* Invokes `hooks` on each resolved plugin (dev parent process only).
+*
+* @param plugins - Normalized plugins from config (after `applyVercubePluginHooks`).
+* @param ctx - Hooks context from devkit (`config`, `hooks`).
+* @returns Resolves when every plugin `hooks` call completes.
+*/
+async function invokeVercubePluginDevHooks(plugins, ctx) {
+	if (!plugins?.length) return;
+	const rawHooks = ctx.hooks;
+	if (!rawHooks || typeof rawHooks !== "object") {
+		for (const plugin of plugins) await plugin.hooks?.(ctx);
+		return;
+	}
+	const previousCleanup = pluginDevHookCleanupMap.get(rawHooks);
+	if (previousCleanup?.length) for (const dispose of previousCleanup) dispose();
+	const cleanup = [];
+	const trackedHooks = new Proxy(rawHooks, { get(target, prop, receiver) {
+		if (prop === "hook") return (name, handler, ...rest) => {
+			const result = Reflect.apply(target.hook, target, [
+				name,
+				handler,
+				...rest
+			]);
+			if (typeof result === "function") cleanup.push(result);
+			else if (typeof target.removeHook === "function") cleanup.push(() => {
+				target.removeHook(name, handler);
+			});
+			return result;
+		};
+		if (prop === "addHooks") return (hooksObject) => {
+			const result = Reflect.apply(target.addHooks, target, [hooksObject]);
+			if (typeof target.removeHooks === "function") cleanup.push(() => {
+				target.removeHooks(hooksObject);
+			});
+			return result;
+		};
+		return Reflect.get(target, prop, receiver);
+	} });
+	const nextCtx = {
+		...ctx,
+		hooks: trackedHooks
+	};
+	for (const plugin of plugins) await plugin.hooks?.(nextCtx);
+	pluginDevHookCleanupMap.set(rawHooks, cleanup);
+}
+//#endregion
 //#region src/Config/DefaultConfig.ts
 /**
 * Default configuration for the Vercube application.
@@ -1595,20 +1885,33 @@ const defaultConfig = {
 //#endregion
 //#region src/Config/Loader.ts
 /**
-* Loads the configuration object for the application
-* @param {ConfigTypes.Config} overrides - The configuration object to load
-* @returns {ConfigTypes.Config} The loaded configuration object
+* Loads and merges `vercube` config from disk, applies defaults, runs env setup, then the plugin `config` and `cli` pipeline.
+*
+* @param overrides - Values merged on top of file-based config (wins over file).
+* @param options - `cwd`, optional `import`, and `command` for plugin context.
+* @returns Fully merged config with normalized `plugins` and aggregated `cli.commands`.
 */
-async function loadVercubeConfig(overrides) {
+async function loadVercubeConfig(overrides, options) {
+	const cwd = options?.cwd ?? process.cwd();
 	const config = await loadConfig({
 		name: "vercube",
 		dotenv: overrides?.c12?.dotenv ?? true,
 		rcFile: false,
 		globalRc: false,
-		defaults: defaultConfig
+		defaults: defaultConfig,
+		cwd,
+		...options?.import ? { import: options.import } : {}
 	});
 	if (config?.config?.c12?.dotenv && typeof config?.config?.c12?.dotenv === "object") await setupDotenv(config.config.c12.dotenv);
-	return defu(overrides ?? {}, config?.config ?? {});
+	let merged = defu(overrides ?? {}, config?.config ?? {});
+	const env = {
+		cwd,
+		dev: merged.dev,
+		production: merged.production,
+		command: options?.command
+	};
+	merged = await applyVercubePluginHooks(merged, env);
+	return merged;
 }
 //#endregion
 //#region src/Common/CreateApp.ts
@@ -3244,4 +3547,4 @@ let HttpStatusCode = /* @__PURE__ */ function(HttpStatusCode) {
 	return HttpStatusCode;
 }({});
 //#endregion
-export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, DANGEROUS_PROPERTIES, Delete, ErrorHandlerProvider, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, HttpStatusCode, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, RequestContext, Response$1 as Response, Router, RuntimeConfig, SetHeader, StandardSchemaValidationProvider, Status, Trace, UnauthorizedError, ValidationProvider, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, isSafeProperty, loadVercubeConfig, safeAssign, safeJsonParse, sanitizeObject, secureReviver };
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, DANGEROUS_PROPERTIES, Delete, EVLOG_FINISH_KEY, EVLOG_REQUEST_LOGGER_KEY, ErrorHandlerProvider, EvlogMiddleware, FastResponse, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, HttpStatusCode, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, RequestContext, Response$1 as Response, Router, RuntimeConfig, SetHeader, StandardSchemaValidationProvider, Status, Trace, UnauthorizedError, ValidationProvider, applyVercubePluginHooks, createApp, createMetadataCtx, createMetadataMethod, defineConfig, defineVercubePlugin, initializeMetadata, initializeMetadataMethod, invokeVercubePluginDevHooks, isBasePluginClass, isSafeProperty, loadVercubeConfig, normalizeVercubePluginInputs, safeAssign, safeJsonParse, sanitizeObject, secureReviver, vercubePluginFromClass, withPluginOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/core",
-  "version": "0.0.48",
+  "version": "1.0.0-beta.1",
   "description": "Core module for Vercube framework",
   "repository": {
     "type": "git",
@@ -28,11 +28,11 @@
     "pathe": "2.0.3",
     "rou3": "0.8.1",
     "srvx": "0.11.16",
-    "@vercube/di": "0.0.48",
-    "@vercube/logger": "0.0.48"
+    "@vercube/logger": "1.0.0-beta.1",
+    "@vercube/di": "1.0.0-beta.1"
   },
   "devDependencies": {
-    "rolldown": "1.0.2",
+    "rolldown": "1.1.1",
     "zod": "4.4.3"
   },
   "publishConfig": {