@h3ravel/core 1.21.6 → 1.22.0-alpha.1

package/dist/index.js

@@ -1,6 +1,11 @@
+import { createRequire } from "node:module";
 import "reflect-metadata";
-import { FileSystem, Logger, PathLoader } from "@h3ravel/shared";
-import { InvalidArgumentException, Str, dd, dump, str } from "@h3ravel/support";
+import { FileSystem, Logger, PathLoader, Resolver } from "@h3ravel/shared";
+import { H3, serve } from "h3";
+import { CKernel, IApplication, IContainer, IController, IKernel, IRegisterer } from "@h3ravel/contracts";
+import { Arr, InvalidArgumentException, Obj, RuntimeException, ServiceProvider, Str, data_get, dd, dump, str } from "@h3ravel/support";
+import { AppBuilder, ConfigException, Helpers, HttpException, Inject, Injectable, MiddlewareHandler, NotFoundHttpException } from "@h3ravel/foundation";
+import { createRequire as createRequire$1 } from "module";
 import fg from "fast-glob";
 import path from "node:path";
 import { detect } from "detect-port";
@@ -8,12 +13,90 @@ import dotenv from "dotenv";
 import dotenvExpand from "dotenv-expand";
 import { readFile } from "node:fs/promises";
 import semver from "semver";
-import { HttpContext as HttpContext$1, LogRequests, Request, Response } from "@h3ravel/http";
+import { Facades } from "@h3ravel/support/facades";
 
+//#region src/Manager/ContainerResolver.ts
+var ContainerResolver = class ContainerResolver {
+	constructor(app) {
+		this.app = app;
+	}
+	async resolveMethodParams(instance, method, ..._default) {
+		/**
+		* Get param types for instance method
+		*/
+		let params = Reflect.getMetadata("design:paramtypes", instance, String(method)) || [];
+		/**
+		* Ensure that the Application class is always available
+		*/
+		if (params.length < 1 && _default.length > 0) params = _default;
+		/**
+		* Resolve the bound dependencies
+		*/
+		const args = params.filter((e) => ContainerResolver.isClass(e) || e instanceof Application).map((type) => {
+			if (type instanceof Application) return type;
+			return this.app.make(type);
+		});
+		return new Promise((resolve) => {
+			resolve(instance[method](...args));
+		});
+	}
+	static isClass(C) {
+		return typeof C === "function" && C.prototype !== void 0 && Object.toString.call(C).substring(0, 5) === "class";
+	}
+	static isAbstract(C) {
+		return this.isClass(C) && C.name.startsWith("I");
+	}
+	static isCallable(C) {
+		return typeof C === "function" && !ContainerResolver.isClass(C);
+	}
+};
+
+//#endregion
 //#region src/Container.ts
-var Container = class {
+var Container = class Container extends IContainer {
 	bindings = /* @__PURE__ */ new Map();
 	singletons = /* @__PURE__ */ new Map();
+	middlewareHandler;
+	/**
+	* The current globally available container (if any).
+	*/
+	static instance;
+	/**
+	* All of the before resolving callbacks by class type.
+	*/
+	beforeResolvingCallbacks = /* @__PURE__ */ new Map();
+	/**
+	* All of the after resolving callbacks by class type.
+	*/
+	afterResolvingCallbacks = /* @__PURE__ */ new Map();
+	/**
+	* All of the registered rebound callbacks.
+	*/
+	reboundCallbacks = /* @__PURE__ */ new Map();
+	/**
+	* The container's shared instances.
+	*/
+	instances = /* @__PURE__ */ new Map();
+	/**
+	* The container's resolved instances.
+	*/
+	resolvedInstances = /* @__PURE__ */ new Map();
+	/**
+	* The registered type alias.
+	*/
+	aliases = /* @__PURE__ */ new Map();
+	/**
+	* The registered aliases keyed by the abstract name.
+	*/
+	abstractAliases = /* @__PURE__ */ new Map();
+	/**
+	* The registered aliases keyed by the abstract name.
+	*/
+	middlewares = /* @__PURE__ */ new Map();
+	/**
+	* The extension closures for services.
+	*/
+	extenders = /* @__PURE__ */ new Map();
 	static hasAnyDecorator(target) {
 		if (Reflect.getMetadataKeys(target).length > 0) return true;
 		const paramLength = target.length;
@@ -24,7 +107,22 @@ var Container = class {
 		this.bindings.set(key, factory);
 	}
 	/**
+	* Bind unregistered middlewares to the service container so we can use them later
+	* 
+	* @param key 
+	* @param middleware 
+	*/
+	bindMiddleware(key, middleware) {
+		this.middlewares.set(key, middleware);
+	}
+	boundMiddlewares(key) {
+		if (key) return this.middlewares.get(key);
+		return this.middlewares.entries();
+	}
+	/**
 	* Remove one or more transient services from the container
+	* 
+	* @param key 
 	*/
 	unbind(key) {
 		if (Array.isArray(key)) for (let i = 0; i < key.length; i++) {
@@ -36,28 +134,127 @@ var Container = class {
 			this.singletons.delete(key);
 		}
 	}
-	/**
-	* Bind a singleton service to the container
-	*/
 	singleton(key, factory) {
 		this.bindings.set(key, () => {
-			if (!this.singletons.has(key)) this.singletons.set(key, factory(this));
+			if (!this.singletons.has(key)) this.singletons.set(key, this.call(factory));
 			return this.singletons.get(key);
 		});
 	}
+	/**
+	* Read reflected param types, resolve dependencies from the container and 
+	* optionally transform them, finally invoke the specified method on a class instance
+	* 
+	* @param instance 
+	* @param method 
+	* @param defaultArgs 
+	* @param handler 
+	* @returns 
+	*/
+	async invoke(instance, method, defaultArgs, handler) {
+		/**
+		* Get param types for the instance method
+		*/
+		const paramTypes = Reflect.getMetadata("design:paramtypes", instance, method) || [];
+		/**
+		* Resolve the bound dependencies
+		*/
+		let args = await Promise.all(paramTypes.map(async (paramType) => {
+			const inst = this.make(paramType);
+			if (handler) return await handler(inst);
+			return inst;
+		}));
+		/**
+		* Ensure that the args is always filled
+		*/
+		if (args.length < 1) args = defaultArgs ?? [];
+		const fn = instance[method];
+		return Reflect.apply(fn, instance, args);
+	}
+	/**
+	* Read reflected param types, resolve dependencies from the container and return the result
+	* 
+	* @param instance 
+	* @param method 
+	*/
+	resolveParams(instance, method) {
+		/**
+		* Resolve and return the bound dependencies
+		*/
+		return (Reflect.getMetadata("design:paramtypes", instance, method) || []).filter((e) => !!e).map((abstract) => {
+			if (typeof abstract === "function" && abstract.toString().startsWith("function Function")) return abstract;
+			return this.make(abstract);
+		});
+	}
 	make(key) {
+		return this.resolve(key);
+	}
+	/**
+	* Resolve the gevein service from the container
+	* 
+	* @param abstract 
+	* @param raiseEvents 
+	*/
+	resolve(abstract, raiseEvents = true) {
+		abstract = this.getAlias(abstract);
 		/**
 		* Direct factory binding
 		*/
-		if (this.bindings.has(key)) return this.bindings.get(key)();
-		/**
+		let resolved;
+		if (this.resolvedInstances.has(abstract)) return this.resolvedInstances.get(abstract);
+		if (raiseEvents) this.runBeforeResolvingCallbacks(abstract);
+		if (this.bindings.has(abstract)) resolved = this.bindings.get(abstract)();
+		else if (this.instances.has(abstract)) resolved = this.instances.get(abstract);
+		else if (typeof abstract === "function")
+ /**
 		* If this is a class constructor, auto-resolve via reflection
 		*/
-		if (typeof key === "function") return this.build(key);
-		throw new Error(`No binding found for key: ${typeof key === "string" ? key : key?.name}`);
+		resolved = this.build(abstract);
+		else throw new Error(`No binding found for key: ${typeof abstract === "string" ? abstract : abstract?.name}`);
+		/**
+		* If we defined any extenders for this type, we'll need to spin through them
+		* and apply them to the object being built. This allows for the extension
+		* of services, such as changing configuration or decorating the object.
+		*/
+		for (const extender of this.getExtenders(abstract)) resolved = extender(resolved, this);
+		if (raiseEvents) this.runAfterResolvingCallbacks(abstract, resolved);
+		this.resolvedInstances.set(abstract, resolved);
+		return resolved;
+	}
+	afterResolving(key, callback) {
+		const existing = this.afterResolvingCallbacks.get(key) || [];
+		existing.push(callback);
+		this.afterResolvingCallbacks.set(key, existing);
+	}
+	beforeResolving(key, callback) {
+		const existing = this.beforeResolvingCallbacks.get(key) || [];
+		existing.push(callback);
+		this.beforeResolvingCallbacks.set(key, existing);
+	}
+	/**
+	* Execute all registered beforeResolving callbacks for a given key
+	*
+	* @param  key
+	* @param resolved 
+	*/
+	runBeforeResolvingCallbacks(key) {
+		const callbacks = this.beforeResolvingCallbacks.get(key) || [];
+		for (let i = 0; i < callbacks.length; i++) callbacks[i](this);
+	}
+	/**
+	* Execute all registered afterResolving callbacks for a given key
+	* 
+	* @param key 
+	* @param resolved 
+	*/
+	runAfterResolvingCallbacks(key, resolved) {
+		const callbacks = this.afterResolvingCallbacks.get(key) || [];
+		for (let i = 0; i < callbacks.length; i++) callbacks[i](resolved, this);
 	}
 	/**
 	* Automatically build a class with constructor dependency injection
+	* 
+	* @param ClassType 
+	* @returns 
 	*/
 	build(ClassType) {
 		let dependencies = [];
@@ -65,44 +262,135 @@ var Container = class {
 			return this.make(alias);
 		});
 		else dependencies = (Reflect.getMetadata("design:paramtypes", ClassType) || []).map((dep) => this.make(dep));
+		if (dependencies.length === 0) dependencies = [this];
 		return new ClassType(...dependencies);
 	}
 	/**
-	* Check if a service is registered
+	* Determine if a given string is an alias.
+	*
+	* @param name
+	*/
+	isAlias(name) {
+		return this.aliases.has(name) && typeof this.aliases.get(name) !== "undefined";
+	}
+	/**
+	* Get the alias for an abstract if available.
+	*
+	* @param  abstract
+	*/
+	getAlias(abstract) {
+		if (typeof abstract === "string" && this.aliases.has(abstract)) return this.getAlias(this.aliases.get(abstract));
+		if (abstract == null) return abstract;
+		return this.aliases.get(abstract) ?? abstract;
+	}
+	/**
+	* Get the extender callbacks for a given type.
+	*
+	* @param  abstract
 	*/
+	getExtenders(abstract) {
+		return this.extenders.get(this.getAlias(abstract)) ?? [];
+	}
+	/**
+	* Remove all of the extender callbacks for a given type.
+	*
+	* @param  abstract
+	*/
+	forgetExtenders(abstract) {
+		this.extenders.delete(this.getAlias(abstract));
+	}
+	alias(key, target) {
+		if (Array.isArray(key)) for (const [tokn, targ] of key) this.aliases.set(tokn, targ);
+		else this.aliases.set(key, target);
+		return this;
+	}
+	rebinding(abstract, callback) {
+		abstract = this.getAlias(abstract);
+		this.reboundCallbacks.set(abstract, this.reboundCallbacks.get(abstract)?.concat(callback) ?? [callback]);
+		if (this.bound(abstract)) return this.make(abstract);
+	}
+	bound(abstract) {
+		return this.bindings.has(abstract) || !!this.instances.get(abstract) || this.isAlias(abstract);
+	}
 	has(key) {
-		return this.bindings.has(key);
+		return this.bound(key);
 	}
-};
-
-//#endregion
-//#region src/Di/ContainerResolver.ts
-var ContainerResolver = class ContainerResolver {
-	constructor(app) {
-		this.app = app;
+	/**
+	* Determine if the given abstract type has been resolved.
+	*
+	* @param abstract
+	*/
+	resolved(abstract) {
+		if (this.isAlias(abstract)) abstract = this.getAlias(abstract);
+		return this.resolvedInstances.has(abstract) || this.instances.has(abstract);
 	}
-	async resolveMethodParams(instance, method, ..._default) {
-		/**
-		* Get param types for instance method
-		*/
-		let params = Reflect.getMetadata("design:paramtypes", instance, String(method)) || [];
-		/**
-		* Ensure that the Application class is always available
-		*/
-		if (params.length < 1 && _default.length > 0) params = _default;
-		/**
-		* Resolve the bound dependencies
-		*/
-		const args = params.filter((e) => ContainerResolver.isClass(e) || e instanceof Application).map((type) => {
-			if (type instanceof Application) return type;
-			return this.app.make(type);
-		});
-		return new Promise((resolve) => {
-			resolve(instance[method](...args));
-		});
+	extend(abstract, closure) {
+		abstract = this.getAlias(abstract);
+		if (this.instances.has(abstract)) {
+			this.instances.set(abstract, closure(this.instances.get(abstract), this));
+			this.rebound(abstract);
+		} else {
+			this.extenders.set(abstract, this.extenders.get(abstract)?.concat(closure) ?? [closure]);
+			if (this.resolved(abstract)) this.rebound(abstract);
+		}
 	}
-	static isClass(C) {
-		return typeof C === "function" && C.prototype !== void 0 && Object.toString.call(C).substring(0, 5) === "class";
+	instance(abstract, instance) {
+		this.removeAbstractAlias(abstract);
+		const isBound = this.bound(abstract);
+		this.aliases.delete(abstract);
+		this.instances.set(abstract, instance);
+		if (isBound) this.rebound(abstract);
+		return instance;
+	}
+	call(callback) {
+		if (ContainerResolver.isClass(callback)) return this.make(callback);
+		return callback(this);
+	}
+	/**
+	* Fire the "rebound" callbacks for the given abstract type.
+	*
+	* @param abstract
+	*/
+	rebound(abstract) {
+		const callbacks = this.getReboundCallbacks(abstract);
+		if (!callbacks) return;
+		const instance = this.make(abstract);
+		for (const callback of callbacks) callback(this, instance);
+	}
+	/**
+	* Get the rebound callbacks for a given type.
+	*
+	* @param abstract
+	*/
+	getReboundCallbacks(abstract) {
+		return this.reboundCallbacks.get(abstract) ?? [];
+	}
+	/**
+	* Remove an alias from the contextual binding alias cache.
+	*
+	* @param  searched
+	*/
+	removeAbstractAlias(searched) {
+		if (!this.aliases.has(searched)) return;
+		for (const [abstract, aliases] of this.abstractAliases.entries()) {
+			const filtered = aliases.filter((alias) => alias !== searched);
+			if (filtered.length > 0) this.abstractAliases.set(abstract, filtered);
+			else this.abstractAliases.delete(abstract);
+		}
+	}
+	/**
+	* Get the globally available instance of the container.
+	*/
+	static getInstance() {
+		return this.instance ??= new Application(process.cwd(), "h3ravel");
+	}
+	/**
+	* Set the shared instance of the container.
+	* 
+	* @param container 
+	*/
+	static setInstance(container) {
+		return Container.instance = container;
 	}
 };
 
@@ -192,33 +480,25 @@ var ProviderRegistry = class {
 	* @returns 
 	*/
 	static sort(providers) {
-		/**
-		* Base priority (default 0)
-		*/
-		providers.forEach((Provider) => {
-			const key = this.getKey(Provider);
-			this.priorityMap.set(`${Provider.name}::${key}`, Provider.priority ?? 0);
-		});
-		/**
-		* Handle before/after adjustments
-		*/
+		const makeKey = (Provider) => `${Provider.name}::${this.getKey(Provider)}`;
+		providers.sort((A, B) => (B.priority ?? 0) - (A.priority ?? 0));
+		const findIndex = (target) => {
+			if (target.includes("::")) return providers.findIndex((p) => makeKey(p) === target);
+			return providers.findIndex((p) => p.name === target);
+		};
 		providers.forEach((Provider) => {
 			const order = Provider.order;
 			if (!order) return;
-			const [direction, target] = order.split(":");
-			const targetPriority = this.priorityMap.get(target) ?? 0;
-			const key = this.getKey(Provider);
-			if (direction === "before") this.priorityMap.set(`${Provider.name}::${key}`, targetPriority - 1);
-			else if (direction === "after") this.priorityMap.set(`${Provider.name}::${key}`, targetPriority + 1);
-		});
-		/**
-		* Return service providers sorted based on thier name and priority
-		*/
-		return providers.sort((A, B) => {
-			const keyA = this.getKey(A);
-			const keyB = this.getKey(B);
-			return (this.priorityMap.get(`${B.name}::${keyB}`) ?? 0) - (this.priorityMap.get(`${A.name}::${keyA}`) ?? 0);
+			const [direction, rawTarget] = order.split(":");
+			const targetIndex = findIndex(rawTarget);
+			if (targetIndex === -1) return;
+			const currentIndex = providers.indexOf(Provider);
+			if (currentIndex === -1) return;
+			providers.splice(currentIndex, 1);
+			const insertIndex = direction === "before" ? targetIndex : targetIndex + 1;
+			providers.splice(insertIndex, 0, Provider);
 		});
+		return providers;
 	}
 	/**
 	* Sort service providers
@@ -237,7 +517,8 @@ var ProviderRegistry = class {
 	* 
 	* @param priorityMap 
 	*/
-	static log(providers) {
+	static log(providers, enabled = true) {
+		if (!enabled) return;
 		const sorted = Array.from((providers ?? this.providers).values());
 		console.table(sorted.map((P) => ({
 			Name: P.constructor.name,
@@ -278,10 +559,10 @@ var ProviderRegistry = class {
 		const providers = [];
 		if (autoRegister) {
 			for (const manifestPath of manifests) {
-				const pkg = await this.getManifest(path.resolve(manifestPath));
+				const pkg = this.getManifest(path.resolve(manifestPath));
 				if (pkg.h3ravel?.providers) providers.push(...await Promise.all(pkg.h3ravel.providers.map(async (name) => (await import(path.resolve(path.dirname(manifestPath), "dist/index.js")))[name])));
 			}
-			for (const provider of providers) {
+			for (const provider of providers.filter((e) => typeof e !== "undefined")) {
 				const key = this.getKey(provider);
 				this.providers.set(key, provider);
 			}
@@ -294,22 +575,16 @@ var ProviderRegistry = class {
 	* @param manifestPath 
 	* @returns 
 	*/
-	static async getManifest(manifestPath) {
-		let pkg;
-		try {
-			pkg = (await import(manifestPath)).default;
-		} catch {
-			const { createRequire } = await import("module");
-			pkg = createRequire(import.meta.url)(manifestPath);
-		}
-		return pkg;
+	static getManifest(manifestPath) {
+		return createRequire$1(import.meta.url)(manifestPath);
 	}
 };
 
 //#endregion
 //#region src/Registerer.ts
-var Registerer = class Registerer {
+var Registerer = class Registerer extends IRegisterer {
 	constructor(app) {
+		super();
 		this.app = app;
 	}
 	static register(app) {
@@ -341,31 +616,87 @@ var Registerer = class Registerer {
 	}
 };
 
+//#endregion
+//#region src/Providers/CoreServiceProvider.ts
+/**
+* Bootstraps core services and bindings.
+* 
+* Bind essential services to the container (logger, config repository).
+* Register app-level singletons.
+* Set up exception handling.
+* 
+* Auto-Registered
+*/
+var CoreServiceProvider = class extends ServiceProvider {
+	static priority = 999;
+	register() {
+		Object.assign(globalThis, { str });
+		this.app.alias(IApplication, Application);
+	}
+	boot() {}
+};
+
 //#endregion
 //#region src/Application.ts
 var Application = class Application extends Container {
+	/**
+	* Indicates if the application has "booted".
+	*/
+	#booted = false;
 	paths = new PathLoader();
 	context;
+	h3Event;
 	tries = 0;
-	booted = false;
 	basePath;
 	versions = {
 		app: "0.0.0",
 		ts: "0.0.0"
 	};
+	namespace;
 	static versions = {
 		app: "0.0.0",
 		ts: "0.0.0"
 	};
+	h3App;
 	providers = [];
 	externalProviders = [];
 	filteredProviders = [];
+	autoRegisterProviders = false;
+	/**
+	* The route resolver callback.
+	*/
+	uriResolver;
 	/**
 	* List of registered console commands
 	*/
 	registeredCommands = [];
-	constructor(basePath) {
+	/**
+	* The array of booted callbacks.
+	*/
+	bootedCallbacks = [];
+	/**
+	* The array of booting callbacks.
+	*/
+	bootingCallbacks = [];
+	/**
+	* The array of terminating callbacks.
+	*/
+	terminatingCallbacks = [];
+	/**
+	* Indicates if the application has been bootstrapped before.
+	*/
+	bootstrapped = false;
+	/**
+	* Controls logging
+	*/
+	logsDisabled = false;
+	/**
+	* The conrrent HttpContext
+	*/
+	httpContext;
+	constructor(basePath, initializer) {
 		super();
+		this.initializer = initializer;
 		dotenvExpand.expand(dotenv.config({ quiet: true }));
 		this.basePath = basePath;
 		this.setPath("base", basePath);
@@ -377,6 +708,7 @@ var Application = class Application extends Container {
 	* Register core bindings into the container
 	*/
 	registerBaseBindings() {
+		Application.setInstance(this);
 		this.bind(Application, () => this);
 		this.bind("path.base", () => this.basePath);
 		this.bind("load.paths", () => this.paths);
@@ -416,7 +748,7 @@ var Application = class Application extends Container {
 	* Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
 	*/
 	async getConfiguredProviders() {
-		return [(await import("@h3ravel/core")).CoreServiceProvider];
+		return [CoreServiceProvider];
 	}
 	async getAllProviders() {
 		return [...await this.getConfiguredProviders(), ...this.externalProviders];
@@ -430,22 +762,30 @@ var Application = class Application extends Container {
 	* 
 	* @returns 
 	*/
-	async quickStartup(providers, filtered = [], autoRegisterProviders = true) {
+	initialize(providers, filtered = [], autoRegisterProviders = true) {
+		/**
+		* Bind HTTP APP to the service container
+		*/
+		this.singleton("http.app", () => {
+			return new H3();
+		});
+		/**
+		* Bind the HTTP server to the service container
+		*/
+		this.singleton("http.serve", () => serve);
 		this.registerProviders(providers, filtered);
-		await this.registerConfiguredProviders(autoRegisterProviders);
-		return this.boot();
+		this.autoRegisterProviders = autoRegisterProviders;
+		return this;
 	}
 	/**
 	* Dynamically register all configured providers
-	* 
-	* @param autoRegister If set to false, service providers will not be auto discovered and registered.
 	*/
-	async registerConfiguredProviders(autoRegister = true) {
+	async registerConfiguredProviders() {
 		const providers = await this.getAllProviders();
 		ProviderRegistry.setSortable(false);
 		ProviderRegistry.setFiltered(this.filteredProviders);
 		ProviderRegistry.registerMany(providers);
-		if (autoRegister) await ProviderRegistry.discoverProviders(autoRegister);
+		if (this.autoRegisterProviders) await ProviderRegistry.discoverProviders(this.autoRegisterProviders);
 		ProviderRegistry.doSort();
 		for (const ProviderClass of ProviderRegistry.all()) {
 			if (!ProviderClass) continue;
@@ -461,7 +801,7 @@ var Application = class Application extends Container {
 	*/
 	registerProviders(providers, filtered = []) {
 		this.externalProviders.push(...providers);
-		this.filteredProviders = filtered;
+		this.filteredProviders = Array.from(new Set(this.filteredProviders.concat(filtered)));
 	}
 	/**
 	* Register a provider
@@ -486,44 +826,237 @@ var Application = class Application extends Container {
 	runningInConsole() {
 		return typeof process !== "undefined" && !!process.stdout && !!process.stdin;
 	}
+	/**
+	* checks if the application is running in Unit Test
+	*/
+	runningUnitTests() {
+		return process.env.VITEST === "true";
+	}
 	getRuntimeEnv() {
 		if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
 		if (typeof process !== "undefined" && process.versions?.node) return "node";
 		return "unknown";
 	}
 	/**
+	* Determine if the application has booted.
+	*/
+	isBooted() {
+		return this.#booted;
+	}
+	/**
+	* Determine if the application has booted.
+	*/
+	logging(logging = true) {
+		this.logsDisabled = !logging;
+		return this;
+	}
+	logsEnabled() {
+		if (this.logsDisabled) return false;
+		return (process.env.APP_DEBUG === "true" && process.env.EXTENDED_DEBUG !== "false" || Number(process.env.VERBOSE) > 1) && !this.providers.some((e) => e.runsInConsole);
+	}
+	/**
 	* Boot all service providers after registration
 	*/
 	async boot() {
-		if (this.booted) return this;
+		if (this.#booted) return this;
+		this.fireAppCallbacks(this.bootingCallbacks);
+		/**
+		* Register all the configured service providers
+		*/
+		await this.registerConfiguredProviders();
 		/**
 		* If debug is enabled, let's show the loaded service provider info
 		*/
-		if ((process.env.APP_DEBUG === "true" && process.env.EXTENDED_DEBUG !== "false" || Number(process.env.VERBOSE) > 1) && !this.providers.some((e) => e.runsInConsole)) ProviderRegistry.log(this.providers);
-		for (const provider of this.providers) if (provider.boot) if (Container.hasAnyDecorator(provider.boot))
+		ProviderRegistry.log(this.providers, this.logsEnabled());
+		for (const provider of this.providers) if (provider.boot) {
+			if (Container.hasAnyDecorator(provider.boot))
  /**
-		* If the service provider is decorated use the IoC container
-		*/
-		await this.make(provider.boot);
-		else
+			* If the service provider is decorated use the IoC container
+			*/
+			await this.make(provider.boot);
+			else
  /**
-		* Otherwise instantiate manually so that we can at least
-		* pass the app instance
-		*/
-		await provider.boot(this);
-		this.booted = true;
+			* Otherwise instantiate manually so that we can at least
+			* pass the app instance
+			*/
+			await provider.boot(this);
+			if (provider.callBootedCallbacks) await provider.callBootedCallbacks();
+		}
+		this.#booted = true;
+		this.fireAppCallbacks(this.bootedCallbacks);
+		return this;
+	}
+	/**
+	* Register a new boot listener.
+	*
+	* @param  callable  $callback
+	*/
+	booting(callback) {
+		this.bootingCallbacks.push(callback);
+	}
+	/**
+	* Register a new "booted" listener.
+	*
+	* @param callback
+	*/
+	booted(callback) {
+		this.bootedCallbacks.push(callback);
+		if (this.isBooted()) callback(this);
+	}
+	/**
+	* Throw an HttpException with the given data.
+	*
+	* @param  code
+	* @param  message
+	* @param  headers
+	*
+	* @throws {HttpException}
+	* @throws {NotFoundHttpException}
+	*/
+	abort(code, message = "", headers = {}) {
+		if (code == 404) throw new NotFoundHttpException(message, void 0, 0, headers);
+		throw new HttpException(code, message, void 0, headers);
+	}
+	/**
+	* Register a terminating callback with the application.
+	*
+	* @param  callback
+	*/
+	terminating(callback) {
+		this.terminatingCallbacks.push(callback);
+		return this;
+	}
+	/**
+	* Terminate the application.
+	*/
+	terminate() {
+		let index = 0;
+		while (index < this.terminatingCallbacks.length) {
+			this.call(this.terminatingCallbacks[index]);
+			index++;
+		}
+	}
+	/**
+	* Call the booting callbacks for the application.
+	*
+	* @param  callbacks
+	*/
+	fireAppCallbacks(callbacks) {
+		let index = 0;
+		while (index < callbacks.length) {
+			callbacks[index](this);
+			index++;
+		}
+	}
+	/**
+	* Handle the incoming HTTP request and send the response to the browser.
+	*
+	* @param  config  Configuration option to pass to the initializer
+	*/
+	async handleRequest(config) {
+		this.h3App?.all("/**", async (event) => {
+			this.context = (event$1) => this.buildContext(event$1, config);
+			this.h3Event = event;
+			const context = await this.context(event);
+			const kernel = this.make(IKernel);
+			this.bind("http.context", () => context);
+			this.bind("http.request", () => context.request);
+			this.bind("http.response", () => context.response);
+			const response = await kernel.handle(context.request);
+			if (response) this.bind("http.response", () => response);
+			kernel.terminate(context.request, response);
+			let finalResponse;
+			if (response && ["Response", "JsonResponse"].includes(response.constructor.name)) finalResponse = response.prepare(context.request).send();
+			else finalResponse = response;
+			return finalResponse;
+		});
+	}
+	/**
+	* Build the http context
+	* 
+	* @param event 
+	* @param config 
+	* @returns 
+	*/
+	async buildContext(event, config, fresh = false) {
+		const { HttpContext, Request, Response } = await import("@h3ravel/http");
+		event = config?.h3Event ?? event;
+		if (!fresh && event._h3ravelContext) return event._h3ravelContext;
+		Request.enableHttpMethodParameterOverride();
+		const ctx = HttpContext.init({
+			app: this,
+			request: await Request.create(event, this),
+			response: new Response(this, event)
+		}, event);
+		event._h3ravelContext = ctx;
+		return ctx;
+	}
+	/**
+	* Handle the incoming Artisan command.
+	*/
+	async handleCommand() {
+		const kernel = this.make(CKernel);
+		const status = await kernel.handle();
+		kernel.terminate(status);
+		return status;
+	}
+	/**
+	* Get the URI resolver callback.
+	*/
+	getUriResolver() {
+		return this.uriResolver ?? (() => void 0);
+	}
+	/**
+	* Set the URI resolver callback.
+	*
+	* @param  callback
+	*/
+	setUriResolver(callback) {
+		this.uriResolver = callback;
 		return this;
 	}
+	/**
+	* Determine if middleware has been disabled for the application.
+	*/
+	shouldSkipMiddleware() {
+		return this.bound("middleware.disable") && this.make("middleware.disable") === true;
+	}
+	/**
+	* Provide safe overides for the app
+	*/
+	configure() {
+		return new AppBuilder(this).withKernels().withCommands();
+	}
+	/**
+	* Check if the current application environment matches the one provided
+	*/
+	environment(env$1) {
+		return this.make("config").get("app.env") === env$1;
+	}
 	async fire(h3App, preferredPort) {
+		if (h3App) this.h3App = h3App;
+		if (!this?.h3App) throw new ConfigException("[Provide a H3 app instance in the config or install @h3ravel/http]");
+		return await this.serve(this.h3App, preferredPort);
+	}
+	/**
+	* Fire up the developement server using the user provided arguments
+	* 
+	* Port will be auto assigned if provided one is not available
+	* 
+	* @param h3App The current H3 app instance
+	* @param preferedPort If provided, this will overide the port set in the evironment
+	*/
+	async serve(h3App, preferredPort) {
 		if (!h3App) throw new InvalidArgumentException("No valid H3 app instance was provided.");
-		const serve = this.make("http.serve");
+		await this.boot();
+		const serve$1 = this.make("http.serve");
 		const port = preferredPort ?? env("PORT", 3e3);
 		const tries = env("RETRIES", 1);
 		const hostname = env("HOSTNAME", "localhost");
 		try {
 			const realPort = await detect(port);
 			if (port == realPort) {
-				const server = serve(h3App, {
+				const server = serve$1(h3App, {
 					port,
 					hostname,
 					silent: true
@@ -543,6 +1076,66 @@ var Application = class Application extends Container {
 		return this;
 	}
 	/**
+	* Run the given array of bootstrap classes.
+	*
+	* @param bootstrappers
+	*/
+	async bootstrapWith(bootstrappers) {
+		for (const bootstrapper of bootstrappers) {
+			if (this.has("app.events")) this.make("app.events").dispatch("bootstrapping: " + bootstrapper.name, [this]);
+			await this.make(bootstrapper).bootstrap(this);
+			if (this.has("app.events")) this.make("app.events").dispatch("bootstrapped: " + bootstrapper.name, [this]);
+		}
+		this.bootstrapped = true;
+	}
+	/**
+	* Determine if the application has been bootstrapped before.
+	*/
+	hasBeenBootstrapped() {
+		return this.bootstrapped;
+	}
+	/**
+	* Save the curretn H3 instance for possible future use.
+	*
+	* @param h3App The current H3 app instance
+	* @returns 
+	*/
+	setH3App(h3App) {
+		this.h3App = h3App;
+		return this;
+	}
+	/**
+	* Set the HttpContext.
+	*
+	* @param  ctx
+	*/
+	setHttpContext(ctx) {
+		this.httpContext = ctx;
+		return this;
+	}
+	getHttpContext(key) {
+		return key ? this.httpContext?.[key] : this.httpContext;
+	}
+	/**
+	* Get the application namespace.
+	*
+	* @throws {RuntimeException}
+	*/
+	getNamespace() {
+		if (this.namespace != null) return this.namespace;
+		const pkg = createRequire(import.meta.url)(path.join(process.cwd(), "package.json"));
+		for (const [namespace, pathChoice] of Object.entries(data_get(pkg, "autoload.namespaces"))) if (this.getPath("app", "/") === this.getPath("src", pathChoice)) return this.namespace = namespace;
+		throw new RuntimeException("Unable to detect application namespace.");
+	}
+	/**
+	* Get the path of the app dir
+	* 
+	* @returns 
+	*/
+	path() {
+		return this.getPath("app");
+	}
+	/**
 	* Get the base path of the app
 	* 
 	* @returns 
@@ -593,52 +1186,14 @@ var Application = class Application extends Container {
 /**
 * Base controller class
 */
-var Controller = class {
+var Controller = class extends IController {
 	app;
 	constructor(app) {
+		super();
 		this.app = app;
 	}
 };
 
-//#endregion
-//#region src/Di/Inject.ts
-function Inject(...dependencies) {
-	return function(target) {
-		target.__inject__ = dependencies;
-	};
-}
-/**
-* Allows binding dependencies to both class and class methods 
-* 
-* @returns 
-*/
-function Injectable() {
-	return (...args) => {
-		if (args.length === 1) args[0];
-		if (args.length === 3) {
-			args[0];
-			args[1];
-			args[2];
-		}
-	};
-}
-
-//#endregion
-//#region src/Exceptions/ConfigException.ts
-var ConfigException = class extends Error {
-	key;
-	constructor(key, type = "config", cause) {
-		const info = {
-			any: `${key} not configured`,
-			env: `${key} environment variable not configured`,
-			config: `${key} config not set`
-		};
-		const message = Logger.log([["ERROR:", "bgRed"], [info[type], "white"]], " ", false);
-		super(message, { cause });
-		this.key = key;
-	}
-};
-
 //#endregion
 //#region src/H3ravel.ts
 /**
@@ -652,56 +1207,23 @@ const h3ravel = async (providers = [], basePath = process.cwd(), config = {
 	initialize: false,
 	autoload: false,
 	filteredProviders: []
-}, middleware = async () => void 0) => {
+}) => {
 	let h3App;
-	const app = new Application(basePath);
-	await app.quickStartup(providers, config.filteredProviders, config.autoload);
+	const app = new Application(basePath, "h3ravel");
+	if (config.customPaths) for (const [name, path$1] of Object.entries(config.customPaths)) app.setPath(name, path$1);
+	app.initialize(providers, config.filteredProviders, config.autoload);
 	try {
 		h3App = app.make("http.app");
-		app.context = async (event) => {
-			if (event._h3ravelContext) return event._h3ravelContext;
-			Request.enableHttpMethodParameterOverride();
-			const ctx = HttpContext$1.init({
-				app,
-				request: await Request.create(event, app),
-				response: new Response(event, app)
-			});
-			event._h3ravelContext = ctx;
-			return ctx;
-		};
-		const kernel = new Kernel(async (event) => app.context(event), [new LogRequests()]);
-		h3App.use((event) => kernel.handle(event, middleware));
+		app.setH3App(h3App);
+		app.singleton(IApplication, () => app);
+		if (!Facades.getApplication()) Facades.setApplication(app);
+		if (!Helpers.isLoaded()) Helpers.load(app);
+		await app.handleRequest(config);
 	} catch {
 		if (!h3App && config.h3) h3App = config.h3;
 	}
-	const originalFire = app.fire;
-	const proxyThis = (function makeProxy(appRef, orig) {
-		return new Proxy(appRef, {
-			get(target, prop, receiver) {
-				if (prop === "fire") return orig;
-				return Reflect.get(target, prop, receiver);
-			},
-			has(target, prop) {
-				if (prop === "fire") return true;
-				return Reflect.has(target, prop);
-			},
-			getOwnPropertyDescriptor(target, prop) {
-				if (prop === "fire") return {
-					configurable: true,
-					enumerable: false,
-					writable: true,
-					value: orig
-				};
-				return Reflect.getOwnPropertyDescriptor(target, prop);
-			}
-		});
-	})(app, originalFire);
-	if (config.initialize && h3App) return await Reflect.apply(originalFire, app, [h3App]);
-	app.fire = async function() {
-		if (!h3App) throw new ConfigException("Provide a H3 app instance in the config or install @h3ravel/http");
-		return await Reflect.apply(originalFire, proxyThis, [h3App]);
-	};
-	return app;
+	if (config.initialize && h3App) return await app.fire(h3App);
+	return app.setH3App(h3App);
 };
 
 //#endregion
@@ -712,12 +1234,23 @@ const h3ravel = async (providers = [], basePath = process.cwd(), config = {
 */
 var Kernel = class {
 	/**
-	* @param context - A factory function that converts an H3Event into an HttpContext.
+	* The router instance.
+	*/
+	router;
+	/**
+	* A factory function that converts an H3Event into an HttpContext.
+	*/
+	context;
+	applicationContext;
+	/**
+	* @param app - The current application instance
 	* @param middleware - An array of middleware classes that will be executed in sequence.
 	*/
-	constructor(context, middleware = []) {
-		this.context = context;
+	constructor(app, middleware = []) {
+		this.app = app;
 		this.middleware = middleware;
+		this.router = app.make("router");
+		this.context = async (event) => app.context(event);
 	}
 	/**
 	* Handles an incoming request and passes it through middleware before invoking the next handler.
@@ -727,145 +1260,45 @@ var Kernel = class {
 	* @returns A promise resolving to the result of the request pipeline.
 	*/
 	async handle(event, next) {
+		const { request } = await this.app.context(event);
 		/**
 		* Convert the raw event into a standardized HttpContext
 		*/
-		const ctx = await this.context(event);
-		const { app } = ctx.request;
-		/** 
-		* Bind HTTP Response instance to the service container
-		*/
-		app.bind("http.response", () => {
-			return ctx.response;
-		});
-		/** 
-		* Bind HTTP Request instance to the service container
+		this.applicationContext = await this.context(event);
+		/**
+		* Bind HttpContext, request, and response to the container
 		*/
-		app.bind("http.request", () => {
-			return ctx.request;
-		});
+		this.app.bind("http.context", () => this.applicationContext);
+		this.app.bind("http.request", () => this.applicationContext.request);
+		this.app.bind("http.response", () => this.applicationContext.response);
+		this.app.middlewareHandler = this.app.has(MiddlewareHandler) ? this.app.make(MiddlewareHandler) : new MiddlewareHandler([], this.app);
+		request.constructor.enableHttpMethodParameterOverride();
 		/**
 		* Run middleware stack and obtain result
 		*/
-		const result = await this.runMiddleware(ctx, () => next(ctx));
+		const result = await this.app.middlewareHandler.register(this.middleware).run(this.applicationContext, next);
 		/**
 		* If a plain object is returned from a controller or middleware,
 		* automatically set the JSON Content-Type header for the response.
 		*/
-		if (result !== void 0 && this.isPlainObject(result)) event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
+		if (result !== void 0 && Obj.isPlainObject(result, true) && !result?.headers) event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
 		return result;
 	}
 	/**
-	* Sequentially runs middleware in the order they were registered.
-	* 
-	* @param context - The standardized HttpContext.
-	* @param next - Callback to execute when middleware completes.
-	* @returns A promise resolving to the final handler's result.
-	*/
-	async runMiddleware(context, next) {
-		let index = -1;
-		const runner = async (i) => {
-			if (i <= index) throw new Error("next() called multiple times");
-			index = i;
-			const middleware = this.middleware[i];
-			if (middleware)
- /**
-			* Execute the current middleware and proceed to the next one
-			*/
-			return middleware.handle(context, () => runner(i + 1));
-			else
- /**
-			* If no more middleware, call the final handler
-			*/
-			return next(context);
-		};
-		return runner(0);
-	}
-	/**
-	* Utility function to determine if a value is a plain object or array.
-	* 
-	* @param value - The value to check.
-	* @returns True if the value is a plain object or array, otherwise false.
-	*/
-	isPlainObject(value) {
-		return typeof value === "object" && value !== null && (value.constructor === Object || value.constructor === Array);
-	}
-};
-
-//#endregion
-//#region src/ServiceProvider.ts
-const Inference = class {};
-var ServiceProvider = class extends Inference {
-	/**
-	* The current app instance
-	*/
-	app;
-	/**
-	* Unique Identifier for the service providers
-	*/
-	static uid;
-	/**
-	* Sort order
-	*/
-	static order;
-	/**
-	* Sort priority
-	*/
-	static priority = 0;
-	/**
-	* Indicate that this service provider only runs in console
-	*/
-	static console = false;
-	/**
-	* List of registered console commands
-	*/
-	registeredCommands;
-	constructor(app) {
-		super();
-		this.app = app;
-	}
-	/**
-	* Register the listed service providers.
-	* 
-	* @param commands An array of console commands to register.
-	* 
-	* @deprecated since version 1.16.0. Will be removed in future versions, use `registerCommands` instead
-	*/
-	commands(commands) {
-		this.registerCommands(commands);
-	}
-	/**
-	* Register the listed service providers.
-	* 
-	* @param commands An array of console commands to register.
+	* Resolve the provided callback using the current H3 event instance 
 	*/
-	registerCommands(commands) {
-		this.registeredCommands = commands;
-	}
-};
-
-//#endregion
-//#region src/Providers/CoreServiceProvider.ts
-/**
-* Bootstraps core services and bindings.
-* 
-* Bind essential services to the container (logger, config repository).
-* Register app-level singletons.
-* Set up exception handling.
-* 
-* Auto-Registered
-*/
-var CoreServiceProvider = class extends ServiceProvider {
-	static priority = 999;
-	register() {
-		Object.assign(globalThis, { str });
-	}
-	boot() {
-		try {
-			Object.assign(globalThis, { asset: this.app.make("asset") });
-		} catch {}
+	async resolve(event, middleware, handler) {
+		const { Response } = await import("@h3ravel/http");
+		this.middleware = Array.from(new Set([...this.middleware, ...Arr.wrap(middleware)]));
+		return this.handle(event, (ctx) => new Promise((resolve) => {
+			if (Resolver.isAsyncFunction(handler)) handler(ctx).then((response) => {
+				if (response instanceof Response) resolve(response.prepare(ctx.request).send());
+				else resolve(response);
+			});
+			else resolve(handler(ctx));
+		}));
 	}
 };
 
 //#endregion
-export { Application, ConfigException, Container, ContainerResolver, Controller, CoreServiceProvider, Inject, Injectable, Kernel, ProviderRegistry, Registerer, ServiceProvider, h3ravel };
+export { Application, Container, ContainerResolver, Controller, CoreServiceProvider, Inject, Injectable, Kernel, ProviderRegistry, Registerer, ServiceProvider, h3ravel };