@avleon/core 0.0.46 → 0.0.49

package/dist/index.cjs

@@ -0,0 +1,3194 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+let class_validator = require("class-validator");
+let typedi = require("typedi");
+typedi = require_chunk.__toESM(typedi);
+require("reflect-metadata");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
+let class_transformer = require("class-transformer");
+let fastify = require("fastify");
+fastify = require_chunk.__toESM(fastify);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let mime = require("mime");
+mime = require_chunk.__toESM(mime);
+let node_stream = require("node:stream");
+node_stream = require_chunk.__toESM(node_stream);
+let node_async_hooks = require("node:async_hooks");
+let bull = require("bull");
+bull = require_chunk.__toESM(bull);
+let node_stream_promises = require("node:stream/promises");
+let dotenv = require("dotenv");
+dotenv = require_chunk.__toESM(dotenv);
+let pino = require("pino");
+pino = require_chunk.__toESM(pino);
+//#region src/container.ts
+function registerController(controller) {
+	controllerRegistry.add(controller);
+}
+function registerService(service) {
+	typedi.Container.set(service, service);
+	serviceRegistry.add(service);
+}
+function getRegisteredServices() {
+	return Array.from(serviceRegistry);
+}
+function getRegisteredControllers() {
+	return Array.from(controllerRegistry);
+}
+function isApiController(target) {
+	return Reflect.getMetadata(API_CONTROLLER_METADATA_KEY, target) === true;
+}
+function registerDataSource(dataSource) {
+	typedi.Container.set("idatasource", dataSource);
+}
+function registerKnex(dataSource) {
+	typedi.Container.set("KnexConnection", dataSource);
+}
+var FEATURE_KEY, ROUTE_META_KEY, CONTROLLER_META_KEY, PARAM_META_KEY, QUERY_META_KEY, REQUEST_BODY_META_KEY, REQUEST_BODY_FILE_KEY, REQUEST_BODY_FILES_KEY, REQUEST_USER_META_KEY, REQUEST_HEADER_META_KEY, DATASOURCE_META_KEY, AUTHORIZATION_META_KEY, controllerRegistry, serviceRegistry, API_CONTROLLER_METADATA_KEY, container_default;
+var init_container = require_chunk.__esmMin((() => {
+	FEATURE_KEY = Symbol.for("features");
+	ROUTE_META_KEY = Symbol("iroute:options");
+	CONTROLLER_META_KEY = Symbol("icontroller:options");
+	PARAM_META_KEY = Symbol("iparam:options");
+	QUERY_META_KEY = Symbol("iparam:options");
+	REQUEST_BODY_META_KEY = Symbol("iparam:options");
+	REQUEST_BODY_FILE_KEY = Symbol("iparam:options");
+	REQUEST_BODY_FILES_KEY = Symbol("iparam:options");
+	REQUEST_USER_META_KEY = Symbol("iparam:options");
+	REQUEST_HEADER_META_KEY = Symbol("iheader:options");
+	DATASOURCE_META_KEY = Symbol("idatasource:options");
+	AUTHORIZATION_META_KEY = Symbol("idatasource:authorization");
+	controllerRegistry = /* @__PURE__ */ new Set();
+	serviceRegistry = /* @__PURE__ */ new Set();
+	API_CONTROLLER_METADATA_KEY = Symbol("apiController");
+	typedi.Container.set("appName", "Iqra");
+	container_default = typedi.Container;
+}));
+//#endregion
+//#region src/swagger-schema.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_container();
+function OpenApiProperty$1(options) {
+	return function(target, propertyKey) {
+		let meta = options ? { ...options } : {};
+		if (meta.format === "binary") if (meta.isArray) meta = {
+			...meta,
+			type: "array",
+			items: meta.items ?? {
+				type: "string",
+				format: "binary"
+			},
+			description: meta.description || "Array of files"
+		};
+		else meta = {
+			...meta,
+			type: "string",
+			format: "binary",
+			description: meta.description || "File upload"
+		};
+		Reflect.defineMetadata("property:openapi", meta, target, propertyKey);
+	};
+}
+function extractOpenApiFields(meta) {
+	const result = {};
+	const jsonSchemaFields = [
+		"description",
+		"deprecated",
+		"example",
+		"enum",
+		"format",
+		"default",
+		"minimum",
+		"maximum",
+		"minLength",
+		"maxLength",
+		"pattern",
+		"oneOf",
+		"allOf",
+		"anyOf",
+		"title",
+		"readOnly",
+		"writeOnly",
+		"nullable"
+	];
+	const validFormats = [
+		"date-time",
+		"date",
+		"time",
+		"duration",
+		"email",
+		"idn-email",
+		"hostname",
+		"idn-hostname",
+		"ipv4",
+		"ipv6",
+		"uri",
+		"uri-reference",
+		"iri",
+		"iri-reference",
+		"uuid",
+		"uri-template",
+		"json-pointer",
+		"relative-json-pointer",
+		"regex",
+		"int32",
+		"int64",
+		"float",
+		"double",
+		"byte",
+		"binary",
+		"password"
+	];
+	jsonSchemaFields.forEach((field) => {
+		if (meta[field] !== void 0) if (field === "format") {
+			const formatValue = meta[field];
+			if (validFormats.includes(formatValue)) result[field] = formatValue;
+		} else result[field] = meta[field];
+	});
+	return result;
+}
+function CreateSwaggerObjectSchema(classType) {
+	const validationMetadata = (0, class_validator.getMetadataStorage)().getTargetValidationMetadatas(classType, "", true, false);
+	const schema = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	const prototype = classType.prototype;
+	const propertyKeys = /* @__PURE__ */ new Set();
+	Object.getOwnPropertyNames(prototype).forEach((k) => propertyKeys.add(k));
+	Object.keys(prototype).forEach((k) => propertyKeys.add(k));
+	validationMetadata.forEach((m) => propertyKeys.add(m.propertyName));
+	try {
+		const instance = new classType();
+		Reflect.ownKeys(instance).forEach((k) => {
+			if (typeof k === "string") propertyKeys.add(k);
+		});
+	} catch (_) {}
+	propertyKeys.forEach((propertyName) => {
+		if (!propertyName || propertyName === "constructor") return;
+		const openApiMeta = Reflect.getMetadata("property:openapi", prototype, propertyName);
+		if (openApiMeta?.exclude) return;
+		const propertyType = Reflect.getMetadata("design:type", prototype, propertyName);
+		let swaggerProperty = {};
+		switch (propertyType) {
+			case String:
+				swaggerProperty.type = "string";
+				break;
+			case Number:
+				swaggerProperty.type = "number";
+				break;
+			case Boolean:
+				swaggerProperty.type = "boolean";
+				break;
+			case Date:
+				swaggerProperty.type = "string";
+				swaggerProperty.format = "date-time";
+				break;
+			case Array:
+				swaggerProperty.type = "array";
+				swaggerProperty.items = { type: "string" };
+				break;
+			case Object:
+				swaggerProperty = CreateSwaggerObjectSchema(propertyType);
+				break;
+			default: if (propertyType && typeof propertyType === "function") swaggerProperty.$ref = `#/components/schemas/${propertyType.name}`;
+			else swaggerProperty.type = propertyType?.name?.toLowerCase() || "string";
+		}
+		if (openApiMeta) {
+			swaggerProperty = {
+				...swaggerProperty,
+				...openApiMeta,
+				...extractOpenApiFields(openApiMeta)
+			};
+			if (openApiMeta.format === "binary") if (openApiMeta.isArray || propertyType === Array) swaggerProperty = {
+				type: "array",
+				items: {
+					type: "string",
+					format: "binary"
+				},
+				description: openApiMeta.description || "Array of files"
+			};
+			else swaggerProperty = {
+				type: "string",
+				format: "binary",
+				description: openApiMeta.description || "File upload"
+			};
+		}
+		schema.properties[propertyName] = swaggerProperty;
+	});
+	validationMetadata.forEach((meta) => {
+		const propertyName = meta.propertyName;
+		const property = schema.properties[propertyName];
+		if (!property) return;
+		switch (meta.name) {
+			case "isNotEmpty":
+			case "isDefined":
+				if (!schema.required.includes(propertyName)) schema.required.push(propertyName);
+				break;
+			case "isOptional":
+				schema.required = schema.required.filter((item) => item !== propertyName);
+				break;
+			case "minLength":
+				property.minLength = meta.constraints[0];
+				break;
+			case "maxLength":
+				property.maxLength = meta.constraints[0];
+				break;
+			case "min":
+				property.minimum = meta.constraints[0];
+				break;
+			case "max":
+				property.maximum = meta.constraints[0];
+				break;
+			case "isEmail":
+				property.format = "email";
+				break;
+			case "isDate":
+				property.format = "date-time";
+				break;
+			case "isIn":
+				property.enum = meta.constraints[0];
+				break;
+			case "isNumber":
+				property.type = "number";
+				break;
+			case "isInt":
+				property.type = "integer";
+				break;
+			case "isBoolean":
+				property.type = "boolean";
+				break;
+			case "isString":
+				property.type = "string";
+				break;
+		}
+	});
+	if (schema.required.length === 0) delete schema.required;
+	return schema;
+}
+function generateClassSchema(classType) {
+	const schema = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	if (!classType || !classType.prototype) return schema;
+	const validationMetadata = (0, class_validator.getMetadataStorage)().getTargetValidationMetadatas(classType, "", true, false);
+	const prototype = classType.prototype;
+	const propertyKeys = new Set([...Object.getOwnPropertyNames(prototype), ...validationMetadata.map((m) => m.propertyName)]);
+	try {
+		const instance = new classType();
+		Reflect.ownKeys(instance).forEach((k) => {
+			if (typeof k === "string") propertyKeys.add(k);
+		});
+	} catch (_) {}
+	propertyKeys.forEach((propertyName) => {
+		if (!propertyName || propertyName === "constructor") return;
+		const openApiMeta = Reflect.getMetadata("property:openapi", prototype, propertyName);
+		if (openApiMeta?.exclude) return;
+		const propertyType = Reflect.getMetadata("design:type", prototype, propertyName);
+		let swaggerProperty = {};
+		switch (propertyType) {
+			case String:
+				swaggerProperty.type = "string";
+				break;
+			case Number:
+				swaggerProperty.type = "number";
+				break;
+			case Boolean:
+				swaggerProperty.type = "boolean";
+				break;
+			case Date:
+				swaggerProperty.type = "string";
+				swaggerProperty.format = "date-time";
+				break;
+			case Array:
+				swaggerProperty.type = "array";
+				swaggerProperty.items = { type: "string" };
+				break;
+			case Object:
+				swaggerProperty = generateClassSchema(propertyType);
+				break;
+			default: if (propertyType && typeof propertyType === "function") swaggerProperty.$ref = `#/components/schemas/${propertyType.name}`;
+			else swaggerProperty.type = propertyType?.name?.toLowerCase() || "string";
+		}
+		if (openApiMeta) {
+			const { required: _required, exclude: _exclude, isArray: _isArray, ...safeOpenApiMeta } = openApiMeta;
+			swaggerProperty = {
+				...swaggerProperty,
+				...extractOpenApiFields(safeOpenApiMeta)
+			};
+		}
+		schema.properties[propertyName] = swaggerProperty;
+	});
+	validationMetadata.forEach((meta) => {
+		const propertyName = meta.propertyName;
+		if (!schema.properties[propertyName]) schema.properties[propertyName] = { type: "string" };
+		switch (meta.name) {
+			case "isNotEmpty":
+			case "isDefined":
+				if (!schema.required.includes(propertyName)) schema.required.push(propertyName);
+				break;
+			case "isOptional":
+				schema.required = schema.required.filter((item) => item !== propertyName);
+				break;
+			case "minLength":
+				schema.properties[propertyName].minLength = meta.constraints[0];
+				break;
+			case "maxLength":
+				schema.properties[propertyName].maxLength = meta.constraints[0];
+				break;
+			case "min":
+				schema.properties[propertyName].minimum = meta.constraints[0];
+				break;
+			case "max":
+				schema.properties[propertyName].maximum = meta.constraints[0];
+				break;
+			case "isEmail":
+				schema.properties[propertyName].format = "email";
+				break;
+			case "isDate":
+				schema.properties[propertyName].format = "date-time";
+				break;
+			case "isIn":
+				schema.properties[propertyName].enum = meta.constraints[0];
+				break;
+			case "isNumber":
+				schema.properties[propertyName].type = "number";
+				break;
+			case "isInt":
+				schema.properties[propertyName].type = "integer";
+				break;
+			case "isBoolean":
+				schema.properties[propertyName].type = "boolean";
+				break;
+			case "isString":
+				schema.properties[propertyName].type = "string";
+				break;
+		}
+	});
+	if (schema.required.length === 0) delete schema.required;
+	return schema;
+}
+function generateSwaggerSchema(controllers) {
+	if (!Array.isArray(controllers)) return generateClassSchema(controllers);
+	const components = {};
+	for (const controller of controllers) {
+		if (!controller || typeof controller !== "function") continue;
+		if (!controller.prototype) continue;
+		if (Reflect.getMetadata(CONTROLLER_META_KEY, controller)) continue;
+		if (!Reflect.getMetadata("openapi:schema", controller)) continue;
+		components[controller.name] = generateClassSchema(controller);
+	}
+	return { components: Object.keys(components).length > 0 ? { schemas: components } : void 0 };
+}
+function OpenApiResponse$1(code = 200, model, description = "Successful response") {
+	let dataSchema;
+	if (typeof model === "function") dataSchema = generateClassSchema(model);
+	else if (model && typeof model === "object") dataSchema = inferSchemaFromExample(model);
+	else dataSchema = { type: "string" };
+	let message = "OK";
+	switch (code) {
+		case 400:
+			message = "Error";
+			description = "Error: Bad Request";
+			break;
+		case 401:
+			message = "Error";
+			description = "Error: Unauthorized";
+			break;
+		case 403:
+			message = "Error";
+			description = "Error: Forbidden";
+			break;
+		case 201:
+			message = "Created";
+			description = "Success: Created";
+			break;
+		case 500:
+			message = "Error";
+			description = "Error: InternalError";
+			break;
+	}
+	return {
+		description,
+		content: { "application/json": { schema: {
+			type: "object",
+			properties: {
+				code: {
+					type: "number",
+					example: code
+				},
+				status: {
+					type: "string",
+					example: message
+				},
+				data: dataSchema
+			}
+		} } }
+	};
+}
+function inferSchemaFromExample(obj) {
+	if (Array.isArray(obj)) return {
+		type: "array",
+		items: inferSchemaFromExample(obj[0] ?? {})
+	};
+	if (obj && typeof obj === "object") {
+		const properties = {};
+		for (const [key, value] of Object.entries(obj)) properties[key] = inferType(value);
+		return {
+			type: "object",
+			properties
+		};
+	}
+	return inferType(obj);
+}
+function inferType(value) {
+	switch (typeof value) {
+		case "string": return {
+			type: "string",
+			example: value
+		};
+		case "number": return {
+			type: "number",
+			example: value
+		};
+		case "boolean": return {
+			type: "boolean",
+			example: value
+		};
+		case "object":
+			if (Array.isArray(value)) return inferSchemaFromExample(value);
+			if (value === null) return { type: "null" };
+			return inferSchemaFromExample(value);
+		default: return { type: "string" };
+	}
+}
+//#endregion
+//#region src/controller.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_container();
+const REQUEST_METADATA_KEY = Symbol("avleon:request");
+function AvleonRequest() {
+	return (target, propertyKey, parameterIndex) => {
+		const existingParams = Reflect.getMetadata(REQUEST_METADATA_KEY, target, propertyKey) || [];
+		existingParams.push({
+			index: parameterIndex,
+			type: "request"
+		});
+		Reflect.defineMetadata(REQUEST_METADATA_KEY, existingParams, target, propertyKey);
+	};
+}
+function createControllerDecorator(type = "web") {
+	return function(pathOrOptions, maybeOptions) {
+		return function(target) {
+			let path = "/";
+			let options = {};
+			if (typeof pathOrOptions === "string") {
+				path = pathOrOptions;
+				options = maybeOptions || {};
+			} else if (typeof pathOrOptions === "object") {
+				options = pathOrOptions;
+				path = options.path || "/";
+			}
+			Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, target);
+			if (typeof typedi.Service === "function") {
+				registerController(target);
+				(0, typedi.Service)()(target);
+				Reflect.defineMetadata(CONTROLLER_META_KEY, {
+					type,
+					path,
+					options
+				}, target);
+			} else throw new Error("Service decorator is not a function");
+		};
+	};
+}
+function ApiController(pathOrOptions = "/", mayBeOptions) {
+	if (typeof pathOrOptions == "function") {
+		Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
+		if (typeof typedi.Service === "function") {
+			registerController(pathOrOptions);
+			(0, typedi.Service)()(pathOrOptions);
+			Reflect.defineMetadata(CONTROLLER_META_KEY, {
+				type: "api",
+				path: "/",
+				options: {}
+			}, pathOrOptions);
+		} else throw new Error("Service decorator is not a function");
+	} else {
+		if (mayBeOptions) return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
+		return createControllerDecorator("api")(pathOrOptions);
+	}
+}
+//#endregion
+//#region src/route-methods.ts
+init_container();
+/**
+* Generic Route decorator factory
+*/
+function Route(method, pathOrOptions, maybeOptions) {
+	return function(target, propertyKey, descriptor) {
+		let path = "/";
+		let options = {};
+		if (typeof pathOrOptions === "string") {
+			path = pathOrOptions || "/";
+			options = maybeOptions || {};
+		} else if (typeof pathOrOptions === "object" && pathOrOptions !== null) {
+			options = pathOrOptions;
+			path = options.path || options.name || "/";
+		} else {
+			options = maybeOptions || {};
+			path = "/";
+		}
+		path = typeof path === "string" ? path : "/";
+		Reflect.defineMetadata("route:path", path, target, propertyKey);
+		Reflect.defineMetadata("route:method", method, target, propertyKey);
+		Reflect.defineMetadata(ROUTE_META_KEY, {
+			...options,
+			method,
+			path,
+			controller: target.constructor.name
+		}, target, propertyKey);
+		if (options) Reflect.defineMetadata("route:options", options, target, propertyKey);
+	};
+}
+const Get = (pathOrOptions, maybeOptions) => Route("GET", pathOrOptions, maybeOptions);
+const Post = (pathOrOptions, maybeOptions) => Route("POST", pathOrOptions, maybeOptions);
+const Put = (pathOrOptions, maybeOptions) => Route("PUT", pathOrOptions, maybeOptions);
+const Delete = (pathOrOptions, maybeOptions) => Route("DELETE", pathOrOptions, maybeOptions);
+const Patch = (pathOrOptions, maybeOptions) => Route("PATCH", pathOrOptions, maybeOptions);
+const Options = (pathOrOptions, maybeOptions) => Route("OPTIONS", pathOrOptions, maybeOptions);
+const All = (pathOrOptions, maybeOptions) => Route("ALL", pathOrOptions, maybeOptions);
+//#endregion
+//#region src/openapi.ts
+/**
+* Normalize a flat ParamsSchemaMap into a valid JSON Schema object
+* that Fastify/AJV can validate against.
+*
+* Input:  { id: { type: "string", example: "abc-123" } }
+* Output: { type: "object", properties: { id: { type: "string", example: "abc-123" } } }
+*/
+function normalizeParamsToJsonSchema(params, requiredKeys = []) {
+	const properties = {};
+	for (const [key, val] of Object.entries(params)) properties[key] = {
+		type: "string",
+		...val
+	};
+	const schema = {
+		type: "object",
+		properties
+	};
+	if (requiredKeys.length > 0) schema.required = requiredKeys;
+	return schema;
+}
+function OpenApiSchema() {
+	return function(target) {
+		Reflect.defineMetadata("openapi:schema", true, target);
+	};
+}
+function OpenApi(options) {
+	return function(target, propertyKey, descriptor) {
+		if (typeof target === "function" && !propertyKey) Reflect.defineMetadata("controller:openapi", options, target);
+		else if (descriptor) Reflect.defineMetadata("route:openapi", options, target, propertyKey);
+		else if (propertyKey) Reflect.defineMetadata("property:openapi", options, target, propertyKey);
+	};
+}
+//#endregion
+//#region src/utils/common-utils.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+function isConstructor(func) {
+	if (typeof func !== "function") return false;
+	if (func === Function.prototype.bind || func instanceof RegExp) return false;
+	if (func.prototype && typeof func.prototype === "object") return true;
+	try {
+		return typeof new func() === "object";
+	} catch (e) {
+		return false;
+	}
+}
+function formatUrl(path) {
+	if (typeof path !== "string") throw new Error("The path must be a string");
+	path = path.trim();
+	if (!path.startsWith("/")) path = "/" + path;
+	path = path.replace(/\/\/+/g, "/");
+	if (path.endsWith("/")) path = path.slice(0, -1);
+	return path;
+}
+function parsedPath(ipath) {
+	return !ipath.startsWith("/") ? "/" + ipath : ipath;
+}
+function normalizePath(base = "/", subPath = "/") {
+	return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function extrctParamFromUrl(url) {
+	return url.split("/").filter((x) => x.startsWith(":") || x.startsWith("?:")).map((f) => ({
+		key: f.replace(/(\?|:)/g, ""),
+		required: !f.startsWith("?:")
+	}));
+}
+function findDuplicates(arr) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	for (const str of arr) if (seen.has(str)) duplicates.add(str);
+	else seen.add(str);
+	return Array.from(duplicates);
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var uuid, getLineNumber;
+var init_common_utils = require_chunk.__esmMin((() => {
+	uuid = node_crypto.default.randomUUID();
+	getLineNumber = (filePath, rpath) => {
+		let numbers = [];
+		try {
+			const lines = node_fs.default.readFileSync(filePath, "utf8").split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				const match = lines[i].match(rpath);
+				if (match) {
+					console.log(match);
+					numbers.push({
+						line: i + 1,
+						column: match.index ?? 0
+					});
+				}
+			}
+			return numbers;
+		} catch (error) {
+			return numbers;
+		}
+	};
+}));
+//#endregion
+//#region src/utils/object-utils.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+function pick(obj, paths) {
+	const result = {};
+	for (const path of paths) {
+		const keys = path.split(".");
+		let source = obj;
+		let target = result;
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (!(key in source)) break;
+			if (i === keys.length - 1) target[key] = source[key];
+			else {
+				source = source[key];
+				target[key] = target[key] || {};
+				target = target[key];
+			}
+		}
+	}
+	return result;
+}
+function exclude(obj, paths) {
+	if (Array.isArray(obj)) return obj.map((item) => exclude(item, paths));
+	const clone = structuredClone(obj);
+	for (const path of paths) {
+		const keys = path.split(".");
+		let target = clone;
+		for (let i = 0; i < keys.length - 1; i++) {
+			if (!(keys[i] in target)) break;
+			target = target[keys[i]];
+		}
+		delete target?.[keys[keys.length - 1]];
+	}
+	return clone;
+}
+function autoCast(value, typeHint, schema) {
+	if (value === null || value === void 0) return value;
+	if (Array.isArray(value)) {
+		const elementType = Array.isArray(typeHint) ? typeHint[0] : void 0;
+		return value.map((v) => autoCast(v, elementType));
+	}
+	if (typeof value === "object" && !(value instanceof Date)) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) {
+			let fieldType = void 0;
+			if (schema?.properties?.[key]?.type) {
+				const t = schema.properties[key].type;
+				fieldType = t === "integer" || t === "number" ? Number : t === "boolean" ? Boolean : t === "array" ? Array : t === "object" ? Object : String;
+			}
+			result[key] = autoCast(val, fieldType);
+		}
+		return result;
+	}
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (typeHint === Boolean || trimmed.toLowerCase() === "true") return true;
+	if (trimmed.toLowerCase() === "false") return false;
+	if (typeHint === Number || !isNaN(Number(trimmed)) && trimmed !== "") {
+		const n = Number(trimmed);
+		if (!isNaN(n)) return n;
+	}
+	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
+		return autoCast(JSON.parse(trimmed), typeHint, schema);
+	} catch {
+		return trimmed;
+	}
+	if (typeHint === Date || /^\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2})?/.test(trimmed)) {
+		const d = new Date(trimmed);
+		if (!isNaN(d.getTime())) return d;
+	}
+	return trimmed;
+}
+/**
+* Deeply normalizes query strings into nested JS objects.
+*/
+function normalizeQueryDeep(query) {
+	const result = {};
+	const setDeep = (obj, path, value) => {
+		let current = obj;
+		for (let i = 0; i < path.length; i++) {
+			const key = path[i];
+			const nextKey = path[i + 1];
+			if (i === path.length - 1) if (key === "") {
+				if (!Array.isArray(current)) current = [];
+				current.push(value);
+			} else if (Array.isArray(current[key])) current[key].push(value);
+			else if (current[key] !== void 0) current[key] = [current[key], value];
+			else current[key] = value;
+			else {
+				if (!current[key]) current[key] = nextKey === "" || /^\d+$/.test(nextKey) ? [] : {};
+				current = current[key];
+			}
+		}
+	};
+	for (const [rawKey, rawValue] of Object.entries(query)) {
+		const path = [];
+		const regex = /([^\[\]]+)|(\[\])/g;
+		let match;
+		while ((match = regex.exec(rawKey)) !== null) if (match[1]) path.push(match[1]);
+		else if (match[2]) path.push("");
+		if (path.length === 0) if (result[rawKey]) if (Array.isArray(result[rawKey])) result[rawKey].push(rawValue);
+		else result[rawKey] = [result[rawKey], rawValue];
+		else result[rawKey] = rawValue;
+		else setDeep(result, path, rawValue);
+	}
+	return result;
+}
+function transformObjectByInstanceToObject(instance, value) {
+	return (0, class_transformer.instanceToPlain)((0, class_transformer.plainToInstance)(instance, value), {
+		excludeExtraneousValues: true,
+		exposeUnsetFields: true
+	});
+}
+function jsonToJs(value) {
+	try {
+		return JSON.parse(value);
+	} catch (err) {
+		return false;
+	}
+}
+function jsonToInstance(value, instance) {
+	try {
+		return (0, class_transformer.plainToInstance)(instance, JSON.parse(value));
+	} catch (err) {
+		return false;
+	}
+}
+var init_object_utils = require_chunk.__esmMin((() => {}));
+//#endregion
+//#region src/exceptions/http-exceptions.ts
+var BaseHttpException, BadRequestException, ValidationErrorException, InternalErrorException, NotFoundException, UnauthorizedException, ForbiddenException, HttpExceptions;
+var init_http_exceptions = require_chunk.__esmMin((() => {
+	BaseHttpException = class extends Error {
+		code = 500;
+		name = "HttpException";
+		payload;
+		constructor(message) {
+			const stringMessage = typeof message === "string" ? message : JSON.stringify(message);
+			super(stringMessage);
+			this.payload = typeof message === "string" ? { message } : message;
+		}
+		isCustomException() {
+			return true;
+		}
+	};
+	BadRequestException = class extends BaseHttpException {
+		name = "BadRequest";
+		code = 400;
+		constructor(message) {
+			super(message);
+		}
+	};
+	ValidationErrorException = class extends BadRequestException {
+		name = "ValidationError";
+	};
+	InternalErrorException = class extends BaseHttpException {
+		name = "InternalError";
+		code = 500;
+		constructor(message = "Something going wrong") {
+			super(message);
+		}
+	};
+	NotFoundException = class extends BaseHttpException {
+		name = "NotFound";
+		code = 404;
+		constructor(message) {
+			super(message);
+		}
+	};
+	UnauthorizedException = class extends BaseHttpException {
+		name = "Unauthorized";
+		code = 401;
+		constructor(message) {
+			super(message);
+		}
+	};
+	ForbiddenException = class extends BaseHttpException {
+		name = "Forbidden";
+		code = 403;
+		constructor(message) {
+			super(message);
+		}
+	};
+	HttpExceptions = {
+		notFound: (message = "") => new NotFoundException(message),
+		validationError: (message = "") => new ValidationErrorException(message),
+		badRequest: (message = "") => new BadRequestException(message),
+		unauthorized: (message = "") => new UnauthorizedException(message),
+		forbidden: (message = "") => new ForbiddenException(message),
+		internalError: (message = "") => new InternalErrorException(message)
+	};
+}));
+//#endregion
+//#region src/exceptions/index.ts
+var init_exceptions = require_chunk.__esmMin((() => {
+	init_http_exceptions();
+}));
+//#endregion
+//#region src/utils/validation-utils.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+function getDataType(expectedType) {
+	switch (expectedType.name) {
+		case "Object":
+			if (Array.isArray(expectedType)) return "array";
+			return "object";
+		case "String": return "string";
+		case "Number": return "number";
+		case "Boolean": return "boolean";
+		default: return expectedType;
+	}
+}
+function isValidType(value, expectedType) {
+	if (value === void 0 || value === null) return true;
+	switch (expectedType.name) {
+		case "String": return typeof value === "string";
+		case "Number": return typeof value === "number" || !isNaN(Number(value));
+		case "Boolean": return typeof value === "boolean";
+		default: return value instanceof expectedType;
+	}
+}
+function isValidJsonString(value) {
+	try {
+		return JSON.parse(value);
+	} catch (err) {
+		return false;
+	}
+}
+async function validateObjectByInstance(target, value = {}, options = "array") {
+	try {
+		const { validateOrReject } = require("class-validator");
+		const { plainToInstance } = require("class-transformer");
+		await validateOrReject(plainToInstance(target, value));
+	} catch (error) {
+		if (typeof error == "object" && Array.isArray(error)) return options == "object" ? error.reduce((acc, x) => {
+			acc[x.property] = x.constraints;
+			return acc;
+		}, {}) : error.map((x) => ({
+			path: x.property,
+			constraints: x.constraints
+		}));
+		else throw new InternalErrorException("Can't validate object");
+	}
+}
+function validateRequestBody(target, value, options = "array") {
+	if (!isClassValidatorClass(target)) return {
+		count: 0,
+		errors: {}
+	};
+	const error = (0, class_validator.validateSync)((0, class_transformer.plainToInstance)(target, value ? value : {}));
+	const errors = options == "object" ? error.reduce((acc, x) => {
+		acc[x.property] = x.constraints;
+		return acc;
+	}, {}) : error.map((x) => ({
+		path: x.property,
+		constraints: x.constraints
+	}));
+	return {
+		count: error.length,
+		errors
+	};
+}
+var isClassValidator, isClassValidatorClass;
+var init_validation_utils = require_chunk.__esmMin((() => {
+	init_exceptions();
+	isClassValidator = (target) => {
+		try {
+			require("class-validator");
+			return (0, class_validator.getMetadataStorage)().getTargetValidationMetadatas(target, "", false, false).length > 0;
+		} catch (err) {
+			console.log(err);
+			return false;
+		}
+	};
+	isClassValidatorClass = (target) => {
+		try {
+			return require("class-validator").getMetadataStorage().getTargetValidationMetadatas(target, void 0, false, false).length > 0;
+		} catch (err) {
+			return false;
+		}
+	};
+}));
+//#endregion
+//#region src/exceptions/system-exception.ts
+var SystemUseError, EnvironmentVariableNotFound;
+var init_system_exception = require_chunk.__esmMin((() => {
+	SystemUseError = class extends Error {
+		constructor(message) {
+			super(message);
+		}
+	};
+	EnvironmentVariableNotFound = class extends Error {
+		constructor(key) {
+			super(`${key} not found in environment variables.`);
+		}
+	};
+}));
+//#endregion
+//#region src/utils/di-utils.ts
+function inject(cls) {
+	try {
+		return container_default.get(cls);
+	} catch (error) {
+		throw new SystemUseError("Not a project class. Maybe you wanna register it first.");
+	}
+}
+var init_di_utils = require_chunk.__esmMin((() => {
+	init_container();
+	init_system_exception();
+}));
+//#endregion
+//#region src/validation.ts
+function validateOrThrow(obj, rules, options) {
+	const errors = new Validator(rules, options).validate(obj);
+	if (errors[0].length > 0) throw new BadRequestException(errors[0]);
+	return errors[1];
+}
+var PValidationRule, Validator, isBool, parseBoolean;
+var init_validation = require_chunk.__esmMin((() => {
+	init_exceptions();
+	PValidationRule = class {
+		name;
+		type;
+		message;
+		constructor(name, type, message) {
+			this.name = name;
+			this.type = type;
+			this.message = message;
+		}
+	};
+	Validator = class {
+		rules = [];
+		options = {};
+		constructor(obj, options) {
+			this.init(obj);
+			if (options) this.options = options;
+		}
+		init(obj) {
+			Object.keys(obj).forEach((key) => {
+				const rule = obj[key];
+				this.rules.push(new PValidationRule(key, rule.type, rule.message));
+			});
+		}
+		validate(obj, options) {
+			const erors = [];
+			this.rules.forEach((k) => {
+				const r = Object.keys(obj).find((key) => key == k.name);
+				let messages = [];
+				if (!r || obj[r] == void 0 || obj[r] == "") messages.push({
+					constraint: "required",
+					message: k.name + " is required"
+				});
+				if (k.type == "string" && typeof obj[k.name] != "string") messages.push({
+					constraint: "type",
+					message: `${k.name} must be type ${k.type}`
+				});
+				if (k.type == "number" && !parseInt(obj[k.name])) messages.push({
+					constraint: "type",
+					message: `${k.name} must be type ${k.type}`
+				});
+				if (k.type == "number") obj[k.name] = parseInt(obj[k.name]);
+				if (k.type == "boolean" && !isBool(obj[k.name])) messages.push({
+					constraint: "type",
+					message: `${k.name} must be type ${k.type}`
+				});
+				if (k.type == "boolean") obj[k.name] = parseBoolean(obj[k.name]);
+				if (messages.length > 0) erors.push({
+					path: k.name,
+					...this.options.location ? { location: this.options.location } : {},
+					constraints: messages
+				});
+			});
+			return [erors, obj];
+		}
+	};
+	isBool = (val) => {
+		if (typeof val == "boolean") return true;
+		if (parseInt(val) == 0 || parseInt(val) == 1) return true;
+		if (val == "true" || val == "false") return true;
+		return false;
+	};
+	parseBoolean = (val) => {
+		if (typeof val === "boolean") return val;
+		if (parseInt(val) == 1) return true;
+		if (typeof val === "string") return val.trim().toLowerCase() === "true";
+		return false;
+	};
+}));
+//#endregion
+//#region src/helpers.ts
+var init_helpers = require_chunk.__esmMin((() => {
+	init_common_utils();
+	init_object_utils();
+	init_validation_utils();
+	init_di_utils();
+	init_validation();
+}));
+//#endregion
+//#region src/params.ts
+init_container();
+init_helpers();
+function createParamDecorator(type) {
+	return function(key, options = {}) {
+		return function(target, propertyKey, parameterIndex) {
+			let metaKey;
+			switch (type) {
+				case "route:param":
+					metaKey = PARAM_META_KEY;
+					break;
+				case "route:query":
+					metaKey = QUERY_META_KEY;
+					break;
+				case "route:body":
+					metaKey = REQUEST_BODY_META_KEY;
+					break;
+				case "route:user":
+					metaKey = REQUEST_USER_META_KEY;
+					break;
+				case "route:header":
+					metaKey = REQUEST_HEADER_META_KEY;
+					break;
+				default: throw new Error(`Unknown param decorator type: ${String(type)}`);
+			}
+			const existingParams = Reflect.getMetadata(metaKey, target, propertyKey) || [];
+			const paramNames = target[propertyKey].toString().match(/\(([^)]*)\)/)?.[1]?.split(",").map((n) => n.trim()) || [];
+			const paramDataType = (Reflect.getMetadata("design:paramtypes", target, propertyKey) || [])[parameterIndex];
+			existingParams.push({
+				index: parameterIndex,
+				key: typeof key === "string" ? key : "all",
+				name: paramNames[parameterIndex],
+				required: options.required ?? true,
+				validate: options.validate ?? true,
+				dataType: getDataType(paramDataType),
+				validatorClass: isClassValidatorClass(paramDataType),
+				schema: isClassValidatorClass(paramDataType) ? generateClassSchema(paramDataType) : null,
+				type
+			});
+			Reflect.defineMetadata(metaKey, existingParams, target, propertyKey);
+		};
+	};
+}
+const Param = createParamDecorator("route:param");
+const Query = createParamDecorator("route:query");
+const Body = createParamDecorator("route:body");
+const Header = createParamDecorator("route:header");
+const AuthUser = createParamDecorator("route:user");
+//#endregion
+//#region src/decorators.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+function AppService(target) {
+	if (target) (0, typedi.Service)()(target);
+	else return function(tg) {
+		(0, typedi.Service)()(tg);
+	};
+}
+const Utility = typedi.Service;
+const Helper = typedi.Service;
+//#endregion
+//#region src/core/router.ts
+init_helpers();
+init_container();
+init_exceptions();
+/**
+* Normalize a flat params/query map like:
+*   { id: { type: "string", example: "abc-123" } }
+* into a valid AJV/JSON Schema object:
+*   { type: "object", properties: { id: { type: "string", example: "abc-123" } } }
+*/
+function normalizeParamsToJsonSchema$1(map, requiredKeys = []) {
+	const properties = {};
+	for (const [key, val] of Object.entries(map)) {
+		const { required, ...rest } = val;
+		properties[key] = {
+			type: "string",
+			...rest
+		};
+	}
+	const schema = {
+		type: "object",
+		properties
+	};
+	if (requiredKeys.length > 0) schema.required = requiredKeys;
+	return schema;
+}
+/**
+* Take a raw @OpenApi schema object and return a Fastify-compatible
+* route schema — normalizing params, query → querystring, and headers.
+*/
+function buildRouteSchema(raw) {
+	const schema = { ...raw };
+	if (raw.params && typeof raw.params === "object" && !raw.params.type) {
+		const required = Object.entries(raw.params).filter(([, v]) => v.required !== false).map(([k]) => k);
+		schema.params = normalizeParamsToJsonSchema$1(raw.params, required);
+	}
+	if (raw.query && typeof raw.query === "object" && !raw.query.type) {
+		const required = Object.entries(raw.query).filter(([, v]) => v.required === true).map(([k]) => k);
+		schema.querystring = normalizeParamsToJsonSchema$1(raw.query, required);
+		delete schema.query;
+	}
+	if (raw.headers && typeof raw.headers === "object" && !raw.headers.type) schema.headers = normalizeParamsToJsonSchema$1(raw.headers);
+	return schema;
+}
+var AvleonRouter = class {
+	routeSet = /* @__PURE__ */ new Set();
+	metaCache = /* @__PURE__ */ new Map();
+	middlewares = /* @__PURE__ */ new Map();
+	rMap = /* @__PURE__ */ new Map();
+	app;
+	authorizeMiddleware;
+	constructor(app) {
+		this.app = app;
+	}
+	setAuthorizeMiddleware(middleware) {
+		this.authorizeMiddleware = middleware;
+	}
+	registerMiddleware(name, instance) {
+		this.middlewares.set(name, instance);
+	}
+	_processMeta(prototype, method) {
+		const cacheKey = `${prototype.constructor.name}_${method}`;
+		if (this.metaCache.has(cacheKey)) return this.metaCache.get(cacheKey);
+		const meta = {
+			request: Reflect.getMetadata(REQUEST_METADATA_KEY, prototype, method) || [],
+			params: Reflect.getMetadata(PARAM_META_KEY, prototype, method) || [],
+			query: Reflect.getMetadata(QUERY_META_KEY, prototype, method) || [],
+			body: Reflect.getMetadata(REQUEST_BODY_META_KEY, prototype, method) || [],
+			file: Reflect.getMetadata(REQUEST_BODY_FILE_KEY, prototype, method) || [],
+			files: Reflect.getMetadata(REQUEST_BODY_FILES_KEY, prototype, method) || [],
+			headers: Reflect.getMetadata(REQUEST_HEADER_META_KEY, prototype, method) || [],
+			currentUser: Reflect.getMetadata(REQUEST_USER_META_KEY, prototype, method) || []
+		};
+		this.metaCache.set(cacheKey, meta);
+		return meta;
+	}
+	executeMiddlewares(target, propertyKey) {
+		const classMiddlewares = Reflect.getMetadata("controller:middleware", target.constructor) || [];
+		const methodMiddlewares = propertyKey ? Reflect.getMetadata("route:middleware", target, propertyKey) || [] : [];
+		return [...classMiddlewares, ...methodMiddlewares];
+	}
+	async buildController(controller) {
+		const ctrl = typedi.default.get(controller);
+		const controllerMeta = Reflect.getMetadata(CONTROLLER_META_KEY, ctrl.constructor);
+		if (!controllerMeta) return;
+		const prototype = Object.getPrototypeOf(ctrl);
+		const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+		const tag = ctrl.constructor.name.replace("Controller", "");
+		const swaggerControllerMeta = Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
+		const authClsMeata = Reflect.getMetadata(AUTHORIZATION_META_KEY, ctrl.constructor) || {
+			authorize: false,
+			options: void 0
+		};
+		for await (const method of methods) {
+			const methodMeta = Reflect.getMetadata(ROUTE_META_KEY, prototype, method);
+			if (!methodMeta) continue;
+			const methodmetaOptions = {
+				method: methodMeta.method.toLowerCase(),
+				path: formatUrl(controllerMeta.path + methodMeta.path)
+			};
+			const routeKey = `${methodmetaOptions.method}:${methodmetaOptions.path}`;
+			if (!this.routeSet.has(routeKey)) this.routeSet.add(routeKey);
+			const classMiddlewares = this.executeMiddlewares(ctrl, method);
+			const swaggerMeta = Reflect.getMetadata("route:openapi", prototype, method) || {};
+			const authClsMethodMeata = Reflect.getMetadata(AUTHORIZATION_META_KEY, ctrl.constructor, method) || {
+				authorize: false,
+				options: void 0
+			};
+			const allMeta = this._processMeta(prototype, method);
+			let bodySchema = null;
+			allMeta.body.forEach((r) => {
+				if (r.schema) bodySchema = { ...r.schema };
+			});
+			let schema = {
+				...swaggerControllerMeta,
+				...swaggerMeta,
+				tags: [tag]
+			};
+			if (!swaggerMeta.body && bodySchema) schema = {
+				...schema,
+				body: bodySchema
+			};
+			if (!swaggerMeta.query && !schema.querystring) {
+				for (const queryMeta of allMeta.query) if (queryMeta.validatorClass && queryMeta.schema) {
+					schema.querystring = queryMeta.schema;
+					break;
+				}
+			}
+			if (!swaggerMeta.body && !bodySchema) {
+				for (const bodyMeta of allMeta.body) if (bodyMeta.validatorClass && bodyMeta.schema) {
+					schema = {
+						...schema,
+						body: bodyMeta.schema
+					};
+					break;
+				}
+			}
+			const routePath = methodmetaOptions.path === "" ? "/" : methodmetaOptions.path;
+			const isMultipart = schema?.consumes?.includes("multipart/form-data") || Object.values(schema?.body?.properties || {}).some((p) => p.format === "binary");
+			if (isMultipart) {
+				schema.consumes = ["multipart/form-data"];
+				if (!schema.body) schema.body = {
+					type: "object",
+					properties: {}
+				};
+				for (const param of allMeta.body) if (param.type === "route:file") schema.body.properties[param.key] = {
+					type: "string",
+					format: "binary"
+				};
+				else schema.body.properties[param.key] = { type: param.dataType };
+			}
+			const routeSchema = buildRouteSchema(schema);
+			this.app.route({
+				url: routePath,
+				method: methodmetaOptions.method.toUpperCase(),
+				schema: routeSchema,
+				attachValidation: isMultipart,
+				handler: async (req, res) => {
+					let reqClone = req;
+					if (authClsMeata.authorize && this.authorizeMiddleware) {
+						await container_default.get(this.authorizeMiddleware).authorize(reqClone, authClsMeata.options);
+						if (res.sent) return;
+					}
+					if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
+						await container_default.get(this.authorizeMiddleware).authorize(reqClone, authClsMethodMeata.options);
+						if (res.sent) return;
+					}
+					if (classMiddlewares.length > 0) for (let m of classMiddlewares) {
+						reqClone = await typedi.default.get(m.constructor).invoke(reqClone, res);
+						if (res.sent) return;
+					}
+					const args = await this._mapArgs(reqClone, allMeta);
+					for (let paramMeta of allMeta.params) if (paramMeta.required) validateOrThrow({ [paramMeta.key]: args[paramMeta.index] }, { [paramMeta.key]: { type: paramMeta.dataType } }, { location: "param" });
+					for (let queryMeta of allMeta.query) {
+						if (queryMeta.validatorClass) {
+							const err = await validateObjectByInstance(queryMeta.dataType, args[queryMeta.index]);
+							if (err) return await res.code(400).send({
+								code: 400,
+								error: "ValidationError",
+								errors: err,
+								message: err.message
+							});
+						}
+						if (queryMeta.required) validateOrThrow({ [queryMeta.key]: args[queryMeta.index] }, { [queryMeta.key]: { type: queryMeta.dataType } }, { location: "queryparam" });
+					}
+					if (!isMultipart) {
+						for (let bodyMeta of allMeta.body) if (bodyMeta.validatorClass) {
+							const err = await validateObjectByInstance(bodyMeta.dataType, args[bodyMeta.index]);
+							if (err) return await res.code(400).send({
+								code: 400,
+								error: "ValidationError",
+								errors: err,
+								message: err.message
+							});
+						}
+					}
+					const result = await prototype[method].apply(ctrl, args);
+					if (result?.download) {
+						const { stream, filename } = result;
+						if (!stream || typeof stream.pipe !== "function") return res.code(500).send({
+							code: 500,
+							error: "INTERNAL_ERROR",
+							message: "Invalid stream object"
+						});
+						const contentType = result.contentType || mime.default.getType(filename) || "application/octet-stream";
+						res.header("Content-Type", contentType);
+						res.header("Content-Disposition", `attachment; filename="${filename}"`);
+						stream.on("error", (err) => {
+							console.error("Stream error:", err);
+							if (!res.sent) res.code(500).send({
+								code: 500,
+								error: "StreamError",
+								message: "Error while streaming file."
+							});
+						});
+						return res.send(stream);
+					}
+					if (result instanceof node_stream.default || typeof result?.pipe === "function") {
+						result.on("error", (err) => {
+							console.error("Stream error:", err);
+							if (!res.sent) res.code(500).send({
+								code: 500,
+								error: "StreamError",
+								message: "Error while streaming file."
+							});
+						});
+						res.header("Content-Type", "application/octet-stream");
+						return res.send(result);
+					}
+					return res.send(result);
+				}
+			});
+		}
+	}
+	async _mapArgs(req, meta) {
+		if (!req.hasOwnProperty("_argsCache")) Object.defineProperty(req, "_argsCache", {
+			value: /* @__PURE__ */ new Map(),
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+		const cache = req._argsCache;
+		const cacheKey = JSON.stringify(meta);
+		if (cache.has(cacheKey)) return cache.get(cacheKey);
+		const maxIndex = Math.max(...meta.params.map((p) => p.index || 0), ...meta.query.map((q) => q.index), ...meta.body.map((b) => b.index), ...meta.currentUser.map((u) => u.index), ...meta.headers.map((h) => h.index), ...meta.request?.map((r) => r.index) || [], ...meta.file?.map((f) => f.index) || [], ...meta.files?.map((f) => f.index) || [], -1) + 1;
+		const args = new Array(maxIndex).fill(void 0);
+		meta.params.forEach((p) => {
+			const raw = p.key === "all" ? { ...req.params } : req.params[p.key] ?? null;
+			args[p.index] = autoCast(raw, p.dataType, p.schema);
+		});
+		meta.query.forEach((q) => {
+			const raw = q.key === "all" ? normalizeQueryDeep({ ...req.query }) : req.query[q.key];
+			args[q.index] = autoCast(raw, q.dataType, q.schema);
+		});
+		meta.body.forEach((body) => {
+			args[body.index] = {
+				...req.body,
+				...req.formData
+			};
+		});
+		meta.currentUser.forEach((user) => {
+			args[user.index] = req.user;
+		});
+		meta.headers.forEach((header) => {
+			args[header.index] = header.key === "all" ? { ...req.headers } : req.headers[header.key];
+		});
+		if (meta.request && meta.request.length > 0) meta.request.forEach((r) => {
+			args[r.index] = req;
+		});
+		const needsFiles = meta.file && meta.file.length > 0 || meta.files && meta.files.length > 0;
+		if (needsFiles && req.headers["content-type"]?.startsWith("multipart/form-data") && req.saveRequestFiles) {
+			const files = await req.saveRequestFiles();
+			if (!files || files.length === 0) {
+				if (meta.files && meta.files.length > 0) throw new BadRequestException({ error: "No files uploaded" });
+				if (meta.file && meta.file.length > 0) meta.file.forEach((f) => {
+					args[f.index] = null;
+				});
+			} else {
+				const fileInfo = files.map((file) => ({
+					type: file.type,
+					filepath: file.filepath,
+					fieldname: file.fieldname,
+					filename: file.filename,
+					encoding: file.encoding,
+					mimetype: file.mimetype,
+					fields: file.fields,
+					toBuffer: file.toBuffer
+				}));
+				if (meta.file && meta.file.length > 0) meta.file.forEach((f) => {
+					if (f.fieldName === "all") args[f.index] = fileInfo[0] || null;
+					else {
+						const file = fileInfo.find((x) => x.fieldname === f.fieldName);
+						if (!file) throw new BadRequestException(`File field "${f.fieldName}" not found in uploaded files`);
+						args[f.index] = file;
+					}
+				});
+				if (meta.files && meta.files.length > 0) meta.files.forEach((f) => {
+					if (f.fieldName === "all") args[f.index] = fileInfo;
+					else {
+						const matchingFiles = fileInfo.filter((x) => x.fieldname === f.fieldName);
+						if (matchingFiles.length === 0) throw new BadRequestException(`No files found for field "${f.fieldName}"`);
+						args[f.index] = matchingFiles;
+					}
+				});
+			}
+		} else if (needsFiles) throw new BadRequestException({ error: "Invalid content type. Expected multipart/form-data for file uploads" });
+		cache.set(cacheKey, args);
+		return args;
+	}
+	_routeHandler(routePath, method, fn) {
+		const routeKey = method + ":" + routePath;
+		this.rMap.set(routeKey, {
+			handler: fn,
+			middlewares: [],
+			schema: {}
+		});
+		const route = {
+			useMiddleware: (middlewares) => {
+				const ms = (Array.isArray(middlewares) ? middlewares : [middlewares]).map((mclass) => {
+					const cls = typedi.default.get(mclass);
+					this.middlewares.set(mclass.name, cls);
+					return cls.invoke;
+				});
+				const r = this.rMap.get(routeKey);
+				if (r) r.middlewares = ms;
+				return route;
+			},
+			useOpenApi: (options) => {
+				const r = this.rMap.get(routeKey);
+				if (r) r.schema = options;
+				return route;
+			}
+		};
+		return route;
+	}
+	mapGet(path = "", fn) {
+		return this._routeHandler(path, "GET", fn);
+	}
+	mapPost(path = "", fn) {
+		return this._routeHandler(path, "POST", fn);
+	}
+	mapPut(path = "", fn) {
+		return this._routeHandler(path, "PUT", fn);
+	}
+	mapDelete(path = "", fn) {
+		return this._routeHandler(path, "DELETE", fn);
+	}
+	async mapRoute(method, path = "", fn) {
+		this.app[method](path, async (req, res) => {
+			try {
+				const result = await fn(req, res);
+				if (typeof result === "object" && result !== null) res.json(result);
+				else res.send(result);
+			} catch (error) {
+				console.error(`Error in ${method} route handler:`, error);
+				res.status(500).send({ error: "Internal Server Error" });
+			}
+		});
+	}
+	processFunctionalRoutes() {
+		this.rMap.forEach((value, key) => {
+			const colonIdx = key.indexOf(":");
+			const m = key.slice(0, colonIdx);
+			const r = key.slice(colonIdx + 1);
+			const routeSchema = buildRouteSchema(value.schema || {});
+			this.app.route({
+				method: m.toUpperCase(),
+				url: r,
+				schema: routeSchema,
+				preHandler: value.middlewares ?? [],
+				handler: async (req, res) => {
+					return value.handler(req, res);
+				}
+			});
+		});
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var init_decorateMetadata = require_chunk.__esmMin((() => {}));
+//#endregion
+//#region \0@oxc-project+runtime@0.121.0/helpers/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;
+}
+var init_decorate = require_chunk.__esmMin((() => {}));
+//#endregion
+//#region src/kenx-provider.ts
+var kenx_provider_exports = /* @__PURE__ */ require_chunk.__exportAll({ DB: () => DB });
+var DB;
+var init_kenx_provider = require_chunk.__esmMin((() => {
+	init_decorateMetadata();
+	init_decorate();
+	DB = class DB {
+		connection;
+		constructor() {
+			const existing = typedi.Container.has("KnexConnection") ? typedi.Container.get("KnexConnection") : null;
+			if (existing) this.connection = existing;
+		}
+		init(config) {
+			if (!this.connection) {
+				this.connection = require("knex")(config);
+				typedi.Container.set("KnexConnection", this.connection);
+			}
+			return this.connection;
+		}
+		get client() {
+			if (!this.connection) throw new Error("Knex is not initialized. Call DB.init(config) first.");
+			return this.connection;
+		}
+	};
+	DB = __decorate([(0, typedi.Service)(), __decorateMetadata("design:paramtypes", [])], DB);
+}));
+//#endregion
+//#region src/websocket.ts
+var websocket_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	AvleonSocketIo: () => AvleonSocketIo,
+	SocketIoServer: () => SocketIoServer
+});
+var SocketIoServer, AvleonSocketIo;
+var init_websocket = require_chunk.__esmMin((() => {
+	init_decorate();
+	SocketIoServer = new typedi.Token("SocketIoServer");
+	AvleonSocketIo = class AvleonSocketIo {
+		io;
+		sendToAll() {}
+		sendOnly() {}
+		sendRoom() {}
+		receive(channel) {}
+	};
+	AvleonSocketIo = __decorate([(0, typedi.Service)()], AvleonSocketIo);
+}));
+//#endregion
+//#region src/event-dispatcher.ts
+var event_dispatcher_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	Dispatch: () => Dispatch,
+	EventDispatcher: () => EventDispatcher,
+	SocketContextService: () => SocketContextService
+});
+function Dispatch(event, options) {
+	return function(target, propertyKey, descriptor) {
+		const original = descriptor.value;
+		descriptor.value = async function(...args) {
+			const result = await original.apply(this, args);
+			await typedi.Container.get(EventDispatcher).dispatch(event, result, options);
+			return result;
+		};
+	};
+}
+var _ref$1, SocketContextService, EventDispatcher;
+var init_event_dispatcher = require_chunk.__esmMin((() => {
+	init_websocket();
+	init_helpers();
+	init_decorate();
+	init_decorateMetadata();
+	SocketContextService = class SocketContextService {
+		storage = new node_async_hooks.AsyncLocalStorage();
+		run(socket, fn) {
+			this.storage.run({ socket }, fn);
+		}
+		getSocket() {
+			return this.storage.getStore()?.socket;
+		}
+	};
+	SocketContextService = __decorate([(0, typedi.Service)()], SocketContextService);
+	EventDispatcher = class EventDispatcher {
+		constructor(_context) {
+			this._context = _context;
+		}
+		async dispatch(event, data, options = {}) {
+			const retryCount = options.retry ?? 0;
+			const delay = options.retryDelay ?? 300;
+			for (let attempt = 0; attempt <= retryCount; attempt++) try {
+				await this.dispatchToTransports(event, data, options);
+				break;
+			} catch (err) {
+				if (attempt === retryCount) throw err;
+				await sleep(delay * (attempt + 1));
+			}
+		}
+		async dispatchToTransports(event, data, options) {
+			const transports = options.transports ?? ["socket"];
+			for (const transport of transports) if (transport === "socket") {
+				const io = typedi.Container.get(SocketIoServer);
+				const socket = typedi.Container.get(SocketContextService).getSocket();
+				if (options.broadcast && socket) if (options.room) socket.broadcast.to(options.room).emit(event, data);
+				else socket.broadcast.emit(event, data);
+				else if (options.room) io.to(options.room).emit(event, data);
+				else io.emit(event, data);
+			}
+		}
+	};
+	EventDispatcher = __decorate([(0, typedi.Service)(), __decorateMetadata("design:paramtypes", [typeof (_ref$1 = typeof SocketContextService !== "undefined" && SocketContextService) === "function" ? _ref$1 : Object])], EventDispatcher);
+}));
+//#endregion
+//#region src/event-subscriber.ts
+var event_subscriber_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	EventSubscriberRegistry: () => EventSubscriberRegistry,
+	Private: () => Private,
+	Subscribe: () => Subscribe,
+	getPrivateChannelResolver: () => getPrivateChannelResolver,
+	getSocketSubscribers: () => getSocketSubscribers,
+	isPrivate: () => isPrivate,
+	registerSocketSubscriber: () => registerSocketSubscriber
+});
+function Private(channelResolver) {
+	return function(target, propertyKey) {
+		Reflect.defineMetadata(PRIVATE_META_KEY, true, target, propertyKey);
+		Reflect.defineMetadata(`private:channel:${propertyKey}`, channelResolver, target);
+	};
+}
+function isPrivate(target, propertyKey) {
+	return Reflect.getMetadata(PRIVATE_META_KEY, target, propertyKey) || false;
+}
+function getPrivateChannelResolver(target, propertyKey) {
+	return Reflect.getMetadata(`private:channel:${propertyKey}`, target);
+}
+function registerSocketSubscriber(target) {
+	socketSubscriberClasses.add(target);
+}
+function getSocketSubscribers() {
+	return Array.from(socketSubscriberClasses);
+}
+function Subscribe(event) {
+	return (target, propertyKey) => {
+		Reflect.defineMetadata("socket:event", event, target, propertyKey);
+		registerSocketSubscriber(target.constructor);
+	};
+}
+var _ref, PRIVATE_META_KEY, socketSubscriberClasses, EventSubscriberRegistry;
+var init_event_subscriber = require_chunk.__esmMin((() => {
+	init_event_dispatcher();
+	init_decorateMetadata();
+	init_decorate();
+	PRIVATE_META_KEY = "avleon:private";
+	socketSubscriberClasses = /* @__PURE__ */ new Set();
+	EventSubscriberRegistry = class EventSubscriberRegistry {
+		constructor(socketContext) {
+			this.socketContext = socketContext;
+		}
+		register(socket) {
+			const subscriberClasses = getSocketSubscribers();
+			for (const SubscriberClass of subscriberClasses) {
+				const instance = typedi.Container.get(SubscriberClass);
+				const prototype = Object.getPrototypeOf(instance);
+				const methodNames = Object.getOwnPropertyNames(prototype).filter((name) => typeof prototype[name] === "function");
+				for (const methodName of methodNames) {
+					const event = Reflect.getMetadata("socket:event", prototype, methodName);
+					const isPrivateListener = isPrivate(instance, methodName);
+					const channelResolver = getPrivateChannelResolver(instance, methodName);
+					if (event) {
+						const channel = isPrivateListener && channelResolver ? channelResolver(socket) : event;
+						console.log("Channel", channel);
+						socket.on(channel, (payload) => {
+							this.socketContext.run(socket, async () => {
+								if (isPrivateListener) {
+									if (!socket.data.user) return;
+								}
+								await instance[methodName](payload, socket.data);
+							});
+						});
+					}
+				}
+			}
+		}
+	};
+	EventSubscriberRegistry = __decorate([(0, typedi.Service)(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof SocketContextService !== "undefined" && SocketContextService) === "function" ? _ref : Object])], EventSubscriberRegistry);
+}));
+//#endregion
+//#region src/core/application.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_exceptions();
+init_system_exception();
+init_container();
+function requireTypeorm() {
+	try {
+		return require("typeorm");
+	} catch {
+		throw new Error("[Avleon] typeorm is not installed.\nRun: npm install typeorm\nThen install a driver: npm install pg  (or mysql2, sqlite3, etc.)");
+	}
+}
+function requireSocketIo() {
+	try {
+		return require("fastify-socket.io");
+	} catch {
+		throw new Error("[Avleon] fastify-socket.io is not installed.\nRun: npm install fastify-socket.io socket.io");
+	}
+}
+function requireSwagger() {
+	try {
+		return require("@fastify/swagger");
+	} catch {
+		throw new Error("[Avleon] @fastify/swagger is not installed.\nRun: npm install @fastify/swagger @fastify/swagger-ui");
+	}
+}
+function requireSwaggerUi() {
+	try {
+		return require("@fastify/swagger-ui");
+	} catch {
+		throw new Error("[Avleon] @fastify/swagger-ui is not installed.\nRun: npm install @fastify/swagger-ui");
+	}
+}
+function requireScalar() {
+	try {
+		return require("@scalar/fastify-api-reference");
+	} catch {
+		throw new Error("[Avleon] @scalar/fastify-api-reference is not installed.\nRun: npm install @scalar/fastify-api-reference");
+	}
+}
+function requireCors() {
+	try {
+		return require("@fastify/cors");
+	} catch {
+		throw new Error("[Avleon] @fastify/cors is not installed.\nRun: npm install @fastify/cors");
+	}
+}
+function requireMultipart() {
+	try {
+		return require("@fastify/multipart");
+	} catch {
+		throw new Error("[Avleon] @fastify/multipart is not installed.\nRun: npm install @fastify/multipart");
+	}
+}
+function requireStatic() {
+	try {
+		return require("@fastify/static");
+	} catch {
+		throw new Error("[Avleon] @fastify/static is not installed.\nRun: npm install @fastify/static");
+	}
+}
+var AvleonApplication = class AvleonApplication {
+	app;
+	router;
+	static instance;
+	alreadyRun = false;
+	hasSwagger = false;
+	globalSwaggerOptions;
+	dataSourceOptions = null;
+	dataSource = null;
+	isMapFeatures = false;
+	registerControllerAuto = false;
+	registerControllerPath = "src/controllers";
+	controllers = [];
+	_hasWebsocket = false;
+	io;
+	constructor(options) {
+		this.app = (0, fastify.default)({
+			...options?.server,
+			ajv: { customOptions: {
+				strict: false,
+				...options?.server?.ajv?.customOptions
+			} }
+		});
+		this.router = new AvleonRouter(this.app);
+		if (options?.dataSourceOptions) {
+			this.dataSourceOptions = options.dataSourceOptions;
+			if (this.dataSourceOptions) {
+				const { DataSource } = requireTypeorm();
+				this.dataSource = new DataSource(this.dataSourceOptions);
+				typedi.default.set(DataSource, this.dataSource);
+			}
+		}
+	}
+	static getApp(options) {
+		if (!AvleonApplication.instance) AvleonApplication.instance = new AvleonApplication(options);
+		return AvleonApplication.instance;
+	}
+	/** @deprecated Use `getApp` instead. This is internal. */
+	static getInternalApp(options) {
+		return new AvleonApplication(options);
+	}
+	useCors(options) {
+		this.app.register(requireCors(), options);
+		return this;
+	}
+	useDatasource(dataSource) {
+		const { DataSource } = requireTypeorm();
+		this.dataSource = dataSource;
+		typedi.default.set(DataSource, this.dataSource);
+		return this;
+	}
+	useMultipart(options) {
+		this.app.register(requireMultipart(), {
+			attachFieldsToBody: true,
+			limits: { fileSize: 10 * 1024 * 1024 },
+			...options
+		});
+		return this;
+	}
+	useOpenApi(options) {
+		this.hasSwagger = true;
+		this.globalSwaggerOptions = options;
+		return this;
+	}
+	async initSwagger(options) {
+		const baseSchema = generateSwaggerSchema((this.controllers ?? []).filter((c) => c != null && typeof c === "function"));
+		await this.app.register(requireSwagger(), { openapi: {
+			...baseSchema,
+			info: options?.info || {
+				title: "API",
+				version: "1.0.0"
+			},
+			servers: options?.servers,
+			tags: options?.tags,
+			components: {
+				...baseSchema?.components,
+				...options?.components,
+				schemas: {
+					...baseSchema?.components?.schemas,
+					...options?.components?.schemas
+				}
+			},
+			security: options?.security,
+			externalDocs: options?.externalDocs
+		} });
+		const routePrefix = options?.routePrefix || "/swagger";
+		if (options?.provider === "scalar") await this.app.register(requireScalar(), {
+			routePrefix,
+			configuration: {
+				spec: { content: () => requireSwagger() },
+				...options?.uiConfig
+			}
+		});
+		else await this.app.register(requireSwaggerUi(), {
+			routePrefix,
+			uiConfig: {
+				docExpansion: "full",
+				deepLinking: false,
+				...options?.uiConfig
+			},
+			uiHooks: {
+				onRequest: function(request, reply, next) {
+					next();
+				},
+				preHandler: function(request, reply, next) {
+					next();
+				}
+			},
+			staticCSP: true,
+			transformSpecificationClone: true
+		});
+	}
+	useMiddlewares(middlewares) {
+		middlewares.forEach((m) => {
+			const cls = typedi.default.get(m);
+			this.app.addHook("preHandler", async (req, res) => {
+				await cls.invoke(req, res);
+			});
+		});
+		return this;
+	}
+	useAuthorization(authorization) {
+		this.router.setAuthorizeMiddleware(authorization);
+		return this;
+	}
+	useSerialization() {
+		return this;
+	}
+	useControllers(controllers) {
+		if (Array.isArray(controllers)) {
+			this.controllers = controllers;
+			controllers.forEach((controller) => {
+				if (!this.controllers.includes(controller)) this.controllers.push(controller);
+			});
+		} else {
+			this.registerControllerAuto = true;
+			if (controllers.path) this.registerControllerPath = controllers.path;
+		}
+		return this;
+	}
+	useStaticFiles(options) {
+		this.app.register(requireStatic(), options);
+		return this;
+	}
+	useHttps(options) {
+		return this;
+	}
+	useGlobal(options) {
+		if (options.cors) this.useCors(options.cors);
+		if (options.openApi) this.useOpenApi(options.openApi);
+		if (options.controllers) this.useControllers(options.controllers);
+		if (options.middlewares) this.useMiddlewares(options.middlewares);
+		if (options.authorization) this.useAuthorization(options.authorization);
+		if (options.multipart) this.useMultipart(options.multipart);
+		if (options.staticFiles) this.useStaticFiles(options.staticFiles);
+		return this;
+	}
+	useSocketIo(options) {
+		this._hasWebsocket = true;
+		this.app.register(requireSocketIo(), options);
+		return this;
+	}
+	useKnex(options) {
+		try {
+			const { DB } = (init_kenx_provider(), require_chunk.__toCommonJS(kenx_provider_exports));
+			typedi.default.get(DB).init(options.config ?? options);
+		} catch (e) {
+			if (e.message?.includes("knex")) throw e;
+			throw new Error("[Avleon] Failed to initialize Knex. Make sure knex and a database driver are installed.\nRun: npm install knex pg  (or mysql2, sqlite3, etc.)");
+		}
+		return this;
+	}
+	mapFeatures() {
+		this.isMapFeatures = true;
+		return this;
+	}
+	isDevelopment() {
+		return process.env.NODE_ENV === "development" || !process.env.NODE_ENV;
+	}
+	async _mapControllers() {
+		const safeControllers = (this.controllers ?? []).filter((c) => c != null && typeof c === "function");
+		if (safeControllers.length > 0) for (const controller of safeControllers) if (isApiController(controller)) await this.router.buildController(controller);
+		else throw new SystemUseError("Not an API controller.");
+	}
+	_resolveControllerDir(dir) {
+		const isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT || process[Symbol.for("ts-node.register.instance")];
+		const controllerDir = node_path.default.join(process.cwd(), this.registerControllerPath);
+		return isTsNode ? controllerDir : controllerDir.replace("src", "dist");
+	}
+	async autoControllers(controllersPath) {
+		const conDir = this._resolveControllerDir(controllersPath);
+		const isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT || process[Symbol.for("ts-node.register.instance")];
+		try {
+			const files = node_fs.default.readdirSync(conDir, {
+				recursive: true,
+				encoding: "utf-8"
+			});
+			for (const file of files) {
+				if (/\.(test|spec|e2e-spec)\.(ts|js)$/.test(file)) continue;
+				if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
+					const module = await import(node_path.default.join(conDir, file));
+					for (const exported of Object.values(module)) if (typeof exported === "function" && isApiController(exported)) {
+						if (!this.controllers.some((con) => exported.name === con.name)) this.controllers.push(exported);
+					}
+				}
+			}
+		} catch (e) {
+			console.warn("Could not auto-register controllers from " + conDir, e);
+		}
+	}
+	_mapFeatures() {
+		try {
+			typedi.default.get("features");
+		} catch {}
+	}
+	async initializeDatabase() {
+		if (this.dataSourceOptions && this.dataSource) await this.dataSource.initialize();
+	}
+	handleSocket(socket) {
+		try {
+			const { SocketContextService } = (init_event_dispatcher(), require_chunk.__toCommonJS(event_dispatcher_exports));
+			const { EventSubscriberRegistry } = (init_event_subscriber(), require_chunk.__toCommonJS(event_subscriber_exports));
+			const { SocketIoServer } = (init_websocket(), require_chunk.__toCommonJS(websocket_exports));
+			const contextService = typedi.default.get(SocketContextService);
+			typedi.default.get(EventSubscriberRegistry).register(socket);
+			const originalOn = socket.on.bind(socket);
+			socket.on = (event, handler) => {
+				return originalOn(event, (...args) => {
+					contextService.run(socket, () => handler(...args));
+				});
+			};
+		} catch (e) {
+			console.warn("[Avleon] Socket handler error:", e);
+		}
+	}
+	mapGet(path = "", fn) {
+		return this.router.mapGet(path, fn);
+	}
+	mapPost(path = "", fn) {
+		return this.router.mapPost(path, fn);
+	}
+	mapPut(path = "", fn) {
+		return this.router.mapPut(path, fn);
+	}
+	mapDelete(path = "", fn) {
+		return this.router.mapDelete(path, fn);
+	}
+	async run(port = 4e3, fn) {
+		if (this.alreadyRun) throw new SystemUseError("App already running");
+		this.alreadyRun = true;
+		if (this.hasSwagger) await this.initSwagger(this.globalSwaggerOptions);
+		await this.initializeDatabase();
+		if (this.isMapFeatures) this._mapFeatures();
+		if (this.registerControllerAuto) await this.autoControllers();
+		await this._mapControllers();
+		this.router.processFunctionalRoutes();
+		this.app.setErrorHandler((error, request, reply) => {
+			const isDev = process.env.NODE_ENV === "development";
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+			const requestInfo = `${request.method} ${request.url}`;
+			if (error.statusCode === 400 || error.validation) {
+				console.warn(`[${timestamp}] HTTP 400 ${requestInfo} — ${error.message}`);
+				return reply.status(400).send({
+					code: 400,
+					status: "Error",
+					message: error.message,
+					errors: error.validation ?? void 0
+				});
+			}
+			if (error instanceof BaseHttpException) {
+				console.warn(`[${timestamp}] HTTP ${error.code} ${requestInfo} — ${error.message}`);
+				return reply.status(error.code || 500).type("application/json").serializer((payload) => JSON.stringify(payload)).send({
+					code: error.code,
+					status: "Error",
+					message: error.message,
+					data: error.payload
+				});
+			}
+			console.error(`\n❌ UNHANDLED ERROR @ ${timestamp}`);
+			console.error(`   ${requestInfo}`);
+			console.error(`   ${error.name}: ${error.message}`);
+			if (error.stack) console.error(`   Stack:\n${error.stack.split("\n").slice(1).map((l) => `      ${l.trim()}`).join("\n")}`);
+			if (isDev) {
+				console.error(`   Params:`, JSON.stringify(request.params));
+				console.error(`   Query: `, JSON.stringify(request.query));
+				console.error(`   Body:  `, JSON.stringify(request.body));
+			}
+			console.error("");
+			return reply.status(500).send({
+				code: 500,
+				status: "Error",
+				message: isDev ? error.message : "Internal Server Error",
+				...isDev && {
+					error: error.name,
+					stack: error.stack?.split("\n").slice(0, 5)
+				}
+			});
+		});
+		await this.app.ready();
+		if (this._hasWebsocket) {
+			if (!this.app.io) throw new Error("Socket.IO not initialized. Make sure fastify-socket.io is registered correctly.");
+			try {
+				const { SocketIoServer } = (init_websocket(), require_chunk.__toCommonJS(websocket_exports));
+				typedi.default.set(SocketIoServer, this.app.io);
+				await this.app.io.on("connection", this.handleSocket.bind(this));
+			} catch (e) {
+				console.warn("[Avleon] WebSocket setup error:", e);
+			}
+		}
+		await this.app.listen({ port });
+		console.log(`Application running on http://127.0.0.1:${port}`);
+		if (fn) fn();
+	}
+};
+//#endregion
+//#region src/core/testing.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_exceptions();
+init_system_exception();
+var AvleonTest = class AvleonTest {
+	constructor() {
+		process.env.NODE_ENV = "test";
+	}
+	static getController(controller, deps = []) {
+		const paramTypes = Reflect.getMetadata("design:paramtypes", controller) || [];
+		deps.forEach((dep, i) => {
+			typedi.default.set(paramTypes[i], dep);
+		});
+		return typedi.default.get(controller);
+	}
+	static getProvider(service, deps = []) {
+		const paramTypes = Reflect.getMetadata("design:paramtypes", service) || [];
+		deps.forEach((dep, i) => {
+			typedi.default.set(paramTypes[i], dep);
+		});
+		return typedi.default.get(service);
+	}
+	static createTestApplication(options) {
+		const app = AvleonApplication.getInternalApp({ dataSourceOptions: options.dataSource ? options.dataSource : void 0 });
+		if (options.controllers) app.useControllers(options.controllers);
+		return AvleonTest.from(app);
+	}
+	static from(app) {
+		try {
+			app._mapControllers().catch((e) => console.error(e));
+			app.app.setErrorHandler(async (error, req, res) => {
+				if (error instanceof ValidationErrorException) return res.status(400).send({
+					code: 400,
+					error: "ValidationError",
+					errors: error.message
+				});
+				return res.status(500).send(error);
+			});
+			return {
+				get: async (url, options) => app.app.inject({
+					method: "GET",
+					url,
+					...options
+				}),
+				post: async (url, options) => app.app.inject({
+					method: "POST",
+					url,
+					...options
+				}),
+				put: async (url, options) => app.app.inject({
+					method: "PUT",
+					url,
+					...options
+				}),
+				patch: async (url, options) => app.app.inject({
+					method: "PATCH",
+					url,
+					...options
+				}),
+				delete: async (url, options) => app.app.inject({
+					method: "DELETE",
+					url,
+					...options
+				}),
+				options: async (url, options) => app.app.inject({
+					method: "OPTIONS",
+					url,
+					...options
+				}),
+				getController: (controller, deps = []) => {
+					return AvleonTest.getController(controller, deps);
+				}
+			};
+		} catch (error) {
+			throw new SystemUseError("Can't get test appliction");
+		}
+	}
+	static clean() {
+		typedi.default.reset();
+	}
+};
+var Avleon = class {
+	static createApplication() {
+		return AvleonApplication.getApp();
+	}
+	static createTestApplication(options) {
+		return AvleonTest.createTestApplication(options);
+	}
+};
+//#endregion
+//#region src/response.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+var HttpResponse = class {
+	static Ok(obj, s) {
+		if (s) {
+			const isPaginated = obj?.hasOwnProperty("total");
+			const transformedData = (0, class_transformer.plainToInstance)(s, isPaginated ? obj.data : obj, {
+				enableImplicitConversion: true,
+				excludeExtraneousValues: true
+			});
+			return {
+				message: "success",
+				...isPaginated ? {
+					...obj,
+					data: (0, class_transformer.instanceToPlain)(transformedData)
+				} : { data: (0, class_transformer.instanceToPlain)(transformedData) }
+			};
+		}
+		return {
+			message: "success",
+			data: obj
+		};
+	}
+	static Created(obj, s) {
+		if (s) return {
+			message: "created",
+			data: (0, class_transformer.instanceToPlain)((0, class_transformer.plainToInstance)(s, obj, {
+				enableImplicitConversion: true,
+				excludeExtraneousValues: true
+			}))
+		};
+		return {
+			message: "created",
+			data: obj
+		};
+	}
+	static NoContent() {
+		return {
+			message: "no content",
+			data: null
+		};
+	}
+};
+//#endregion
+//#region src/middleware.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_container();
+var AvleonMiddleware = class {};
+var AuthorizeMiddleware = class {};
+function CanAuthorize(target) {
+	if (typeof target.prototype.authorize !== "function") throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
+	(0, typedi.Service)()(target);
+}
+function AppAuthorization(target) {
+	if (typeof target.prototype.authorize !== "function") throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
+	(0, typedi.Service)()(target);
+}
+function Authorized(options = {}) {
+	return function(target, propertyKey, descriptor) {
+		if (propertyKey && descriptor) Reflect.defineMetadata(AUTHORIZATION_META_KEY, {
+			authorize: true,
+			options
+		}, target.constructor, propertyKey);
+		else Reflect.defineMetadata(AUTHORIZATION_META_KEY, {
+			authorize: true,
+			options
+		}, target);
+	};
+}
+function AppMiddleware(target) {
+	if (typeof target.prototype.invoke !== "function") throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+	(0, typedi.Service)()(target);
+}
+/**
+* A decorator function that applies one or more middleware to a class or a method.
+*
+* When applied to a class, the middleware are registered for the entire controller.
+* When applied to a method, the middleware are registered for that specific route.
+*
+* @param options - A single middleware instance/class or an array of middleware instances/classes to be applied.
+* @returns A decorator that registers the middleware metadata.
+*/
+function UseMiddleware(options) {
+	return function(target, propertyKey, descriptor) {
+		const normalizeMiddleware = (middleware) => typeof middleware === "function" ? new middleware() : middleware;
+		const middlewareList = (Array.isArray(options) ? options : [options]).map(normalizeMiddleware);
+		if (typeof target === "function" && !propertyKey) {
+			const existingMiddlewares = Reflect.getMetadata("controller:middleware", target) || [];
+			Reflect.defineMetadata("controller:middleware", [...existingMiddlewares, ...middlewareList], target);
+		} else if (descriptor) {
+			const existingMiddlewares = Reflect.getMetadata("route:middleware", target, propertyKey) || [];
+			Reflect.defineMetadata("route:middleware", [...existingMiddlewares, ...middlewareList], target, propertyKey);
+		}
+	};
+}
+//#endregion
+//#region src/collection.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_exceptions();
+var BasicCollectionImpl = class BasicCollectionImpl {
+	items;
+	constructor(items) {
+		this.items = items;
+	}
+	static from(items) {
+		return new BasicCollectionImpl(items);
+	}
+	clear() {
+		this.items = [];
+	}
+	find(predicate) {
+		if (this.isFunction(predicate)) return this.items.filter(predicate);
+		return Array.from(this.items);
+	}
+	async findAsync(predicate) {
+		return Array.from(this.items);
+	}
+	_matches(item, where) {
+		if ("$or" in where) return where.$or.some((cond) => this._matches(item, cond));
+		if ("$and" in where) return where.$and.every((cond) => this._matches(item, cond));
+		if ("$not" in where) return !this._matches(item, where.$not);
+		return Object.entries(where).every(([key, condition]) => {
+			const itemValue = item[key];
+			if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+				const op = condition;
+				if ("$in" in op && Array.isArray(op.$in)) return op.$in.includes(itemValue);
+			}
+			return itemValue === condition;
+		});
+	}
+	findOne(predicate) {
+		if (this.isFunction(predicate)) return this.items.find(predicate);
+		const result = this.items.filter((item) => this._matches(item, predicate.where));
+		if (result.length > 0) return result[0];
+	}
+	async findOneAsync(predicate) {
+		if (this.isFunction(predicate)) return this.items.find(predicate);
+		return this.items.find((item) => this._matches(item, predicate.where));
+	}
+	isFunction(value) {
+		return typeof value === "function";
+	}
+	add(item) {
+		this.items.push(item);
+		return this.items[this.items.length - 1];
+	}
+	addAll(items) {
+		this.items.push(...items);
+	}
+	update(predicate, updater) {
+		const item = this.items.find(predicate);
+		if (item) {
+			const index = this.items.indexOf(item);
+			this.items[index] = {
+				...item,
+				...updater
+			};
+		} else throw new NotFoundException("Item not found");
+	}
+	updateAll(predicate, updater) {
+		for (let i = 0; i < this.items.length; i++) if (predicate(this.items[i])) this.items[i] = updater(this.items[i]);
+	}
+	delete(predicate) {
+		const index = this.items.findIndex(predicate);
+		if (index !== -1) this.items.splice(index, 1);
+	}
+	deleteAll(predicate) {
+		this.items = this.items.filter((item) => !predicate(item));
+	}
+	max(key) {
+		return Math.max(...this.items.map((item) => item[key]));
+	}
+	min(key) {
+		return Math.max(...this.items.map((item) => item[key]));
+	}
+	sum(key) {
+		return this.items.flatMap((x) => x[key]).reduce((sum, num) => sum + num, 0);
+	}
+	avg(key) {
+		const nums = this.items.flatMap((x) => x[key]);
+		return nums.reduce((sum, num) => sum + num, 0) / nums.length;
+	}
+	paginate(options) {
+		const take = options?.take || 10;
+		const skip = options?.skip || 0;
+		const total = this.items.length;
+		const data = this.items.slice(skip, take);
+		return {
+			total,
+			totalPage: Math.ceil(total / take),
+			next: skip + take < total ? skip + take : null,
+			data
+		};
+	}
+	getDeepValue(item, path) {
+		if (typeof path !== "string") return item[path];
+		return path.split(".").reduce((acc, key) => acc?.[key], item);
+	}
+};
+var AsynchronousCollection = class AsynchronousCollection {
+	model;
+	repo;
+	constructor(model) {
+		this.model = model;
+	}
+	static fromRepository(model) {
+		return new AsynchronousCollection(model);
+	}
+	getRepository() {
+		if (!this.repo) {
+			const dataSource = typedi.default.get("idatasource");
+			console.log("datasource", dataSource);
+			const repository = dataSource.getRepository(this.model);
+			this.repo = repository;
+			return repository;
+		}
+		return this.repo;
+	}
+	async paginate(options) {
+		const take = options?.take || 10;
+		const skip = options?.skip || 0;
+		const [data, total] = await this.getRepository().findAndCount({
+			take,
+			skip
+		});
+		return {
+			total,
+			totalPage: Math.ceil(total / take),
+			next: skip + take < total ? skip + take : null,
+			prev: skip + take < total ? skip + take : null,
+			data
+		};
+	}
+};
+var Collection = class {
+	constructor() {}
+	static from(items) {
+		return BasicCollectionImpl.from(items);
+	}
+	static fromRepository(entity) {
+		return AsynchronousCollection.fromRepository(entity).getRepository();
+	}
+};
+function InjectRepository(model) {
+	return function(object, propertyName, index) {
+		let repo;
+		try {
+			typedi.default.registerHandler({
+				object,
+				propertyName,
+				index,
+				value: (containerInstance) => {
+					repo = containerInstance.get("idatasource").getRepository(model).extend({ paginate: () => {} });
+					repo.paginate = async function(options = {
+						take: 10,
+						skip: 0
+					}) {
+						const [data, total] = await this.findAndCount({
+							take: options.take || 10,
+							skip: options.skip || 0
+						});
+						return {
+							total,
+							totalPage: Math.ceil(total / (options.take || 10)),
+							next: options.skip + options.take < total ? options.skip + options.take : null,
+							data
+						};
+					};
+					return repo;
+				}
+			});
+		} catch (error) {
+			if (error.name && error.name == "ServiceNotFoundError") console.log("Database didn't initialized.");
+		}
+	};
+}
+//#endregion
+//#region src/queue.ts
+var AvleonQueue = class {
+	queue;
+	handlerFn;
+	constructor(name, adapter, handler) {
+		this.name = name;
+		this.adapter = adapter;
+		this.queue = new bull.default(name || "default", adapter);
+		this.handlerFn = handler;
+		if (typeof this.handler === "function" && !this.handlerFn) this.handlerFn = (job) => this.handler(job);
+		if (this.handlerFn) this.queue.process(this.handlerFn);
+	}
+	add(data, options) {
+		return this.queue.add(data, options);
+	}
+	delay(data, delayMs, options) {
+		return this.queue.add(data, {
+			...options,
+			delay: delayMs
+		});
+	}
+	process(handler) {
+		this.handlerFn = handler;
+		this.queue.process(handler);
+	}
+	processConcurrent(concurrency, handler) {
+		this.handlerFn = handler;
+		this.queue.process(concurrency, handler);
+	}
+	getQueue() {
+		return this.queue;
+	}
+	async clean(grace, status) {
+		return this.queue.clean(grace, status);
+	}
+	async close() {
+		await this.queue.close();
+	}
+	async pause() {
+		await this.queue.pause();
+	}
+	async resume() {
+		await this.queue.resume();
+	}
+	async getJob(jobId) {
+		return this.queue.getJob(jobId);
+	}
+	async getJobs(types, start, end) {
+		return this.queue.getJobs(types, start, end);
+	}
+};
+function Queue(config) {
+	return function(target) {
+		const DecoratedClass = class extends target {
+			constructor(...args) {
+				super(config.name, config.adapter, config.handler);
+			}
+		};
+		Object.defineProperty(DecoratedClass, "name", {
+			value: target.name,
+			writable: false
+		});
+		(0, typedi.Service)()(DecoratedClass);
+		return DecoratedClass;
+	};
+}
+//#endregion
+//#region src/file-storage.ts
+init_system_exception();
+init_http_exceptions();
+init_decorateMetadata();
+init_decorate();
+let FileStorage = class FileStorage {
+	transformOptions = null;
+	baseDir;
+	maxFileSize = 50 * 1024 * 1024;
+	constructor() {
+		this.baseDir = node_path.default.join(process.cwd(), "public");
+		this.ensureDirectoryExists(this.baseDir);
+	}
+	/**
+	* Set transformation options for the next save operation
+	*/
+	transform(options) {
+		this.transformOptions = options;
+		return this;
+	}
+	async getUploadFile(fliePath) {
+		return await node_fs.default.promises.readFile(node_path.default.join(this.baseDir, fliePath));
+	}
+	async download(filepath) {
+		const filename = filepath.toString().split(/[\/\\]/).pop() || "file";
+		return {
+			download: true,
+			stream: (0, node_fs.createReadStream)(filepath),
+			filename
+		};
+	}
+	async downloadAs(filepath, filename) {
+		return {
+			download: true,
+			stream: (0, node_fs.createReadStream)(filepath),
+			filename
+		};
+	}
+	/**
+	* Save a single file with optional transformations
+	*/
+	async save(f, options) {
+		const opts = {
+			overwrite: options?.overwrite ?? true,
+			to: options?.to,
+			saveAs: options?.saveAs
+		};
+		if (f.type !== "file") throw new SystemUseError("Invalid file type");
+		try {
+			const filename = opts.saveAs || f.filename;
+			this.validateFilename(filename);
+			const uploadDir = opts.to ? node_path.default.join(this.baseDir, opts.to) : this.baseDir;
+			const fullPath = node_path.default.join(uploadDir, filename);
+			if (!fullPath.startsWith(this.baseDir)) throw new SystemUseError("Invalid file path");
+			if (!opts.overwrite && this.isFileExists(fullPath)) throw new SystemUseError("File already exists");
+			await this.ensureDirectoryExists(uploadDir);
+			let sourceStream;
+			const savedFile = f;
+			if (savedFile.filepath && !f.file) sourceStream = node_fs.default.createReadStream(savedFile.filepath);
+			else if (f.file) sourceStream = f.file;
+			else throw new SystemUseError("No file stream or filepath available");
+			if (this.transformOptions && this.isImageFile(filename)) await this.processImage(sourceStream, fullPath);
+			else await (0, node_stream_promises.pipeline)(sourceStream, node_fs.default.createWriteStream(fullPath));
+			if (savedFile.filepath && node_fs.default.existsSync(savedFile.filepath)) this.removeFileSync(savedFile.filepath);
+			if (opts.saveAs) f.filename = opts.saveAs;
+			return {
+				uploadPath: options?.to ? "/uploads/" + options.to + "/" + f.filename : "/uploads/" + f.filename,
+				staticPath: options?.to ? "/static/" + options.to + "/" + f.filename : "/static/" + f.filename
+			};
+		} catch (err) {
+			if (err instanceof SystemUseError || err instanceof InternalErrorException) throw err;
+			console.error("File save error:", err);
+			throw new SystemUseError("Failed to upload file");
+		}
+	}
+	/**
+	* Save multiple files
+	*/
+	async saveAll(files, options) {
+		if (!files || files.length === 0) return [];
+		const opts = {
+			overwrite: options?.overwrite ?? true,
+			to: options?.to
+		};
+		const uploadDir = opts.to ? node_path.default.join(this.baseDir, opts.to) : this.baseDir;
+		await this.ensureDirectoryExists(uploadDir);
+		const results = [];
+		for (const f of files) try {
+			this.validateFilename(f.filename);
+			const fullPath = node_path.default.join(uploadDir, f.filename);
+			if (!fullPath.startsWith(this.baseDir)) throw new SystemUseError(`Invalid file path for ${f.filename}`);
+			if (!opts.overwrite && this.isFileExists(fullPath)) throw new SystemUseError(`File ${f.filename} already exists`);
+			if (f.file) if (this.transformOptions && this.isImageFile(f.filename)) await this.processImage(f.file, fullPath);
+			else await (0, node_stream_promises.pipeline)(f.file, node_fs.default.createWriteStream(fullPath));
+			else {
+				const fp = f;
+				if (!fp.filepath) throw new SystemUseError(`No filepath for ${f.filename}`);
+				if (this.transformOptions && this.isImageFile(f.filename)) await this.processImage(node_fs.default.createReadStream(fp.filepath), fullPath);
+				else await (0, node_stream_promises.pipeline)(node_fs.default.createReadStream(fp.filepath), node_fs.default.createWriteStream(fullPath));
+				this.removeFileSync(fp.filepath);
+			}
+			results.push({
+				uploadPath: options?.to ? "/uploads/" + options.to + "/" + f.filename : "/uploads/" + f.filename,
+				staticPath: options?.to ? "/static/" + options.to + "/" + f.filename : "/static/" + f.filename
+			});
+		} catch (error) {
+			console.error(`Failed to save file ${f.filename}:`, error);
+			throw new SystemUseError(`Failed to upload file ${f.filename}`);
+		}
+		return results;
+	}
+	/**
+	* Remove a file from storage
+	*/
+	async remove(filepath) {
+		const fullPath = node_path.default.join(this.baseDir, filepath);
+		if (!fullPath.startsWith(this.baseDir)) throw new SystemUseError("Invalid file path");
+		if (!this.isFileExists(fullPath)) throw new SystemUseError("File doesn't exist");
+		try {
+			node_fs.default.unlinkSync(fullPath);
+		} catch (error) {
+			console.error("File removal error:", error);
+			throw new SystemUseError("Failed to remove file");
+		}
+	}
+	/**
+	* Process image with transformations using sharp
+	*/
+	async processImage(fileStream, outputPath) {
+		try {
+			let sharpPipeline = (await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require("./lib-Bk8hUm06.cjs").default, 1))).default();
+			if (this.transformOptions?.resize) sharpPipeline = sharpPipeline.resize(this.transformOptions.resize.width, this.transformOptions.resize.height, {
+				fit: "inside",
+				withoutEnlargement: true
+			});
+			if (this.transformOptions?.format) {
+				const quality = this.transformOptions.quality || 80;
+				switch (this.transformOptions.format) {
+					case "jpeg":
+						sharpPipeline = sharpPipeline.jpeg({ quality });
+						break;
+					case "png":
+						sharpPipeline = sharpPipeline.png({ quality });
+						break;
+					case "webp":
+						sharpPipeline = sharpPipeline.webp({ quality });
+						break;
+					case "avif":
+						sharpPipeline = sharpPipeline.avif({ quality });
+						break;
+				}
+			}
+			await (0, node_stream_promises.pipeline)(fileStream, sharpPipeline, node_fs.default.createWriteStream(outputPath));
+		} catch (error) {
+			if (error.code === "MODULE_NOT_FOUND" && error.message.includes("sharp")) throw new InternalErrorException("sharp module not found. Please install sharp to use image transformations.");
+			console.error("Image processing failed:", error);
+			throw new InternalErrorException("Image processing failed");
+		} finally {
+			this.transformOptions = null;
+		}
+	}
+	/**
+	* Helper methods
+	*/
+	isFileExists(fpath) {
+		return node_fs.default.existsSync(fpath);
+	}
+	async ensureDirectoryExists(dirPath) {
+		if (!node_fs.default.existsSync(dirPath)) node_fs.default.mkdirSync(dirPath, { recursive: true });
+	}
+	removeFileSync(filepath) {
+		try {
+			if (node_fs.default.existsSync(filepath)) node_fs.default.unlinkSync(filepath);
+		} catch (error) {
+			console.error("Failed to remove temp file:", error);
+		}
+	}
+	isImageFile(filename) {
+		const ext = node_path.default.extname(filename).toLowerCase();
+		return [
+			".jpg",
+			".jpeg",
+			".png",
+			".webp",
+			".avif",
+			".gif",
+			".bmp"
+		].includes(ext);
+	}
+	validateFilename(filename) {
+		if (!filename || filename.trim() === "") throw new SystemUseError("Invalid filename");
+		if (filename.includes("..") || filename.includes("/") || filename.includes("\\")) throw new SystemUseError("Invalid filename: path traversal detected");
+		if (filename.includes("\0")) throw new SystemUseError("Invalid filename: null byte detected");
+	}
+};
+FileStorage = __decorate([AppService, __decorateMetadata("design:paramtypes", [])], FileStorage);
+//#endregion
+//#region src/environment-variables.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_system_exception();
+init_decorate();
+dotenv.default.config({
+	path: node_path.default.join(process.cwd(), ".env"),
+	quiet: true
+});
+let Environment = class Environment {
+	/**
+	* Parses the given `.env` file and merges it with `process.env`.
+	* Values from `process.env` take precedence.
+	*
+	* @private
+	* @param filePath - Absolute path to the `.env` file.
+	* @returns A dictionary of merged environment variables.
+	*/
+	parseEnvFile(filePath) {
+		try {
+			if (!(0, node_fs.existsSync)(filePath)) return { ...process.env };
+			const fileContent = node_fs.default.readFileSync(filePath, "utf8");
+			return {
+				...dotenv.default.parse(fileContent),
+				...process.env
+			};
+		} catch (error) {
+			console.error(`Error parsing .env file: ${error}`);
+			return {};
+		}
+	}
+	/**
+	* Retrieves the value of the specified environment variable.
+	*
+	* @template T
+	* @param key - The name of the environment variable.
+	* @returns The value of the variable, or `undefined` if not found.
+	*/
+	get(key) {
+		return this.parseEnvFile(node_path.default.join(process.cwd(), ".env"))[key];
+	}
+	/**
+	* Retrieves the value of the specified environment variable.
+	* Throws an error if the variable is not found.
+	*
+	* @template T
+	* @param key - The name of the environment variable.
+	* @throws {EnvironmentVariableNotFound} If the variable does not exist.
+	* @returns The value of the variable.
+	*/
+	getOrThrow(key) {
+		const parsedEnv = this.parseEnvFile(node_path.default.join(process.cwd(), ".env"));
+		if (!Object(parsedEnv).hasOwnProperty(key)) throw new EnvironmentVariableNotFound(key);
+		return parsedEnv[key];
+	}
+	/**
+	* Retrieves all available environment variables,
+	* with `process.env` values taking precedence over `.env` values.
+	*
+	* @template T
+	* @returns An object containing all environment variables.
+	*/
+	getAll() {
+		return this.parseEnvFile(node_path.default.join(process.cwd(), ".env"));
+	}
+};
+Environment = __decorate([(0, typedi.Service)()], Environment);
+//#endregion
+//#region src/config.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_helpers();
+function AppConfig(target) {
+	typedi.Container.set({
+		id: target,
+		type: target
+	});
+}
+var AvleonConfig = class {
+	get(configClass) {
+		const instance = typedi.Container.get(configClass);
+		if (!instance) throw new Error(`Configuration for ${configClass.name} not found.`);
+		return instance.config(new Environment());
+	}
+};
+function GetConfig(token) {
+	if (typeof token === "function" && token.prototype != null && typeof token.prototype.config === "function") {
+		const instance = typedi.Container.get(token);
+		if (!instance) throw new Error(`Class "${token.name}" is not registered as a config.`);
+		return instance.config(inject(Environment));
+	}
+	const stored = typedi.Container.get(token);
+	if (!stored) throw new Error("Config object is not registered.");
+	return stored;
+}
+function CreateConfig(token, callback) {
+	let env;
+	try {
+		env = typedi.Container.get(Environment);
+	} catch (error) {
+		env = new Environment();
+	}
+	let config = callback(env);
+	typedi.Container.set(token, config);
+}
+//#endregion
+//#region src/logger.ts
+init_decorateMetadata();
+init_decorate();
+let LoggerService = class LoggerService {
+	logger;
+	constructor() {
+		this.logger = (0, pino.default)({
+			level: process.env.LOG_LEVEL || "info",
+			transport: {
+				target: "pino-pretty",
+				options: {
+					translateTime: "SYS:standard",
+					ignore: "pid,hostname"
+				}
+			}
+		});
+	}
+	getLogger() {
+		return this.logger;
+	}
+	info(message, obj) {
+		if (obj) this.logger.info(obj, message);
+		else this.logger.info(message);
+	}
+	error(message, obj) {
+		if (obj) this.logger.error(obj, message);
+		else this.logger.error(message);
+	}
+	warn(message, obj) {
+		if (obj) this.logger.warn(obj, message);
+		else this.logger.warn(message);
+	}
+	debug(message, obj) {
+		if (obj) this.logger.debug(obj, message);
+		else this.logger.debug(message);
+	}
+	fatal(message, obj) {
+		if (obj) this.logger.fatal(obj, message);
+		else this.logger.fatal(message);
+	}
+	trace(message, obj) {
+		if (obj) this.logger.trace(obj, message);
+		else this.logger.trace(message);
+	}
+};
+LoggerService = __decorate([AppService, __decorateMetadata("design:paramtypes", [])], LoggerService);
+//#endregion
+//#region src/cache.ts
+var CacheManager = class {
+	store = /* @__PURE__ */ new Map();
+	tagsMap = /* @__PURE__ */ new Map();
+	redis = null;
+	constructor(redisInstance) {
+		this.redis = redisInstance || null;
+	}
+	redisTagKey(tag) {
+		return `cache-tags:${tag}`;
+	}
+	async get(key) {
+		if (this.redis) {
+			const val = await this.redis.get(key);
+			return val ? JSON.parse(val) : null;
+		}
+		const cached = this.store.get(key);
+		return cached ? cached.data : null;
+	}
+	async set(key, value, tags = [], ttl = 3600) {
+		const entry = {
+			data: value,
+			timestamp: Date.now()
+		};
+		if (this.redis) {
+			await this.redis.set(key, JSON.stringify(entry.data), "EX", ttl);
+			for (const tag of tags) await this.redis.sadd(this.redisTagKey(tag), key);
+		} else {
+			this.store.set(key, entry);
+			for (const tag of tags) {
+				if (!this.tagsMap.has(tag)) this.tagsMap.set(tag, /* @__PURE__ */ new Set());
+				this.tagsMap.get(tag).add(key);
+			}
+		}
+	}
+	async delete(key) {
+		if (this.redis) {
+			await this.redis.del(key);
+			const tagKeys = await this.redis.keys("cache-tags:*");
+			for (const tagKey of tagKeys) await this.redis.srem(tagKey, key);
+		} else {
+			this.store.delete(key);
+			for (const keys of this.tagsMap.values()) keys.delete(key);
+		}
+	}
+	async invalidateTag(tag) {
+		if (this.redis) {
+			const tagKey = this.redisTagKey(tag);
+			const keys = await this.redis.smembers(tagKey);
+			if (keys.length) {
+				await this.redis.del(...keys);
+				await this.redis.del(tagKey);
+			}
+		} else {
+			const keys = this.tagsMap.get(tag);
+			if (keys) {
+				for (const key of keys) this.store.delete(key);
+				this.tagsMap.delete(tag);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/results.ts
+var Results = class {
+	static code = 500;
+	message = "Something going wrong";
+	static Ok(data) {
+		return new Ok(data);
+	}
+	static NoContent() {
+		this.code = 204;
+	}
+	static OkStream() {}
+	static NotFound(message) {
+		return new NotFound(message);
+	}
+};
+var Ok = class {
+	constructor(data) {
+		this.data = data;
+	}
+};
+var NotFound = class {
+	constructor(message) {
+		this.message = message;
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* @copyright 2024
+* @author Tareq Hossain
+* @email xtrinsic96@gmail.com
+* @url https://github.com/xtareq
+*/
+init_helpers();
+init_exceptions();
+init_container();
+init_kenx_provider();
+init_event_dispatcher();
+init_event_subscriber();
+init_container();
+const GetSchema = generateSwaggerSchema;
+const GetObjectSchema = CreateSwaggerObjectSchema;
+const OpenApiOk = (args1) => {
+	return OpenApiResponse$1(200, args1, "Success");
+};
+const OpenApiResponse = OpenApiResponse$1;
+const OpenApiProperty = OpenApiProperty$1;
+//#endregion
+exports.API_CONTROLLER_METADATA_KEY = API_CONTROLLER_METADATA_KEY;
+exports.AUTHORIZATION_META_KEY = AUTHORIZATION_META_KEY;
+exports.All = All;
+exports.ApiController = ApiController;
+exports.AppAuthorization = AppAuthorization;
+exports.AppConfig = AppConfig;
+exports.AppMiddleware = AppMiddleware;
+exports.AppService = AppService;
+exports.AuthUser = AuthUser;
+exports.AuthorizeMiddleware = AuthorizeMiddleware;
+exports.Authorized = Authorized;
+exports.Avleon = Avleon;
+exports.AvleonApplication = AvleonApplication;
+exports.AvleonConfig = AvleonConfig;
+exports.AvleonContainer = container_default;
+exports.AvleonMiddleware = AvleonMiddleware;
+exports.AvleonQueue = AvleonQueue;
+exports.AvleonRequest = AvleonRequest;
+exports.AvleonTest = AvleonTest;
+exports.BadRequestException = BadRequestException;
+exports.BaseHttpException = BaseHttpException;
+exports.Body = Body;
+exports.CONTROLLER_META_KEY = CONTROLLER_META_KEY;
+exports.CacheManager = CacheManager;
+exports.CanAuthorize = CanAuthorize;
+exports.Collection = Collection;
+exports.CreateConfig = CreateConfig;
+exports.CreateSwaggerObjectSchema = CreateSwaggerObjectSchema;
+exports.DATASOURCE_META_KEY = DATASOURCE_META_KEY;
+Object.defineProperty(exports, "DB", {
+	enumerable: true,
+	get: function() {
+		return DB;
+	}
+});
+exports.Delete = Delete;
+exports.Dispatch = Dispatch;
+Object.defineProperty(exports, "Environment", {
+	enumerable: true,
+	get: function() {
+		return Environment;
+	}
+});
+Object.defineProperty(exports, "EventDispatcher", {
+	enumerable: true,
+	get: function() {
+		return EventDispatcher;
+	}
+});
+Object.defineProperty(exports, "EventSubscriberRegistry", {
+	enumerable: true,
+	get: function() {
+		return EventSubscriberRegistry;
+	}
+});
+exports.FEATURE_KEY = FEATURE_KEY;
+Object.defineProperty(exports, "FileStorage", {
+	enumerable: true,
+	get: function() {
+		return FileStorage;
+	}
+});
+exports.ForbiddenException = ForbiddenException;
+exports.Get = Get;
+exports.GetConfig = GetConfig;
+exports.GetObjectSchema = GetObjectSchema;
+exports.GetSchema = GetSchema;
+exports.Header = Header;
+exports.Helper = Helper;
+exports.HttpExceptions = HttpExceptions;
+exports.HttpResponse = HttpResponse;
+exports.InjectRepository = InjectRepository;
+exports.InternalErrorException = InternalErrorException;
+Object.defineProperty(exports, "LoggerService", {
+	enumerable: true,
+	get: function() {
+		return LoggerService;
+	}
+});
+exports.NotFound = NotFound;
+exports.NotFoundException = NotFoundException;
+exports.Ok = Ok;
+exports.OpenApi = OpenApi;
+exports.OpenApiOk = OpenApiOk;
+exports.OpenApiProperty = OpenApiProperty;
+exports.OpenApiResponse = OpenApiResponse;
+exports.OpenApiSchema = OpenApiSchema;
+exports.Options = Options;
+exports.PARAM_META_KEY = PARAM_META_KEY;
+exports.Param = Param;
+exports.Patch = Patch;
+exports.Post = Post;
+exports.Private = Private;
+exports.Put = Put;
+exports.QUERY_META_KEY = QUERY_META_KEY;
+exports.Query = Query;
+exports.Queue = Queue;
+exports.REQUEST_BODY_FILES_KEY = REQUEST_BODY_FILES_KEY;
+exports.REQUEST_BODY_FILE_KEY = REQUEST_BODY_FILE_KEY;
+exports.REQUEST_BODY_META_KEY = REQUEST_BODY_META_KEY;
+exports.REQUEST_HEADER_META_KEY = REQUEST_HEADER_META_KEY;
+exports.REQUEST_METADATA_KEY = REQUEST_METADATA_KEY;
+exports.REQUEST_USER_META_KEY = REQUEST_USER_META_KEY;
+exports.ROUTE_META_KEY = ROUTE_META_KEY;
+exports.Results = Results;
+exports.Route = Route;
+Object.defineProperty(exports, "SocketContextService", {
+	enumerable: true,
+	get: function() {
+		return SocketContextService;
+	}
+});
+exports.Subscribe = Subscribe;
+exports.UnauthorizedException = UnauthorizedException;
+exports.UseMiddleware = UseMiddleware;
+exports.Utility = Utility;
+exports.ValidationErrorException = ValidationErrorException;
+exports.Validator = Validator;
+exports.autoCast = autoCast;
+exports.createControllerDecorator = createControllerDecorator;
+exports.exclude = exclude;
+exports.extrctParamFromUrl = extrctParamFromUrl;
+exports.findDuplicates = findDuplicates;
+exports.formatUrl = formatUrl;
+exports.generateClassSchema = generateClassSchema;
+exports.generateSwaggerSchema = generateSwaggerSchema;
+exports.getDataType = getDataType;
+exports.getLineNumber = getLineNumber;
+exports.getPrivateChannelResolver = getPrivateChannelResolver;
+exports.getRegisteredControllers = getRegisteredControllers;
+exports.getRegisteredServices = getRegisteredServices;
+exports.getSocketSubscribers = getSocketSubscribers;
+exports.inject = inject;
+exports.isApiController = isApiController;
+exports.isClassValidator = isClassValidator;
+exports.isClassValidatorClass = isClassValidatorClass;
+exports.isConstructor = isConstructor;
+exports.isPrivate = isPrivate;
+exports.isValidJsonString = isValidJsonString;
+exports.isValidType = isValidType;
+exports.jsonToInstance = jsonToInstance;
+exports.jsonToJs = jsonToJs;
+exports.normalizeParamsToJsonSchema = normalizeParamsToJsonSchema;
+exports.normalizePath = normalizePath;
+exports.normalizeQueryDeep = normalizeQueryDeep;
+exports.parsedPath = parsedPath;
+exports.pick = pick;
+exports.registerController = registerController;
+exports.registerDataSource = registerDataSource;
+exports.registerKnex = registerKnex;
+exports.registerService = registerService;
+exports.registerSocketSubscriber = registerSocketSubscriber;
+exports.sleep = sleep;
+exports.transformObjectByInstanceToObject = transformObjectByInstanceToObject;
+exports.uuid = uuid;
+exports.validateObjectByInstance = validateObjectByInstance;
+exports.validateOrThrow = validateOrThrow;
+exports.validateRequestBody = validateRequestBody;
+
+//# sourceMappingURL=index.cjs.map