@h3ravel/core 1.7.4 → 1.9.0

package/dist/index.js

@@ -1,438 +1,653 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import "reflect-metadata";
+import { Logger, PathLoader } from "@h3ravel/shared";
+import { dd, dump } from "@h3ravel/support";
+import path from "node:path";
+import chalk from "chalk";
+import { detect } from "detect-port";
+import dotenv from "dotenv";
+import dotenvExpand from "dotenv-expand";
+import { mkdir } from "node:fs/promises";
+import { Edge } from "edge.js";
 
-// src/Container.ts
+//#region src/Container.ts
 var Container = class {
-  static {
-    __name(this, "Container");
-  }
-  bindings = /* @__PURE__ */ new Map();
-  singletons = /* @__PURE__ */ new Map();
-  /**
-   * Check if the target has any decorators
-   * 
-   * @param target 
-   * @returns 
-   */
-  static hasAnyDecorator(target) {
-    if (Reflect.getMetadataKeys(target).length > 0) return true;
-    const paramLength = target.length;
-    for (let i = 0; i < paramLength; i++) {
-      if (Reflect.getMetadataKeys(target, `__param_${i}`).length > 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-  bind(key, factory) {
-    this.bindings.set(key, factory);
-  }
-  /**
-   * Bind a singleton service to the container
-   */
-  singleton(key, factory) {
-    this.bindings.set(key, () => {
-      if (!this.singletons.has(key)) {
-        this.singletons.set(key, factory());
-      }
-      return this.singletons.get(key);
-    });
-  }
-  /**
-   * Resolve a service from the container
-   */
-  make(key) {
-    if (this.bindings.has(key)) {
-      return this.bindings.get(key)();
-    }
-    if (typeof key === "function") {
-      return this.build(key);
-    }
-    throw new Error(`No binding found for key: ${typeof key === "string" ? key : key?.name}`);
-  }
-  /**
-   * Automatically build a class with constructor dependency injection
-   */
-  build(ClassType) {
-    let dependencies = [];
-    if (Array.isArray(ClassType.__inject__)) {
-      dependencies = ClassType.__inject__.map((alias) => {
-        return this.make(alias);
-      });
-    } else {
-      const paramTypes = Reflect.getMetadata("design:paramtypes", ClassType) || [];
-      dependencies = paramTypes.map((dep) => this.make(dep));
-    }
-    return new ClassType(...dependencies);
-  }
-  /**
-   * Check if a service is registered
-   */
-  has(key) {
-    return this.bindings.has(key);
-  }
+	bindings = /* @__PURE__ */ new Map();
+	singletons = /* @__PURE__ */ new Map();
+	/**
+	* Check if the target has any decorators
+	* 
+	* @param target 
+	* @returns 
+	*/
+	static hasAnyDecorator(target) {
+		if (Reflect.getMetadataKeys(target).length > 0) return true;
+		const paramLength = target.length;
+		for (let i = 0; i < paramLength; i++) if (Reflect.getMetadataKeys(target, `__param_${i}`).length > 0) return true;
+		return false;
+	}
+	bind(key, factory) {
+		this.bindings.set(key, factory);
+	}
+	/**
+	* Bind a singleton service to the container
+	*/
+	singleton(key, factory) {
+		this.bindings.set(key, () => {
+			if (!this.singletons.has(key)) this.singletons.set(key, factory());
+			return this.singletons.get(key);
+		});
+	}
+	/**
+	* Resolve a service from the container
+	*/
+	make(key) {
+		/**
+		* Direct factory binding
+		*/
+		if (this.bindings.has(key)) return this.bindings.get(key)();
+		/**
+		* 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}`);
+	}
+	/**
+	* Automatically build a class with constructor dependency injection
+	*/
+	build(ClassType) {
+		let dependencies = [];
+		if (Array.isArray(ClassType.__inject__)) dependencies = ClassType.__inject__.map((alias) => {
+			return this.make(alias);
+		});
+		else dependencies = (Reflect.getMetadata("design:paramtypes", ClassType) || []).map((dep) => this.make(dep));
+		return new ClassType(...dependencies);
+	}
+	/**
+	* Check if a service is registered
+	*/
+	has(key) {
+		return this.bindings.has(key);
+	}
 };
 
-// src/Application.ts
-import { PathLoader } from "@h3ravel/shared";
+//#endregion
+//#region src/Di/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) params = [_default];
+		/**
+		* Resolve the bound dependencies
+		*/
+		let args = params.filter((e) => ContainerResolver.isClass(e)).map((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";
+	}
+};
 
-// src/Registerer.ts
-import { dd, dump } from "@h3ravel/support";
-var Registerer = class {
-  static {
-    __name(this, "Registerer");
-  }
-  static register() {
-    globalThis.dd = dd;
-    globalThis.dump = dump;
-  }
+//#endregion
+//#region src/Registerer.ts
+var Registerer = class Registerer {
+	constructor(app) {
+		this.app = app;
+	}
+	static register(app) {
+		new Registerer(app).bootRegister();
+	}
+	bootRegister() {
+		globalThis.dd = dd;
+		globalThis.dump = dump;
+		globalThis.app_path = (path$1) => this.appPath(path$1);
+		globalThis.base_path = (path$1) => this.basePath(path$1);
+		globalThis.public_path = (path$1) => this.publicPath(path$1);
+		globalThis.storage_path = (path$1) => this.storagePath(path$1);
+		globalThis.database_path = (path$1) => this.databasePath(path$1);
+	}
+	appPath(path$1) {
+		return this.app.getPath("base", path.join(`/${process.env.SRC_PATH ?? "src"}/`.replace(/([^:]\/)\/+/g, "$1"), "app", path$1 ?? ""));
+	}
+	basePath(path$1) {
+		return this.app.getPath("base", path$1);
+	}
+	publicPath(path$1) {
+		return this.app.getPath("public", path$1);
+	}
+	storagePath(path$1) {
+		return this.app.getPath("base", path.join("storage", path$1 ?? ""));
+	}
+	databasePath(path$1) {
+		return this.app.getPath("database", path$1);
+	}
 };
 
-// src/Application.ts
-import dotenv from "dotenv";
-import path from "path";
-var Application = class _Application extends Container {
-  static {
-    __name(this, "Application");
-  }
-  paths = new PathLoader();
-  booted = false;
-  versions = {
-    app: "0",
-    ts: "0"
-  };
-  basePath;
-  providers = [];
-  externalProviders = [];
-  constructor(basePath) {
-    super();
-    this.basePath = basePath;
-    this.setPath("base", basePath);
-    this.loadOptions();
-    this.registerBaseBindings();
-    Registerer.register();
-    dotenv.config({
-      quiet: true
-    });
-  }
-  /**
-   * Register core bindings into the container
-   */
-  registerBaseBindings() {
-    this.bind(_Application, () => this);
-    this.bind("path.base", () => this.basePath);
-    this.bind("load.paths", () => this.paths);
-  }
-  /**
-   * Dynamically register all configured providers
-   */
-  async registerConfiguredProviders() {
-    const providers = await this.getAllProviders();
-    for (const ProviderClass of providers) {
-      if (!ProviderClass) continue;
-      const provider = new ProviderClass(this);
-      await this.register(provider);
-    }
-  }
-  async loadOptions() {
-    const app = await this.safeImport(this.getPath("base", "package.json"));
-    const core = await this.safeImport("../package.json");
-    if (app && app.dependencies) {
-      this.versions.app = app.dependencies["@h3ravel/core"];
-    }
-    if (core && core.devDependencies) {
-      this.versions.ts = app.devDependencies.typescript;
-    }
-  }
-  /**
-   * Load default and optional providers dynamically
-   * 
-   * Auto-Registration Behavior
-   * 
-   * Minimal App: Loads only core, config, http, router by default.
-   * Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
-   */
-  async getConfiguredProviders() {
-    return [
-      (await import("./index.js")).CoreServiceProvider,
-      (await import("./index.js")).ViewServiceProvider
-    ];
-  }
-  async getAllProviders() {
-    const coreProviders = await this.getConfiguredProviders();
-    const allProviders = [
-      ...coreProviders,
-      ...this.externalProviders
-    ];
-    const uniqueProviders = Array.from(new Set(allProviders));
-    return this.sortProviders(uniqueProviders);
-  }
-  sortProviders(providers) {
-    const priorityMap = /* @__PURE__ */ new Map();
-    providers.forEach((Provider) => {
-      priorityMap.set(Provider.name, Provider.priority ?? 0);
-    });
-    providers.forEach((Provider) => {
-      const order = Provider.order;
-      if (!order) return;
-      const [direction, target] = order.split(":");
-      const targetPriority = priorityMap.get(target) ?? 0;
-      if (direction === "before") {
-        priorityMap.set(Provider.name, targetPriority - 1);
-      } else if (direction === "after") {
-        priorityMap.set(Provider.name, targetPriority + 1);
-      }
-    });
-    const sorted = providers.sort((A, B) => (priorityMap.get(B.name) ?? 0) - (priorityMap.get(A.name) ?? 0));
-    if (process.env.APP_DEBUG === "true") {
-      console.table(sorted.map((P) => ({
-        Provider: P.name,
-        Priority: priorityMap.get(P.name),
-        Order: P.order || "N/A"
-      })));
-    }
-    return sorted;
-  }
-  registerProviders(providers) {
-    this.externalProviders.push(...providers);
-  }
-  /**
-   * Register a provider
-   */
-  async register(provider) {
-    await provider.register();
-    this.providers.push(provider);
-  }
-  /**
-   * Boot all providers after registration
-   */
-  async boot() {
-    if (this.booted) return;
-    for (const provider of this.providers) {
-      if (provider.boot) {
-        await provider.boot();
-      }
-    }
-    this.booted = true;
-  }
-  /**
-   * Attempt to dynamically import an optional module
-   */
-  async safeImport(moduleName) {
-    try {
-      const mod = await import(moduleName);
-      return mod.default ?? mod ?? {};
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get the base path of the app
-   * 
-   * @returns 
-   */
-  getBasePath() {
-    return this.basePath;
-  }
-  /**
-   * Dynamically retrieves a path property from the class.
-   * Any property ending with "Path" is accessible automatically.
-   *
-   * @param name - The base name of the path property
-   * @returns 
-   */
-  getPath(name, pth) {
-    return path.join(this.paths.getPath(name, this.basePath), pth ?? "");
-  }
-  /**
-   * Programatically set the paths.
-   *
-   * @param name - The base name of the path property
-   * @param path - The new path
-   * @returns 
-   */
-  setPath(name, path2) {
-    return this.paths.setPath(name, path2, this.basePath);
-  }
-  /**
-   * Returns the installed version of the system core and typescript.
-   *
-   * @returns 
-   */
-  getVersion(key) {
-    return this.versions[key]?.replaceAll(/\^|~/g, "");
-  }
+//#endregion
+//#region src/Application.ts
+var Application = class Application extends Container {
+	paths = new PathLoader();
+	tries = 0;
+	booted = false;
+	versions = {
+		app: "0",
+		ts: "0"
+	};
+	basePath;
+	providers = [];
+	externalProviders = [];
+	/**
+	* List of registered console commands
+	*/
+	registeredCommands = [];
+	constructor(basePath) {
+		super();
+		dotenvExpand.expand(dotenv.config({ quiet: true }));
+		this.basePath = basePath;
+		this.setPath("base", basePath);
+		this.loadOptions();
+		this.registerBaseBindings();
+		Registerer.register(this);
+	}
+	/**
+	* Register core bindings into the container
+	*/
+	registerBaseBindings() {
+		this.bind(Application, () => this);
+		this.bind("path.base", () => this.basePath);
+		this.bind("load.paths", () => this.paths);
+	}
+	/**
+	* Dynamically register all configured providers
+	*/
+	async registerConfiguredProviders() {
+		const providers = await this.getAllProviders();
+		for (const ProviderClass of providers) {
+			if (!ProviderClass) continue;
+			const provider = new ProviderClass(this);
+			await this.register(provider);
+		}
+	}
+	async loadOptions() {
+		const app = await this.safeImport(this.getPath("base", "package.json"));
+		const core = await this.safeImport("../package.json");
+		if (app && app.dependencies) this.versions.app = app.dependencies["@h3ravel/core"];
+		if (core && core.devDependencies) this.versions.ts = app.devDependencies.typescript;
+	}
+	/**
+	* Get all registered providers
+	*/
+	getRegisteredProviders() {
+		return this.providers;
+	}
+	/**
+	* Load default and optional providers dynamically
+	* 
+	* Auto-Registration Behavior
+	* 
+	* Minimal App: Loads only core, config, http, router by default.
+	* Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
+	*/
+	async getConfiguredProviders() {
+		return [(await import("./index.js")).CoreServiceProvider, (await import("./index.js")).ViewServiceProvider];
+	}
+	async getAllProviders() {
+		const allProviders = [...await this.getConfiguredProviders(), ...this.externalProviders];
+		/**
+		* Deduplicate by class reference
+		*/
+		const uniqueProviders = Array.from(new Set(allProviders));
+		return this.sortProviders(uniqueProviders);
+	}
+	sortProviders(providers) {
+		const priorityMap = /* @__PURE__ */ new Map();
+		/**
+		* Base priority (default 0)
+		*/
+		providers.forEach((Provider) => {
+			priorityMap.set(Provider.name, Provider.priority ?? 0);
+		});
+		/**
+		* Handle before/after adjustments
+		*/
+		providers.forEach((Provider) => {
+			const order = Provider.order;
+			if (!order) return;
+			const [direction, target] = order.split(":");
+			const targetPriority = priorityMap.get(target) ?? 0;
+			if (direction === "before") priorityMap.set(Provider.name, targetPriority - 1);
+			else if (direction === "after") priorityMap.set(Provider.name, targetPriority + 1);
+		});
+		/**
+		* Service providers sorted based on thier name and priority
+		*/
+		const sorted = providers.sort((A, B) => (priorityMap.get(B.name) ?? 0) - (priorityMap.get(A.name) ?? 0));
+		/**
+		* If debug is enabled, let's show the loaded service provider info
+		*/
+		if (process.env.APP_DEBUG === "true" && process.env.EXTENDED_DEBUG !== "false" && !sorted.some((e) => e.console)) {
+			console.table(sorted.map((P) => ({
+				Provider: P.name,
+				Priority: priorityMap.get(P.name),
+				Order: P.order || "N/A"
+			})));
+			console.info(`Set ${chalk.bgCyan(" APP_DEBUG = false ")} in your .env file to hide this information`, "\n");
+		}
+		return sorted;
+	}
+	registerProviders(providers) {
+		this.externalProviders.push(...providers);
+	}
+	/**
+	* Register a provider
+	*/
+	async register(provider) {
+		await new ContainerResolver(this).resolveMethodParams(provider, "register", this);
+		if (provider.registeredCommands && provider.registeredCommands.length > 0) this.registeredCommands.push(...provider.registeredCommands);
+		this.providers.push(provider);
+	}
+	/**
+	* checks if the application is running in CLI
+	*/
+	runningInConsole() {
+		return typeof process !== "undefined" && !!process.stdout && !!process.stdin;
+	}
+	getRuntimeEnv() {
+		if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+		if (typeof process !== "undefined" && process.versions?.node) return "node";
+		return "unknown";
+	}
+	/**
+	* Boot all service providers after registration
+	*/
+	async boot() {
+		if (this.booted) return;
+		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
+ /**
+		* Otherwise instantiate manually so that we can at least
+		* pass the app instance
+		*/
+		await provider.boot(this);
+		this.booted = true;
+	}
+	/**
+	* 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 fire(h3App, preferedPort) {
+		const serve = this.make("http.serve");
+		const port = preferedPort ?? 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, {
+					port,
+					hostname,
+					silent: true
+				});
+				Logger.parse([[`🚀 H3ravel running at:`, "green"], [`${server.options.protocol ?? "http"}://${server.options.hostname}:${server.options.port}`, "cyan"]]);
+			} else if (this.tries <= tries) {
+				await this.fire(h3App, realPort);
+				this.tries++;
+			} else Logger.parse([["ERROR:", "bgRed"], ["No free port available", "red"]]);
+		} catch (e) {
+			Logger.parse([
+				["An error occured", "bgRed"],
+				[e.message, "red"],
+				[e.stack, "red"]
+			], "\n");
+		}
+	}
+	/**
+	* Attempt to dynamically import an optional module
+	*/
+	async safeImport(moduleName) {
+		try {
+			const mod = await import(moduleName);
+			return mod.default ?? mod ?? {};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get the base path of the app
+	* 
+	* @returns 
+	*/
+	getBasePath() {
+		return this.basePath;
+	}
+	/**
+	* Dynamically retrieves a path property from the class.
+	* Any property ending with "Path" is accessible automatically.
+	*
+	* @param name - The base name of the path property
+	* @returns 
+	*/
+	getPath(name, suffix) {
+		return path.join(this.paths.getPath(name, this.basePath), suffix ?? "");
+	}
+	/**
+	* Programatically set the paths.
+	*
+	* @param name - The base name of the path property
+	* @param path - The new path
+	* @returns 
+	*/
+	setPath(name, path$1) {
+		return this.paths.setPath(name, path$1, this.basePath);
+	}
+	/**
+	* Returns the installed version of the system core and typescript.
+	*
+	* @returns 
+	*/
+	getVersion(key) {
+		return this.versions[key]?.replaceAll(/\^|~/g, "");
+	}
+};
+
+//#endregion
+//#region src/Console/ConsoleCommand.ts
+var ConsoleCommand = class {
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	/**
+	* The underlying commander instance.
+	*
+	* @var Command
+	*/
+	program;
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature;
+	/**
+	* A dictionary of signatures or what not.
+	*
+	* @var object
+	*/
+	dictionary = {};
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description;
+	/**
+	* The console command input.
+	*
+	* @var object
+	*/
+	input = {
+		options: {},
+		arguments: {}
+	};
+	/**
+	* Execute the console command.
+	*/
+	async handle(..._args) {}
+	setApplication(app) {
+		this.app = app;
+	}
+	setInput(options, args, regArgs, dictionary, program) {
+		this.program = program;
+		this.dictionary = dictionary;
+		this.input.options = options;
+		this.input.arguments = regArgs.map((e, i) => ({ [e.name()]: args[i] })).reduce((e, x) => Object.assign(e, x), {});
+	}
+	getSignature() {
+		return this.signature;
+	}
+	getDescription() {
+		return this.description;
+	}
+	option(key, def) {
+		return this.input.options[key] ?? def;
+	}
+	options(key) {
+		if (key) return this.input.options[key];
+		return this.input.options;
+	}
+	argument(key, def) {
+		return this.input.arguments[key] ?? def;
+	}
+	arguments() {
+		return this.input.arguments;
+	}
+};
+
+//#endregion
+//#region src/Console/ConsoleKernel.ts
+var ConsoleKernel = class {
+	cwd;
+	output = typeof Logger;
+	basePath = "";
+	modulePath;
+	consolePath;
+	modulePackage;
+	consolePackage;
+	constructor(app) {
+		this.app = app;
+	}
+	async ensureDirectoryExists(dir) {
+		await mkdir(dir, { recursive: true });
+	}
 };
 
-// src/Controller.ts
+//#endregion
+//#region src/Controller.ts
+/**
+* Base controller class
+*/
 var Controller = class {
-  static {
-    __name(this, "Controller");
-  }
-  app;
-  constructor(app) {
-    this.app = app;
-  }
-  show(..._ctx) {
-    return;
-  }
-  index(..._ctx) {
-    return;
-  }
-  store(..._ctx) {
-    return;
-  }
-  update(..._ctx) {
-    return;
-  }
-  destroy(..._ctx) {
-    return;
-  }
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	show(..._ctx) {}
+	index(..._ctx) {}
+	store(..._ctx) {}
+	update(..._ctx) {}
+	destroy(..._ctx) {}
 };
 
-// src/Di/Inject.ts
+//#endregion
+//#region src/Di/Inject.ts
 function Inject(...dependencies) {
-  return function(target) {
-    target.__inject__ = dependencies;
-  };
+	return function(target) {
+		target.__inject__ = dependencies;
+	};
 }
-__name(Inject, "Inject");
+/**
+* Allows binding dependencies to both class and class methods 
+* 
+* @returns 
+*/
 function Injectable() {
-  return (...args) => {
-    if (args.length === 1) {
-      void args[0];
-    }
-    if (args.length === 3) {
-      void args[0];
-      void args[1];
-      void args[2];
-    }
-  };
+	return (...args) => {
+		if (args.length === 1) args[0];
+		if (args.length === 3) {
+			args[0];
+			args[1];
+			args[2];
+		}
+	};
 }
-__name(Injectable, "Injectable");
 
-// src/Http/Kernel.ts
+//#endregion
+//#region src/Http/Kernel.ts
+/**
+* Kernel class handles middleware execution and response transformations.
+* It acts as the core middleware pipeline for HTTP requests.
+*/
 var Kernel = class {
-  static {
-    __name(this, "Kernel");
-  }
-  context;
-  middleware;
-  /**
-   * @param context - A factory function that converts an H3Event into an HttpContext.
-   * @param middleware - An array of middleware classes that will be executed in sequence.
-   */
-  constructor(context, middleware = []) {
-    this.context = context;
-    this.middleware = middleware;
-  }
-  /**
-   * Handles an incoming request and passes it through middleware before invoking the next handler.
-   * 
-   * @param event - The raw H3 event object.
-   * @param next - A callback function that represents the next layer (usually the controller or final handler).
-   * @returns A promise resolving to the result of the request pipeline.
-   */
-  async handle(event, next) {
-    const ctx = this.context(event);
-    const { app } = ctx.request;
-    app.bind("view", () => async (template, params) => {
-      const edge = app.make("edge");
-      return ctx.response.html(await edge.render(template, params));
-    });
-    const result = await this.runMiddleware(ctx, () => next(ctx));
-    if (result !== void 0 && this.isPlainObject(result)) {
-      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 = /* @__PURE__ */ __name(async (i) => {
-      if (i <= index) throw new Error("next() called multiple times");
-      index = i;
-      const middleware = this.middleware[i];
-      if (middleware) {
-        return middleware.handle(context, () => runner(i + 1));
-      } else {
-        return next(context);
-      }
-    }, "runner");
-    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);
-  }
+	/**
+	* @param context - A factory function that converts an H3Event into an HttpContext.
+	* @param middleware - An array of middleware classes that will be executed in sequence.
+	*/
+	constructor(context, middleware = []) {
+		this.context = context;
+		this.middleware = middleware;
+	}
+	/**
+	* Handles an incoming request and passes it through middleware before invoking the next handler.
+	* 
+	* @param event - The raw H3 event object.
+	* @param next - A callback function that represents the next layer (usually the controller or final handler).
+	* @returns A promise resolving to the result of the request pipeline.
+	*/
+	async handle(event, next) {
+		/**
+		* Convert the raw event into a standardized HttpContext
+		*/
+		const ctx = this.context(event);
+		const { app } = ctx.request;
+		/**
+		* Dynamically bind the view renderer to the service container.
+		* This allows any part of the request lifecycle to render templates using Edge.
+		*/
+		app.bind("view", () => async (template, params) => {
+			const edge = app.make("edge");
+			return ctx.response.html(await edge.render(template, params));
+		});
+		/**
+		* Run middleware stack and obtain result
+		*/
+		const result = await this.runMiddleware(ctx, () => next(ctx));
+		/**
+		* 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");
+		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);
+	}
 };
 
-// src/Providers/CoreServiceProvider.ts
-import "reflect-metadata";
-
-// src/ServiceProvider.ts
+//#endregion
+//#region src/ServiceProvider.ts
 var ServiceProvider = class {
-  static {
-    __name(this, "ServiceProvider");
-  }
-  static order;
-  static priority = 0;
-  app;
-  constructor(app) {
-    this.app = app;
-  }
+	/**
+	* 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;
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	/**
+	* An array of console commands to register.
+	*/
+	commands(commands) {
+		this.registeredCommands = commands;
+	}
 };
 
-// src/Providers/CoreServiceProvider.ts
+//#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 {
-    __name(this, "CoreServiceProvider");
-  }
-  static priority = 999;
-  register() {
-  }
+	static priority = 999;
+	register() {}
 };
 
-// src/Providers/ViewServiceProvider.ts
-import { Edge } from "edge.js";
+//#endregion
+//#region src/Providers/ViewServiceProvider.ts
 var ViewServiceProvider = class extends ServiceProvider {
-  static {
-    __name(this, "ViewServiceProvider");
-  }
-  static priority = 995;
-  register() {
-    const config = this.app.make("config");
-    const edge = Edge.create({
-      cache: process.env.NODE_ENV === "production"
-    });
-    edge.mount(this.app.getPath("views"));
-    edge.global("asset", this.app.make("asset"));
-    edge.global("config", config.get);
-    edge.global("app", this.app);
-    this.app.bind("edge", () => edge);
-  }
-};
-export {
-  Application,
-  Container,
-  Controller,
-  CoreServiceProvider,
-  Inject,
-  Injectable,
-  Kernel,
-  Registerer,
-  ServiceProvider,
-  ViewServiceProvider
+	static priority = 995;
+	register() {
+		const config = this.app.make("config");
+		const edge = Edge.create({ cache: process.env.NODE_ENV === "production" });
+		edge.mount(this.app.getPath("views"));
+		edge.global("asset", this.app.make("asset"));
+		edge.global("config", config.get);
+		edge.global("app", this.app);
+		this.app.bind("edge", () => edge);
+	}
 };
+
+//#endregion
+export { Application, ConsoleCommand, ConsoleKernel, Container, ContainerResolver, Controller, CoreServiceProvider, Inject, Injectable, Kernel, Registerer, ServiceProvider, ViewServiceProvider };
 //# sourceMappingURL=index.js.map