@vercube/core 0.0.1-alpha.15

package/dist/index.mjs

@@ -0,0 +1,1944 @@
+import { BaseDecorator, Container, Inject, InjectOptional, createDecorator, initializeContainer } from "@vercube/di";
+import { serve } from "srvx";
+import { addRoute, createRouter, findRoute } from "rou3";
+import { createReadStream } from "node:fs";
+import { extname, join, normalize } from "node:path";
+import { stat } from "node:fs/promises";
+import { BaseLogger, Logger } from "@vercube/logger";
+import { loadConfig } from "c12";
+import { defu } from "defu";
+
+//#region node_modules/.pnpm/@oxc-project+runtime@0.62.0/node_modules/@oxc-project/runtime/src/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);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region packages/core/src/Services/Plugins/PluginsRegistry.ts
+var PluginsRegistry = class {
+	gContainer;
+	/** Holds the list of plugins */
+	fPlugins = new Map();
+	/**
+	* Registers a plugin.
+	*
+	* @param {Plugin} plugin - The plugin to register.
+	* @param {unknown} options - The options to pass to the plugin.
+	*/
+	register(plugin, options) {
+		const instance = this.gContainer.resolve(plugin);
+		this.fPlugins.set(instance.name, {
+			instance,
+			options
+		});
+	}
+	/**
+	* Gets the list of registered plugins.
+	*
+	* @returns {Plugin[]} The list of registered plugins.
+	*/
+	get plugins() {
+		return [...this.fPlugins.values()].map((plugin) => plugin.instance);
+	}
+	/**
+	* Resolves the plugins.
+	*
+	* @param {App} app - The application instance.
+	*/
+	async init(app) {
+		for (const { instance, options } of this.fPlugins.values()) await instance.use(app, options);
+	}
+};
+__decorate([Inject(Container)], PluginsRegistry.prototype, "gContainer", void 0);
+
+//#endregion
+//#region packages/core/src/Services/Hooks/HooksService.ts
+var HooksService = class {
+	fLastId = 0;
+	fHandlers = new Map();
+	/**
+	* Registers listener for event of particular type. Everytime event is called, the listener
+	* will be executed.
+	*
+	* @param type type of event, simple class
+	* @param callback callback fired when event is triggered
+	* @returns unique ID for event listener, can be used to disable this listener
+	*/
+	on(type, callback) {
+		let handlersOfType = this.fHandlers.get(type);
+		if (!handlersOfType) {
+			handlersOfType = [];
+			this.fHandlers.set(type, handlersOfType);
+		}
+		const genId = this.fLastId++;
+		const handler = {
+			callback,
+			id: genId
+		};
+		handlersOfType.push(handler);
+		return {
+			__id: genId,
+			__type: type
+		};
+	}
+	/**
+	* Waits for single event execution and removes the listener immediately after.
+	*
+	* @example
+	* this.gCart.addItem(product);
+	* await this.gEvents.waitFor(CartUpdatedEvent);
+	* console.log('here cart updated event is already called');
+	*
+	* @param type type of event to wait for
+	* @param timeout timeout param in ms - if event is not thrown until this time, it'll reject. passing null disables the timeout
+	* @returns promise with event data that resolves when event is finally called
+	*/
+	waitFor(type, timeout = 10 * 1e3) {
+		return new Promise((resolve, reject) => {
+			let waitTimeout;
+			const eventId = this.on(type, (data) => {
+				this.off(eventId);
+				resolve(data);
+				if (waitTimeout) clearTimeout(waitTimeout);
+			});
+			if (timeout !== null) waitTimeout = setTimeout(() => {
+				this.off(eventId);
+				reject(new Error(`Waiting for event timeout - ${type.name}`));
+			}, timeout);
+		});
+	}
+	/**
+	* Removes listener from particular event.
+	* @param eventId eventId returned from .on() method.
+	* @throws Error if event was not registered
+	*/
+	off(eventId) {
+		const type = eventId.__type;
+		const handlersOfType = this.fHandlers.get(type);
+		if (!handlersOfType) throw new Error("Trying to unbind event that was not bound.");
+		const index = handlersOfType.findIndex((handler) => handler.id === eventId.__id);
+		if (index === -1) throw new Error("Trying to unbind event that was not bound.");
+		handlersOfType.splice(index, 1);
+	}
+	/**
+	* Triggers event, calling all listener callbacks. Will return Promise of number,
+	* that is resolved when all asynchronous listeners are called.
+	* @param type type of trigger, simple class
+	* @param data data which will be passed to listeners, based on event class
+	* @return number of listeners that were notified
+	*/
+	async trigger(type, data) {
+		const handlersOfType = this.fHandlers.get(type);
+		if (!handlersOfType) return 0;
+		const toProcessHandlers = [...handlersOfType];
+		const promises = toProcessHandlers.map((handler) => {
+			const instance = this.objectToClass(type, data);
+			const result = handler.callback(instance);
+			return result instanceof Promise ? result : Promise.resolve();
+		});
+		await Promise.all(promises);
+		return toProcessHandlers.length;
+	}
+	/**
+	* Converts plain object to it's class equivalent.
+	* It's NOT class-transformer, it performs basic key assigment.
+	*
+	* @param ClassConstructor event constructor
+	* @param data event data to be mapped to constructor
+	* @return class type of event
+	*/
+	objectToClass(ClassConstructor, data) {
+		const instance = new ClassConstructor();
+		if (data) for (const key of Object.keys(data)) {
+			const rawInstance = instance;
+			const rawData = data;
+			rawInstance[key] = rawData[key];
+		}
+		return instance;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Hooks/Router/RouterBeforeInitHook.ts
+var RouterBeforeInitHook = class {};
+
+//#endregion
+//#region packages/core/src/Hooks/Router/RouterAfterInitHook.ts
+var RouterAfterInitHook = class {};
+
+//#endregion
+//#region packages/core/src/Services/Router/Router.ts
+var Router = class {
+	/**
+	* Service for triggering application hooks
+	*/
+	gHooksService;
+	/**
+	* Internal router context that stores all registered routes
+	* @private
+	*/
+	fRouterContext;
+	/**
+	* Registers a new route in the router
+	* 
+	* @param {RouterTypes.Route} route - The route configuration to add
+	* @throws {Error} If router is not initialized
+	*/
+	addRoute(route) {
+		if (!this.fRouterContext) throw new Error("Router not initialized. Please call init() before adding routes.");
+		addRoute(this.fRouterContext, route.method.toUpperCase(), route.path, route.handler);
+	}
+	/**
+	* Initializes the router and triggers related hooks
+	* 
+	* This method creates a new router context and triggers
+	* the before and after initialization hooks.
+	*/
+	init() {
+		this.gHooksService.trigger(RouterBeforeInitHook);
+		this.fRouterContext = createRouter();
+		this.gHooksService.trigger(RouterAfterInitHook);
+	}
+	/**
+	* Resolves a route based on the HTTP method and path
+	* 
+	* @param {RouterTypes.RouteFind} route - The route to resolve
+	* @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;
+		} catch {}
+		return findRoute(this.fRouterContext, route.method.toUpperCase(), url);
+	}
+};
+__decorate([Inject(HooksService)], Router.prototype, "gHooksService", void 0);
+
+//#endregion
+//#region packages/core/src/Resolvers/RouterParam.ts
+function resolveRouterParam(param, event) {
+	return event.params?.[param] ?? null;
+}
+
+//#endregion
+//#region packages/core/src/Errors/HttpError.ts
+var HttpError = class HttpError extends Error {
+	/**
+	* The HTTP status code associated with the error.
+	* @type {number}
+	*/
+	status;
+	/**
+	* Creates an instance of HttpError.
+	* @param {number} status - The HTTP status code.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(status, message) {
+		super();
+		Object.setPrototypeOf(this, HttpError.prototype);
+		if (status) this.status = status;
+		if (message) this.message = message;
+		this.stack = new Error().stack;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/BadRequestError.ts
+var BadRequestError = class BadRequestError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "BadRequestError";
+	/**
+	* Creates an instance of BadRequestError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message, errors) {
+		super(400);
+		Object.setPrototypeOf(this, BadRequestError.prototype);
+		if (message) this.message = message;
+		if (errors) this.errors = errors;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Resolvers/Body.ts
+async function resolveRequestBody(event) {
+	const text = await event.request.text();
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new BadRequestError("Invalid JSON body");
+	}
+}
+
+//#endregion
+//#region packages/core/src/Resolvers/Query.ts
+function resolveQueryParam(name, event) {
+	const url = new URL(event.request.url);
+	return url.searchParams.get(name);
+}
+function resolveQueryParams(event) {
+	const url = new URL(event.request.url);
+	const params = {};
+	for (const [key, value] of url.searchParams) params[key] = value;
+	return params;
+}
+
+//#endregion
+//#region packages/core/src/Resolvers/Headers.ts
+function getRequestHeader(header, event) {
+	return event.request.headers.get(header);
+}
+function getRequestHeaders(event) {
+	return event.request.headers;
+}
+
+//#endregion
+//#region packages/core/src/Services/Metadata/MetadataResolver.ts
+var MetadataResolver = class {
+	/**
+	* Resolves the URL for a given instance and path.
+	*
+	* @param {MetadataTypes.ResolveUrlParams} params - The parameters for resolving the URL.
+	* @return {string} The resolved URL.
+	*/
+	resolveUrl(params) {
+		const { instance, propertyName, path: rawPath } = params;
+		const metadata = instance.__metadata;
+		const basePath = (metadata?.__controller?.path ?? "").replace(/\/$/, "");
+		const cleanPath = rawPath.replace(/^\//, "");
+		const url = `${basePath}/${cleanPath}`;
+		metadata.__methods[propertyName].url = url;
+		return url;
+	}
+	resolveMethod(ctx, propertyName) {
+		return ctx.__metadata.__methods[propertyName];
+	}
+	/**
+	* Resolves arguments for a given event.
+	*
+	* @param {MetadataTypes.Arg[]} args - The arguments to resolve.
+	* @param {RouterTypes.RouterEvent} event - The event to resolve arguments for.
+	* @return {unknown[]} The resolved arguments.
+	* @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);
+	}
+	/**
+	* Resolves an argument for a given event.
+	*
+	* @param {MetadataTypes.Arg} arg - The argument to resolve.
+	* 
+	* @return {unknown} The resolved argument.
+	* @private
+	*/
+	resolveArg(arg, event) {
+		switch (arg.type) {
+			case "param": return resolveRouterParam(arg?.data?.name ?? "", event);
+			case "body": return resolveRequestBody(event);
+			case "multipart-form-data": return null;
+			case "query-param": return resolveQueryParam(arg?.data?.name ?? "", event);
+			case "query-params": return resolveQueryParams(event);
+			case "header": return getRequestHeader(arg.data?.name ?? "", event);
+			case "headers": return getRequestHeaders(event);
+			case "request": return event.request;
+			case "response": return event.response;
+			case "session": return null;
+			default: throw new Error(`Unknown argument type: ${arg.type}`);
+		}
+	}
+	/**
+	* Resolves middleware functions for a given context and property name.
+	*
+	* @param {MetadataTypes.Ctx} ctx - The metadata context object
+	* @param {string} propertyName - The name of the property to resolve middlewares for
+	* @returns {MetadataTypes.Middleware[]} Array of middleware functions that apply globally or to the specific property
+	* @public
+	*/
+	resolveMiddlewares(ctx, propertyName) {
+		const middlewares = ctx?.__metadata?.__middlewares?.filter((m) => m.target === "__global__" || m.target === propertyName) ?? [];
+		return middlewares.sort((a) => a.target === "__global__" ? -1 : 1);
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/ErrorHandler/ErrorHandlerProvider.ts
+var ErrorHandlerProvider = class {};
+
+//#endregion
+//#region packages/core/src/Services/Middleware/GlobalMiddlewareRegistry.ts
+var GlobalMiddlewareRegistry = class {
+	fMiddlewares = new Set();
+	/**
+	* Retrieves all registered global middleware configurations
+	* 
+	* @returns {MetadataTypes.Middleware[]} An array of middleware configurations
+	*/
+	get middlewares() {
+		return [...this.fMiddlewares.values()].map((m) => ({
+			...m.opts,
+			target: "__global__",
+			middleware: m.middleware
+		}));
+	}
+	/**
+	* Registers a global middleware configuration
+	* 
+	* @param {typeof BaseMiddleware<T, U>} middleware - The middleware class to register
+	* @param {GlobalMiddlewareParams<T>} opts - The middleware options
+	* @returns {void}
+	*/
+	registerGlobalMiddleware(middleware, opts) {
+		this.fMiddlewares.add({
+			middleware,
+			opts
+		});
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/Router/RequestHandler.ts
+var RequestHandler = class {
+	/** Resolver for extracting metadata from controller classes and methods */
+	gMetadataResolver;
+	/** DI container for resolving dependencies */
+	gContainer;
+	/** Provider for handling errors during request processing */
+	gErrorHandlerProvider;
+	gGlobalMiddlewareRegistry;
+	/**
+	* Prepares a route handler by resolving its metadata and middlewares
+	* 
+	* @param {RequestHandlerOptions} params - Configuration options for the handler
+	* @returns {RouterTypes.RouterHandler} A prepared handler with resolved metadata and middlewares
+	*/
+	prepareHandler(params) {
+		const { instance, propertyName } = params;
+		const prototype = Object.getPrototypeOf(instance);
+		const method = this.gMetadataResolver.resolveMethod(prototype, propertyName);
+		const middlewares = this.gMetadataResolver.resolveMiddlewares(prototype, propertyName);
+		const globalMiddlewares = this.gGlobalMiddlewareRegistry.middlewares;
+		const uniqueMiddlewares = [...middlewares, ...globalMiddlewares].filter((m, index, self) => self.findIndex((t) => t.middleware === m.middleware) === index);
+		const resolvedMiddlewares = uniqueMiddlewares.map((m) => ({
+			...m,
+			middleware: this.gContainer.resolve(m.middleware)
+		}));
+		const beforeMiddlewares = resolvedMiddlewares.filter((m) => !!m.middleware.onRequest);
+		const afterMiddlewares = resolvedMiddlewares.filter((m) => !!m.middleware.onResponse);
+		beforeMiddlewares.sort((a, b) => (a?.priority ?? 999) - (b?.priority ?? 999));
+		afterMiddlewares.sort((a, b) => (a?.priority ?? 999) - (b?.priority ?? 999));
+		return {
+			instance,
+			propertyName,
+			args: method.args,
+			middlewares: {
+				beforeMiddlewares,
+				afterMiddlewares
+			},
+			actions: method.actions
+		};
+	}
+	/**
+	* Processes an HTTP request through the middleware chain and route handler
+	* 
+	* The request handling lifecycle:
+	* 1. Execute "before" middlewares
+	* 2. Apply route actions (status codes, redirects, etc.)
+	* 3. Resolve handler arguments
+	* 4. Execute the route handler
+	* 5. Execute "after" middlewares
+	* 6. Format and return the final response
+	* 
+	* @param {Request} request - The incoming HTTP request
+	* @param {RouterTypes.RouteMatched<RouterTypes.RouterHandler>} route - The matched route with handler data
+	* @returns {Promise<Response>} The HTTP response
+	*/
+	async handleRequest(request, route) {
+		try {
+			const { instance, propertyName, actions, args, middlewares } = route.data;
+			let fakeResponse = new Response(void 0, { headers: { "Content-Type": request.headers.get("Content-Type") ?? "application/json" } });
+			for await (const hook of middlewares?.beforeMiddlewares ?? []) try {
+				const hookResponse = await hook.middleware.onRequest?.(request, fakeResponse, {
+					middlewareArgs: hook.args,
+					methodArgs: args
+				});
+				if (hookResponse instanceof Response) return hookResponse;
+			} catch (error) {
+				return this.gErrorHandlerProvider.handleError(error);
+			}
+			for (const action of actions) {
+				const actionResponse = action.handler(request, fakeResponse);
+				if (actionResponse !== null) fakeResponse = this.processOverrideResponse(actionResponse, fakeResponse);
+			}
+			const resolvedArgs = await this.gMetadataResolver.resolveArgs(args, {
+				...route,
+				request,
+				response: fakeResponse
+			});
+			let handlerResponse = instance[propertyName].call(instance, ...resolvedArgs?.map((a) => a.resolved) ?? []);
+			if (handlerResponse instanceof Promise) handlerResponse = await handlerResponse;
+			for await (const hook of middlewares?.afterMiddlewares ?? []) try {
+				const hookResponse = await hook.middleware.onResponse?.(request, fakeResponse, handlerResponse);
+				if (hookResponse !== null) fakeResponse = this.processOverrideResponse(hookResponse, fakeResponse);
+			} catch (error) {
+				return this.gErrorHandlerProvider.handleError(error);
+			}
+			const body = fakeResponse?.body ?? JSON.stringify(handlerResponse);
+			return new Response(body, {
+				status: fakeResponse.status,
+				statusText: fakeResponse.statusText,
+				headers: fakeResponse.headers
+			});
+		} catch (error_) {
+			return this.gErrorHandlerProvider.handleError(error_);
+		}
+	}
+	/**
+	* Processes and merges response overrides from middlewares or actions
+	* 
+	* This method handles different response formats:
+	* - If a full Response object is provided, it's used directly
+	* - If ResponseInit is provided, it's merged with the base response
+	* 
+	* @param {Response | ResponseInit} response - The response or response options to apply
+	* @param {Response} [base] - The base response to extend (optional)
+	* @returns {Response} The processed response with applied overrides
+	* @private
+	*/
+	processOverrideResponse(response, base) {
+		let fakeResponse = base ?? new Response();
+		if (response != null && response instanceof Response) return response;
+		else if (response !== null) {
+			const responseInit = response;
+			fakeResponse = new Response(void 0, {
+				status: responseInit?.status ?? fakeResponse.status,
+				headers: responseInit?.headers ?? fakeResponse.headers,
+				statusText: responseInit?.statusText ?? fakeResponse.statusText
+			});
+		}
+		return fakeResponse;
+	}
+};
+__decorate([Inject(MetadataResolver)], RequestHandler.prototype, "gMetadataResolver", void 0);
+__decorate([Inject(Container)], RequestHandler.prototype, "gContainer", void 0);
+__decorate([Inject(ErrorHandlerProvider)], RequestHandler.prototype, "gErrorHandlerProvider", void 0);
+__decorate([Inject(GlobalMiddlewareRegistry)], RequestHandler.prototype, "gGlobalMiddlewareRegistry", void 0);
+
+//#endregion
+//#region packages/core/src/Utils/Mine.ts
+const mime = { getType(ext) {
+	const types = {
+		".html": "text/html",
+		".css": "text/css",
+		".js": "application/javascript",
+		".json": "application/json",
+		".png": "image/png",
+		".jpg": "image/jpeg",
+		".jpeg": "image/jpeg",
+		".gif": "image/gif",
+		".svg": "image/svg+xml",
+		".ico": "image/x-icon"
+	};
+	return types[ext] || null;
+} };
+
+//#endregion
+//#region packages/core/src/Services/Router/StaticRequestHandler.ts
+var StaticRequestHandler = class {
+	/**
+	* The options for the static server
+	*/
+	fOptions;
+	/**
+	* Initializes the static server with the given options
+	* 
+	* @param {ConfigTypes.ServerOptions['static']} options - The options for the static server
+	* @returns {void}
+	*/
+	initialize(options) {
+		this.fOptions = options;
+	}
+	/**
+	* Handles HTTP requests for static files
+	* 
+	* @param {Request} request - The incoming HTTP request
+	* @returns {Promise<void | Response>} A promise that resolves to void or a Response object
+	*/
+	async handleRequest(request) {
+		const dirs = this.fOptions?.dirs ?? [];
+		if (!dirs) return;
+		if (request.method !== "GET") return;
+		const url = new URL(request.url);
+		const path = normalize(url.pathname);
+		let relativePath = path;
+		for (const dir of dirs) relativePath = relativePath.replace(dir, "");
+		for (const dir of dirs) {
+			const fullPath = join(process.cwd(), dir, relativePath);
+			try {
+				const stats = await stat(fullPath);
+				if (stats.isDirectory()) continue;
+				if (stats.isFile()) return this.serveFile(fullPath, stats);
+			} catch {
+				continue;
+			}
+		}
+	}
+	/**
+	* Serves a static file and returns a Response object
+	* 
+	* @param {string} path - The path to the file to serve
+	* @param {any} stats - The stats object for the file
+	* @returns {Promise<Response>} A promise that resolves to a Response object
+	*/
+	async serveFile(path, stats) {
+		const headers = new Headers();
+		const ext = extname(path).toLowerCase();
+		const contentType = mime.getType(ext) || "application/octet-stream";
+		headers.set("Content-Type", contentType);
+		headers.set("Content-Length", stats.size.toString());
+		if (this.fOptions?.maxAge && this.fOptions.maxAge > 0) {
+			const directives = ["public", `max-age=${this.fOptions.maxAge}`];
+			if (this.fOptions?.immutable) directives.push("immutable");
+			headers.set("Cache-Control", directives.join(", "));
+		}
+		if (this.fOptions?.etag) headers.set("ETag", `W/"${stats.size}-${stats.mtime.getTime()}"`);
+		const stream = createReadStream(path);
+		return new Response(stream, { headers });
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/HttpServer/HttpServer.ts
+var HttpServer = class {
+	/**
+	* Router service for resolving routes
+	*/
+	gRouter;
+	/**
+	* Handler for processing HTTP requests
+	*/
+	gRequestHandler;
+	/**
+	* Error handler provider for managing error responses
+	*/
+	gErrorHandlerProvider;
+	/**
+	* Static server for serving static files
+	*/
+	gStaticRequestHandler;
+	/**
+	* Underlying server instance
+	* @private
+	*/
+	fServer;
+	/**
+	* Initializes the HTTP server and starts listening for requests
+	* 
+	* @returns {Promise<void>} A promise that resolves when the server is ready
+	*/
+	async initialize(config) {
+		const { port, host } = config.server ?? {};
+		this.fServer = serve({
+			bun: { error: (error) => {
+				return this.gErrorHandlerProvider.handleError(error);
+			} },
+			deno: { onError: (error) => {
+				return this.gErrorHandlerProvider.handleError(error);
+			} },
+			hostname: host,
+			port,
+			fetch: this.handleRequest.bind(this)
+		});
+		await this.fServer.ready();
+	}
+	/**
+	* Processes an incoming HTTP request
+	* 
+	* This method:
+	* 1. Resolves the route for the request
+	* 2. Returns a 404 response if no route is found
+	* 3. Delegates to the request handler for matched routes
+	* 
+	* @param {Request} request - The incoming HTTP request
+	* @returns {Promise<Response>} The HTTP response
+	* @private
+	*/
+	async handleRequest(request) {
+		try {
+			const route = this.gRouter.resolve({
+				path: request.url,
+				method: request.method
+			});
+			if (!route) {
+				const response = await this.gStaticRequestHandler.handleRequest(request);
+				if (response) return response;
+				else throw new NotFoundError("Route not found");
+			}
+			return this.gRequestHandler.handleRequest(request, route);
+		} catch (error) {
+			return this.gErrorHandlerProvider.handleError(error);
+		}
+	}
+};
+__decorate([Inject(Router)], HttpServer.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], HttpServer.prototype, "gRequestHandler", void 0);
+__decorate([Inject(ErrorHandlerProvider)], HttpServer.prototype, "gErrorHandlerProvider", void 0);
+__decorate([Inject(StaticRequestHandler)], HttpServer.prototype, "gStaticRequestHandler", void 0);
+
+//#endregion
+//#region packages/core/src/Common/App.ts
+var App = class {
+	gRouter;
+	gPluginsRegistry;
+	gHttpServer;
+	gStaticRequestHandler;
+	/** Holds the initialization status of the application */
+	fIsInitialized = false;
+	/** Holds the dependency injection container */
+	fInternalContainer;
+	/** Hold app config */
+	fConfig;
+	/**
+	* Gets the dependency injection container.
+	*
+	* @returns {Container} The dependency injection container.
+	*/
+	get container() {
+		return this.fInternalContainer;
+	}
+	/**
+	* Sets the dependency injection container.
+	*
+	* @param {Container} container - The dependency injection container.
+	*/
+	set container(container) {
+		this.fInternalContainer = container;
+	}
+	/**
+	* Initializes the application.
+	*
+	* @returns {Promise<void>} A promise that resolves when the application is initialized.
+	*/
+	async init(cfg) {
+		this.fConfig = cfg;
+		await this.gHttpServer.initialize(this.fConfig);
+		if (this.fConfig.server?.static) this.gStaticRequestHandler.initialize(this.fConfig.server?.static);
+		this.gRouter.init();
+	}
+	/**
+	* Registers a plugin.
+	*
+	* @param {typeof Plugin} plugin - The plugin to register.
+	* @param {unknown} options - The options to pass to the plugin.
+	*/
+	registerPlugin(plugin, options) {
+		this.gPluginsRegistry.register(plugin, options);
+	}
+	/**
+	* Starts the application and begins listening for incoming requests.
+	*
+	* @returns {Promise<void>} A promise that resolves when the application starts listening.
+	* @throws {Error} If the application is already initialized.
+	*/
+	async listen() {
+		if (this.fIsInitialized) throw new Error("App is already initialized");
+		await this.resolvePlugins();
+		initializeContainer(this.container);
+	}
+	/**
+	* Resolves and initializes the plugins for the application.
+	*
+	* @private
+	*/
+	async resolvePlugins() {
+		await this.gPluginsRegistry.init(this);
+	}
+};
+__decorate([Inject(Router)], App.prototype, "gRouter", void 0);
+__decorate([Inject(PluginsRegistry)], App.prototype, "gPluginsRegistry", void 0);
+__decorate([Inject(HttpServer)], App.prototype, "gHttpServer", void 0);
+__decorate([Inject(StaticRequestHandler)], App.prototype, "gStaticRequestHandler", void 0);
+
+//#endregion
+//#region packages/logger/dist/Providers/index.mjs
+var LoggerProvider = class {};
+const isColorAllowed = () => !process.env.NO_COLOR;
+const colorIfAllowed = (colorFn) => {
+	const wrappedFn = (text) => {
+		return isColorAllowed() ? colorFn(text) : text;
+	};
+	return wrappedFn;
+};
+const colors = {
+	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
+};
+const LOG_LEVEL_COLORS = {
+	debug: colors.green,
+	info: colors.bold,
+	warn: colors.yellow,
+	error: colors.red
+};
+var ConsoleProvider = class extends LoggerProvider {
+	/**
+	* Initializes the appender with the provided options.
+	* This method should be called before using the appender to process messages.
+	*/
+	initialize() {}
+	/**
+	* Prints a log message according to the specified format and level.
+	* @param message - The log message object containing level, tag, and arguments
+	* @protected
+	*/
+	processMessage(message) {
+		const date = message.timestamp ? new Date(message.timestamp) : new Date();
+		console[message.level](`%s%s${message?.tag ? "%s" : ""} %s`, LOG_LEVEL_COLORS[message.level](`[${date.toISOString().split("T")[1]?.replace("Z", "")}]`), LOG_LEVEL_COLORS[message.level](`[${message.level.toUpperCase().padEnd(5, " ")}]`), message?.tag ? LOG_LEVEL_COLORS[message.level](`[${message.tag}]`) : "", ...message.args);
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/Validation/ValidationProvider.ts
+var ValidationProvider = class {};
+
+//#endregion
+//#region packages/core/src/Services/Validation/StandardSchemaValidationProvider.ts
+var StandardSchemaValidationProvider = class {
+	/**
+	* Validates data against a schema
+	* @param {ValidationTypes.Schema} schema - The schema to validate against
+	* @param {ValidationTypes.Input} data - The data to validate
+	* @return {ValidationTypes.Result | Promise<ValidationTypes.Result>} The validation result
+	*/
+	validate(schema, data) {
+		return schema["~standard"].validate(data);
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/Config/RuntimeConfig.ts
+var RuntimeConfig = class {
+	/**
+	* Private field to store the runtime configuration object.
+	* @private
+	*/
+	fRuntimeConfig;
+	/**
+	* Gets the current runtime configuration.
+	* @returns {ConfigTypes.RuntimeConfig} The current runtime configuration object.
+	*/
+	get runtimeConfig() {
+		return this.fRuntimeConfig;
+	}
+	/**
+	* Sets the runtime configuration.
+	* @param {ConfigTypes.RuntimeConfig} value - The new runtime configuration object to set.
+	*/
+	set runtimeConfig(value) {
+		this.fRuntimeConfig = value;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/InternalServerError.ts
+var InternalServerError = class InternalServerError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "InternalServerError";
+	/**
+	* Creates an instance of InternalServerError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(500);
+		Object.setPrototypeOf(this, InternalServerError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Services/ErrorHandler/DefaultErrorHandlerProvider.ts
+var DefaultErrorHandlerProvider = class extends ErrorHandlerProvider {
+	gLogger;
+	/**
+	* Handles an error that occurred during request processing
+	* 
+	* @param error - The Error object containing error details
+	* @returns Promise<Response> | Response - The response to be sent to the client
+	*/
+	handleError(error) {
+		const _internalError = new InternalServerError();
+		const status = error?.status ?? 500;
+		if (error instanceof HttpError) return new Response(JSON.stringify({ ...error }, void 0, 2), { status });
+		this.gLogger.error(error);
+		return new Response(JSON.stringify({ ...error?.cause ?? _internalError.cause }, void 0, 2), { status });
+	}
+};
+__decorate([Inject(Logger)], DefaultErrorHandlerProvider.prototype, "gLogger", void 0);
+
+//#endregion
+//#region packages/core/src/Common/Container.ts
+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.bind(ErrorHandlerProvider, DefaultErrorHandlerProvider);
+	container.bind(HttpServer);
+	container.bind(StaticRequestHandler);
+	container.bind(Router);
+	container.bind(HooksService);
+	container.bind(MetadataResolver);
+	container.bind(PluginsRegistry);
+	container.bind(RequestHandler);
+	container.bind(RuntimeConfig);
+	container.bind(GlobalMiddlewareRegistry);
+	container.bind(ValidationProvider, StandardSchemaValidationProvider);
+	return container;
+}
+
+//#endregion
+//#region packages/core/src/Utils/InternalUtils.ts
+function generateRandomHash() {
+	const hashByPerformance = Math.floor(Date.now() * 1e3).toString(16);
+	const hashByMath = () => (Math.floor(Math.random() * 16777215) | 1048576).toString(16);
+	return `${hashByPerformance}-${hashByMath()}-${hashByMath()}-${hashByMath()}`;
+}
+
+//#endregion
+//#region packages/core/src/Config/DefaultConfig.ts
+const defaultConfig = {
+	logLevel: "debug",
+	production: false,
+	dev: false,
+	build: {
+		root: process.cwd(),
+		entry: "src/index.ts",
+		output: {
+			dir: "dist",
+			publicDir: "public"
+		},
+		bundler: "rolldown"
+	},
+	server: {
+		runtime: "node",
+		host: "localhost",
+		port: 3e3,
+		https: false,
+		static: { dirs: ["public"] }
+	},
+	experimental: {},
+	runtime: { session: {
+		secret: process.env?.SECRET ?? generateRandomHash(),
+		name: "vercube_session",
+		duration: 60 * 60 * 24 * 7
+	} }
+};
+
+//#endregion
+//#region packages/core/src/Config/Loader.ts
+async function loadVercubeConfig(overrides) {
+	const config = await loadConfig({
+		name: "vercube",
+		dotenv: true,
+		rcFile: false,
+		globalRc: false,
+		defaults: defaultConfig
+	});
+	return defu(overrides ?? {}, config?.config ?? {});
+}
+
+//#endregion
+//#region packages/core/src/Common/CreateApp.ts
+async function createApp(cfg) {
+	const config = await loadVercubeConfig(cfg);
+	const container = createContainer(config);
+	const app = container.resolve(App);
+	container.get(RuntimeConfig).runtimeConfig = config?.runtime ?? {};
+	app.container = container;
+	await app.init(config);
+	initializeContainer(container);
+	return app;
+}
+
+//#endregion
+//#region packages/core/src/Config/Config.ts
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+//#region packages/core/src/Middleware/ValidationMiddleware.ts
+var ValidationMiddleware = class {
+	gValidationProvider;
+	/**
+	* Middleware function that processes the HTTP event
+	* @param {Request} request - The HTTP request object
+	* @param {Response} response - The HTTP response object
+	* @param {MiddlewareOptions} args - Additional arguments for the middleware
+	* @returns {Promise<void>} - A promise that resolves when the processing is complete
+	* @throws {BadRequestError} - If validation fails
+	*/
+	async onRequest(request, response, args) {
+		if (!this.gValidationProvider) {
+			console.warn("ValidationMiddleware::ValidationProvider is not registered");
+			return;
+		}
+		const validators = args.methodArgs?.filter((arg) => arg.validate && arg.validationSchema) ?? [];
+		for (const validator of validators) {
+			const result = await this.gValidationProvider.validate(validator.validationSchema, validator.resolved);
+			if (result.issues?.length) throw new BadRequestError(`Validation error - ${validator.type}`, result.issues);
+		}
+	}
+};
+__decorate([InjectOptional(ValidationProvider)], ValidationMiddleware.prototype, "gValidationProvider", void 0);
+
+//#endregion
+//#region packages/core/src/Utils/Utils.ts
+function createMetadataCtx() {
+	return {
+		__controller: { path: "" },
+		__middlewares: [],
+		__methods: {}
+	};
+}
+function createMetadataMethod() {
+	return {
+		req: null,
+		res: null,
+		url: null,
+		args: [],
+		actions: []
+	};
+}
+function initializeMetadataMethod(target, propertyName) {
+	if (!target.__metadata.__methods[propertyName]) target.__metadata.__methods[propertyName] = createMetadataMethod();
+	return target.__metadata.__methods[propertyName];
+}
+function initializeMetadata(target) {
+	if (!target.__metadata) target.__metadata = createMetadataCtx();
+	if (!target.__metadata.__methods) target.__metadata.__methods = {};
+	if (!target.__metadata.__middlewares) target.__metadata.__middlewares = [];
+	return target.__metadata;
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Body.ts
+var BodyDecorator = class extends BaseDecorator {
+	/**
+	* @method created
+	* This method is called when the decorator is created. It ensures that the metadata
+	* for the property exists and adds the body argument to the metadata.
+	*/
+	created() {
+		const meta = initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "body",
+			validate: this.options?.validationSchema ? true : false,
+			validationSchema: this.options?.validationSchema
+		});
+		meta.__middlewares.unshift({
+			target: this.propertyName,
+			priority: -1,
+			args: {},
+			middleware: ValidationMiddleware
+		});
+	}
+};
+function Body(options) {
+	return createDecorator(BodyDecorator, options);
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Connect.ts
+var ConnectDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the CONNECT request.
+	*/
+	created() {
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "CONNECT",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], ConnectDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], ConnectDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], ConnectDecorator.prototype, "gMetadataResolver", void 0);
+function Connect(path) {
+	return createDecorator(ConnectDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Controller.ts
+function Controller(path) {
+	return function internalDecorator(target) {
+		const meta = initializeMetadata(target.prototype);
+		meta.__controller = {
+			...meta?.__controller,
+			path
+		};
+	};
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Delete.ts
+var DeleteDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the DELETE request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "DELETE",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], DeleteDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], DeleteDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], DeleteDecorator.prototype, "gMetadataResolver", void 0);
+function Delete(path) {
+	return createDecorator(DeleteDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Get.ts
+var GetDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the GET request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "GET",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], GetDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], GetDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], GetDecorator.prototype, "gMetadataResolver", void 0);
+function Get(path) {
+	return createDecorator(GetDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Head.ts
+var HeadDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the HEAD request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "HEAD",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], HeadDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], HeadDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], HeadDecorator.prototype, "gMetadataResolver", void 0);
+function Head(path) {
+	return createDecorator(HeadDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Header.ts
+var HeaderDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the header information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "header",
+			data: { name: this.options.name }
+		});
+	}
+};
+function Header(name) {
+	return createDecorator(HeaderDecorator, { name });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Headers.ts
+var HeadersDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the headers information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "headers"
+		});
+	}
+};
+function Headers$1() {
+	return createDecorator(HeadersDecorator, {});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Options.ts
+var OptionsDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the OPTIONS request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "OPTIONS",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], OptionsDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], OptionsDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], OptionsDecorator.prototype, "gMetadataResolver", void 0);
+function Options(path) {
+	return createDecorator(OptionsDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Param.ts
+var ParamDecorator = class extends BaseDecorator {
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the parameter information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "param",
+			data: { name: this.options.name }
+		});
+	}
+};
+__decorate([Inject(MetadataResolver)], ParamDecorator.prototype, "gMetadataResolver", void 0);
+function Param(name) {
+	return createDecorator(ParamDecorator, { name });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Patch.ts
+var PatchDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the PATCH request.
+	*/
+	created() {
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "PATCH",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], PatchDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], PatchDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], PatchDecorator.prototype, "gMetadataResolver", void 0);
+function Patch(path) {
+	return createDecorator(PatchDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Post.ts
+var PostDecorator = class extends BaseDecorator {
+	gRouter;
+	gMetadataResolver;
+	gRequestHandler;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the POST request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "POST",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], PostDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(MetadataResolver)], PostDecorator.prototype, "gMetadataResolver", void 0);
+__decorate([Inject(RequestHandler)], PostDecorator.prototype, "gRequestHandler", void 0);
+function Post(path) {
+	return createDecorator(PostDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Put.ts
+var PutDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the PUT request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "PUT",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], PutDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], PutDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], PutDecorator.prototype, "gMetadataResolver", void 0);
+function Put(path) {
+	return createDecorator(PutDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/QueryParam.ts
+var QueryParamDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the query parameter information to the metadata.
+	*/
+	created() {
+		const meta = initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "query-param",
+			data: { name: this.options.name },
+			validate: this.options?.validationSchema ? true : false,
+			validationSchema: this.options?.validationSchema
+		});
+		meta.__middlewares.unshift({
+			target: this.propertyName,
+			priority: -1,
+			args: {},
+			middleware: ValidationMiddleware
+		});
+	}
+};
+function QueryParam(options) {
+	return createDecorator(QueryParamDecorator, options);
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/QueryParams.ts
+var QueryParamsDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the query parameters information to the metadata.
+	*/
+	created() {
+		const meta = initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "query-params",
+			data: {},
+			validate: this.options?.validationSchema ? true : false,
+			validationSchema: this.options?.validationSchema
+		});
+		meta.__middlewares.unshift({
+			target: this.propertyName,
+			priority: -1,
+			args: {},
+			middleware: ValidationMiddleware
+		});
+	}
+};
+function QueryParams(options) {
+	return createDecorator(QueryParamsDecorator, options);
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Request.ts
+var RequestDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the request information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "request"
+		});
+	}
+};
+function Request() {
+	return createDecorator(RequestDecorator, {});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Response.ts
+var ResponseDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the response information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "response"
+		});
+	}
+};
+function Response$1() {
+	return createDecorator(ResponseDecorator, {});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Trace.ts
+var TraceDecorator = class extends BaseDecorator {
+	gRouter;
+	gRequestHandler;
+	gMetadataResolver;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method constructs the full path for the route, registers the route
+	* with the Router, and sets up the event handler for the TRACE request.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		initializeMetadataMethod(this.prototype, this.propertyName);
+		this.options.path = this.gMetadataResolver.resolveUrl({
+			instance: this.instance,
+			path: this.options.path,
+			propertyName: this.propertyName
+		});
+		this.gRouter.addRoute({
+			path: this.options.path,
+			method: "TRACE",
+			handler: this.gRequestHandler.prepareHandler({
+				instance: this.instance,
+				propertyName: this.propertyName
+			})
+		});
+	}
+};
+__decorate([Inject(Router)], TraceDecorator.prototype, "gRouter", void 0);
+__decorate([Inject(RequestHandler)], TraceDecorator.prototype, "gRequestHandler", void 0);
+__decorate([Inject(MetadataResolver)], TraceDecorator.prototype, "gMetadataResolver", void 0);
+function Trace(path) {
+	return createDecorator(TraceDecorator, { path });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/SetHeader.ts
+var SetHeaderDecorator = class extends BaseDecorator {
+	/**
+	* Called when the decorator is created.
+	* Adds a query parameter to the metadata.
+	* @override
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.actions.push({ handler: (req, res) => {
+			res.headers.delete(this.options.key);
+			res.headers.append(this.options.key, this.options.value);
+			return res;
+		} });
+	}
+};
+function SetHeader(key, value) {
+	return createDecorator(SetHeaderDecorator, {
+		key,
+		value
+	});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Status.ts
+var StatusDecorator = class extends BaseDecorator {
+	/**
+	
+	* Called when the decorator is created.
+	
+	* Sets a status on the response
+	
+	* @override
+	
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.actions.push({ handler: () => ({ status: this.options.code }) });
+	}
+};
+function Status(code) {
+	return createDecorator(StatusDecorator, { code });
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Redirect.ts
+var RedirectDecorator = class extends BaseDecorator {
+	/**
+	
+	* Decorator responsible for redirecting to a specified URL.
+	
+	* Called when the decorator is created.
+	
+	* Sets the location header value and status code.
+	
+	* @override
+	
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.actions.push({ handler: () => {
+			return new Response(void 0, {
+				status: this.options.code,
+				headers: { "Location": this.options.location }
+			});
+		} });
+	}
+};
+function Redirect(location, code = 301) {
+	return createDecorator(RedirectDecorator, {
+		location,
+		code
+	});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Middleware.ts
+function Middleware(middleware, opts) {
+	return function internalDecorator(target, propertyName) {
+		const ctx = propertyName ? target : target.prototype;
+		const meta = initializeMetadata(ctx);
+		meta.__middlewares.push({
+			target: propertyName ?? "__global__",
+			priority: opts?.priority ?? 999,
+			middleware
+		});
+	};
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/MultipartFormData.ts
+var MultipartFormDataDecorator = class extends BaseDecorator {
+	/**
+	* @method created
+	* This method is called when the decorator is created. It ensures that the metadata
+	* for the property exists and adds the body argument to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "multipart-form-data"
+		});
+	}
+};
+function MultipartFormData() {
+	return createDecorator(MultipartFormDataDecorator, {});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Http/Session.ts
+var SessionDecorator = class extends BaseDecorator {
+	gRuntimeConfig;
+	/**
+	* Called when the decorator is created.
+	*
+	* This method checks if metadata for the property exists, creates it if it doesn't,
+	* and then adds the session information to the metadata.
+	*/
+	created() {
+		initializeMetadata(this.prototype);
+		const method = initializeMetadataMethod(this.prototype, this.propertyName);
+		method.args.push({
+			idx: this.propertyIndex,
+			type: "session",
+			data: {
+				name: this.gRuntimeConfig.runtimeConfig.session?.name ?? "vercube_session",
+				secret: this.gRuntimeConfig.runtimeConfig.session?.secret ?? generateRandomHash(),
+				duration: this.gRuntimeConfig.runtimeConfig.session?.duration ?? 60 * 60 * 24 * 7
+			}
+		});
+	}
+};
+__decorate([Inject(RuntimeConfig)], SessionDecorator.prototype, "gRuntimeConfig", void 0);
+function Session() {
+	return createDecorator(SessionDecorator, {});
+}
+
+//#endregion
+//#region packages/core/src/Decorators/Hooks/Listen.ts
+var ListenDecorator = class extends BaseDecorator {
+	gHooksService;
+	fHook;
+	/**
+	* Called when decorator is initialized. It will register event listener that will call this function
+	* once executed.
+	*/
+	created() {
+		this.fHook = this.gHooksService.on(this.options.hookType, (data) => this.instance[this.propertyName](data));
+	}
+	/**
+	* Called when decorator is destroyed. It will unregister event listener.
+	*/
+	destroyed() {
+		this.gHooksService.off(this.fHook);
+	}
+};
+__decorate([Inject(HooksService)], ListenDecorator.prototype, "gHooksService", void 0);
+function Listen(hookType) {
+	return createDecorator(ListenDecorator, { hookType });
+}
+
+//#endregion
+//#region packages/core/src/Services/Plugins/BasePlugin.ts
+var BasePlugin = class {
+	/**
+	* The name of the plugin.
+	*/
+	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.
+	*/
+	use(app, options) {}
+};
+
+//#endregion
+//#region packages/core/src/Services/Middleware/BaseMiddleware.ts
+var BaseMiddleware = class {};
+
+//#endregion
+//#region packages/core/src/Errors/Http/ForbiddenError.ts
+var ForbiddenError = class ForbiddenError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "ForbiddenError";
+	/**
+	* Creates an instance of ForbiddenError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(403);
+		Object.setPrototypeOf(this, ForbiddenError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/MethodNotAllowedError.ts
+var MethodNotAllowedError = class MethodNotAllowedError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "MethodNotAllowedError";
+	/**
+	* Creates an instance of MethodNotAllowedError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(405);
+		Object.setPrototypeOf(this, MethodNotAllowedError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/NotAcceptableError.ts
+var NotAcceptableError = class NotAcceptableError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "NotAcceptableError";
+	/**
+	* Creates an instance of NotAcceptableError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(406);
+		Object.setPrototypeOf(this, NotAcceptableError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/NotFoundError.ts
+var NotFoundError = class NotFoundError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "NotFoundError";
+	/**
+	* Creates an instance of NotFoundError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(404);
+		Object.setPrototypeOf(this, NotFoundError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Errors/Http/UnauthorizedError.ts
+var UnauthorizedError = class UnauthorizedError extends HttpError {
+	/**
+	* The name of the error.
+	* @type {string}
+	*/
+	name = "UnauthorizedError";
+	/**
+	* Creates an instance of UnauthorizedError.
+	* @param {string} [message] - The error message.
+	*/
+	constructor(message) {
+		super(401);
+		Object.setPrototypeOf(this, UnauthorizedError.prototype);
+		if (message) this.message = message;
+	}
+};
+
+//#endregion
+//#region packages/core/src/Types/HttpTypes.ts
+let HTTPStatus = /* @__PURE__ */ function(HTTPStatus$1) {
+	HTTPStatus$1[HTTPStatus$1["CONTINUE"] = 100] = "CONTINUE";
+	HTTPStatus$1[HTTPStatus$1["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+	HTTPStatus$1[HTTPStatus$1["PROCESSING"] = 102] = "PROCESSING";
+	HTTPStatus$1[HTTPStatus$1["OK"] = 200] = "OK";
+	HTTPStatus$1[HTTPStatus$1["CREATED"] = 201] = "CREATED";
+	HTTPStatus$1[HTTPStatus$1["ACCEPTED"] = 202] = "ACCEPTED";
+	HTTPStatus$1[HTTPStatus$1["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+	HTTPStatus$1[HTTPStatus$1["NO_CONTENT"] = 204] = "NO_CONTENT";
+	HTTPStatus$1[HTTPStatus$1["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+	HTTPStatus$1[HTTPStatus$1["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+	HTTPStatus$1[HTTPStatus$1["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+	HTTPStatus$1[HTTPStatus$1["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+	HTTPStatus$1[HTTPStatus$1["IM_USED"] = 226] = "IM_USED";
+	HTTPStatus$1[HTTPStatus$1["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+	HTTPStatus$1[HTTPStatus$1["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+	HTTPStatus$1[HTTPStatus$1["FOUND"] = 302] = "FOUND";
+	HTTPStatus$1[HTTPStatus$1["SEE_OTHER"] = 303] = "SEE_OTHER";
+	HTTPStatus$1[HTTPStatus$1["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+	HTTPStatus$1[HTTPStatus$1["USE_PROXY"] = 305] = "USE_PROXY";
+	HTTPStatus$1[HTTPStatus$1["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+	HTTPStatus$1[HTTPStatus$1["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+	HTTPStatus$1[HTTPStatus$1["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+	HTTPStatus$1[HTTPStatus$1["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+	HTTPStatus$1[HTTPStatus$1["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+	HTTPStatus$1[HTTPStatus$1["FORBIDDEN"] = 403] = "FORBIDDEN";
+	HTTPStatus$1[HTTPStatus$1["NOT_FOUND"] = 404] = "NOT_FOUND";
+	HTTPStatus$1[HTTPStatus$1["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+	HTTPStatus$1[HTTPStatus$1["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+	HTTPStatus$1[HTTPStatus$1["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+	HTTPStatus$1[HTTPStatus$1["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+	HTTPStatus$1[HTTPStatus$1["CONFLICT"] = 409] = "CONFLICT";
+	HTTPStatus$1[HTTPStatus$1["GONE"] = 410] = "GONE";
+	HTTPStatus$1[HTTPStatus$1["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+	HTTPStatus$1[HTTPStatus$1["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+	HTTPStatus$1[HTTPStatus$1["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+	HTTPStatus$1[HTTPStatus$1["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+	HTTPStatus$1[HTTPStatus$1["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+	HTTPStatus$1[HTTPStatus$1["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+	HTTPStatus$1[HTTPStatus$1["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+	HTTPStatus$1[HTTPStatus$1["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+	HTTPStatus$1[HTTPStatus$1["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+	HTTPStatus$1[HTTPStatus$1["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+	HTTPStatus$1[HTTPStatus$1["LOCKED"] = 423] = "LOCKED";
+	HTTPStatus$1[HTTPStatus$1["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+	HTTPStatus$1[HTTPStatus$1["TOO_EARLY"] = 425] = "TOO_EARLY";
+	HTTPStatus$1[HTTPStatus$1["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+	HTTPStatus$1[HTTPStatus$1["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+	HTTPStatus$1[HTTPStatus$1["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+	HTTPStatus$1[HTTPStatus$1["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+	HTTPStatus$1[HTTPStatus$1["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+	HTTPStatus$1[HTTPStatus$1["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+	HTTPStatus$1[HTTPStatus$1["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+	HTTPStatus$1[HTTPStatus$1["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+	HTTPStatus$1[HTTPStatus$1["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+	HTTPStatus$1[HTTPStatus$1["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+	HTTPStatus$1[HTTPStatus$1["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+	HTTPStatus$1[HTTPStatus$1["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+	HTTPStatus$1[HTTPStatus$1["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+	HTTPStatus$1[HTTPStatus$1["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+	HTTPStatus$1[HTTPStatus$1["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+	HTTPStatus$1[HTTPStatus$1["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+	return HTTPStatus$1;
+}({});
+
+//#endregion
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, Delete, ForbiddenError, Get, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, InternalServerError, Listen, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, Response$1 as Response, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };