moost 0.5.29 → 0.5.31

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { Mate, getConstructor, isConstructor } from "@prostojs/mate";
-import { ContextInjector, EventLogger, createAsyncEventContext, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams } from "@wooksjs/event-core";
-import { Infact, createProvideRegistry, createReplaceRegistry } from "@prostojs/infact";
-import { ProstoLogger, coloredConsole, createConsoleTransort } from "@prostojs/logger";
+import { Mate, getConstructor, getConstructor as getConstructor$1, isConstructor, isConstructor as isConstructor$1 } from "@prostojs/mate";
+import { ContextInjector, EventLogger, createAsyncEventContext, getContextInjector, getContextInjector as getContextInjector$1, replaceContextInjector, useAsyncEventContext, useAsyncEventContext as useAsyncEventContext$1, useEventId, useEventLogger, useEventLogger as useEventLogger$1, useRouteParams } from "@wooksjs/event-core";
+import { Infact, createProvideRegistry, createProvideRegistry as createProvideRegistry$1, createReplaceRegistry, createReplaceRegistry as createReplaceRegistry$1 } from "@prostojs/infact";
+import { ProstoLogger, ProstoLogger as ProstoLogger$1, coloredConsole, createConsoleTransort } from "@prostojs/logger";
 import { Hookable } from "hookable";
 import { clearGlobalWooks, getGlobalWooks } from "wooks";
 
@@ -11,12 +11,20 @@ function setDefaultLogger(logger) {
 	defaultLogger = logger;
 }
 function getDefaultLogger(topic) {
-	if (!defaultLogger) defaultLogger = new ProstoLogger({
+	if (!defaultLogger) defaultLogger = new ProstoLogger$1({
 		level: 4,
-		transports: [createConsoleTransort({ format: coloredConsole })]
+		transports: [loggerConsoleTransport]
 	});
-	return topic && defaultLogger instanceof ProstoLogger ? defaultLogger.createTopic(topic) : defaultLogger;
+	return topic && defaultLogger instanceof ProstoLogger$1 ? defaultLogger.createTopic(topic) : defaultLogger;
 }
+function createLogger(opts) {
+	return new ProstoLogger$1({
+		...opts,
+		level: opts?.level ?? 4,
+		transports: opts?.transports ?? [loggerConsoleTransport]
+	});
+}
+const loggerConsoleTransport = createConsoleTransort({ format: coloredConsole });
 
 //#endregion
 //#region packages/moost/src/pipes/run-pipes.ts
@@ -46,7 +54,7 @@ function getMoostMate() {
 //#endregion
 //#region packages/moost/src/metadata/infact.ts
 const sharedMoostInfact = getNewMoostInfact();
-const INFACT_BANNER = `${"\x1B[2m\x1B[35m"}infact`;
+const INFACT_BANNER = `infact`;
 let loggingOptions = {
 	newInstance: "SINGLETON",
 	warn: true,
@@ -61,16 +69,28 @@ function setInfactLoggingOptions(options) {
 function getMoostInfact() {
 	return sharedMoostInfact;
 }
-const scopeVarsMap = new Map();
-function defineInfactScope(name, scopeVars) {
+const scopeVarsMap = /* @__PURE__ */ new Map();
+/**
+* Define global scope name to be used with `@InjectFromScope` and `@InjectScopeVars` decorators
+*
+* You can read scoped vars with `getInfactScopeVars`
+* @param name scope name
+* @param scopeVars key-value object as scoped vars
+*/ function defineInfactScope(name, scopeVars) {
 	scopeVarsMap.set(name, scopeVars);
 	getMoostInfact().registerScope(name);
 }
-function getInfactScopeVars(name) {
+/**
+* Read scoped vars defined with `defineInfactScope`
+* @param name scope name
+* @returns key-value object as scoped vars
+*/ function getInfactScopeVars(name) {
 	return scopeVarsMap.get(name);
 }
-function getNewMoostInfact() {
-	return new Infact({
+/**
+* Get Infact instance (used for Dependency Injections)
+*/ function getNewMoostInfact() {
+	const infactInstance = new Infact({
 		describeClass(classConstructor) {
 			const meta = getMoostMate().read(classConstructor);
 			return {
@@ -79,25 +99,26 @@ function getNewMoostInfact() {
 				constructorParams: meta?.params || [],
 				provide: meta?.provide,
 				properties: meta?.properties || [],
-				scopeId: meta?.injectable === "FOR_EVENT" ? useEventId().getId() : undefined
+				scopeId: meta?.injectable === "FOR_EVENT" ? useEventId().getId() : void 0
 			};
 		},
-		resolveParam({ paramMeta, customData, classConstructor, index, scopeId }) {
-			if (paramMeta && customData?.pipes) return runPipes(customData.pipes, undefined, {
+		resolveParam({ paramMeta, customData, classConstructor, index, scopeId, instantiate }) {
+			if (paramMeta && customData?.pipes) return runPipes(customData.pipes, void 0, {
 				paramMeta,
 				type: classConstructor,
 				key: "constructor",
 				scopeId,
 				classMeta: getMoostMate().read(classConstructor),
 				index,
-				targetMeta: paramMeta
+				targetMeta: paramMeta,
+				instantiate
 			}, "PARAM");
 		},
 		describeProp(classConstructor, key) {
 			const meta = getMoostMate().read(classConstructor, key);
 			return meta;
 		},
-		resolveProp({ instance, key, initialValue, propMeta, scopeId, classMeta, customData, classConstructor }) {
+		resolveProp({ instance, key, initialValue, propMeta, scopeId, classMeta, customData, classConstructor, instantiate }) {
 			if (propMeta && customData?.pipes) return runPipes(customData.pipes, initialValue, {
 				instance,
 				type: classConstructor,
@@ -105,7 +126,8 @@ function getNewMoostInfact() {
 				scopeId,
 				propMeta,
 				targetMeta: propMeta,
-				classMeta
+				classMeta,
+				instantiate
 			}, "PROP");
 		},
 		storeProvideRegByInstance: true,
@@ -124,39 +146,40 @@ function getNewMoostInfact() {
 					if (!loggingOptions.error) return;
 					break;
 				}
+				default:
 			}
 			let logger;
 			try {
-				logger = event === "error" ? getDefaultLogger(INFACT_BANNER) : useEventLogger(INFACT_BANNER);
+				logger = event === "error" ? getDefaultLogger(INFACT_BANNER) : useEventLogger$1(INFACT_BANNER);
 			} catch (error) {
 				logger = getDefaultLogger(INFACT_BANNER);
 			}
-			const instance = `${"\x1B[4m"}${targetClass.name}${"\x1B[24m"}`;
+			const instance = `${targetClass.name}`;
 			switch (event) {
 				case "new-instance": {
 					const params = args?.map((a) => {
 						switch (typeof a) {
 							case "number":
-							case "boolean": return `${"\x1B[33m"}${a}${"\x1B[2m\x1B[34m"}`;
-							case "string": return `${"\x1B[92m"}"${a.slice(0, 1)}..."${"\x1B[2m\x1B[34m"}`;
+							case "boolean": return `${a}`;
+							case "string": return `"${a.slice(0, 1)}..."`;
 							case "object": {
 								if (Array.isArray(a)) return `[${a.length}]`;
-								if (getConstructor(a)) return getConstructor(a).name;
+								if (getConstructor$1(a)) return getConstructor$1(a).name;
 								return "{}";
 							}
 							default: return "*";
 						}
-					}).map((a) => `${"\x1B[2m\x1B[1m"}${a}${"\x1B[22m\x1B[2m"}`).join(", ") || "";
-					logger.info(`new ${instance}${"\x1B[2m\x1B[34m"}(${params})`);
+					}).map((a) => `${a}`).join(", ") || "";
+					logger.info(`new ${instance}(${params})`);
 					break;
 				}
 				case "warn": {
-					const hier = `${"\x1B[2m\x1B[34m"}⋱ ${args?.map(String).join(" → ") || ""}`;
+					const hier = `⋱ ${args?.map(String).join(" → ") || ""}`;
 					logger.warn(`${instance} - ${message} ${hier}`);
 					break;
 				}
 				case "error": {
-					const hier = `${"\x1B[2m\x1B[34m"}⋱ ${args?.map(String).join(" → ") || ""}`;
+					const hier = `⋱ ${args?.map(String).join(" → ") || ""}`;
 					logger.error(`Failed to instantiate ${instance}. ${message} ${hier}`);
 					break;
 				}
@@ -164,19 +187,20 @@ function getNewMoostInfact() {
 			}
 		}
 	});
+	return infactInstance;
 }
 
 //#endregion
 //#region packages/moost/src/composables/controller.composable.ts
 function setControllerContext(controller, method, route) {
-	const { store } = useAsyncEventContext();
+	const { store } = useAsyncEventContext$1();
 	const { set } = store("controller");
 	set("instance", controller);
 	set("method", method);
 	set("route", route);
 }
 function useControllerContext() {
-	const { store } = useAsyncEventContext();
+	const { store } = useAsyncEventContext$1();
 	const { get } = store("controller");
 	const getController = () => get("instance");
 	const getMethod = () => get("method");
@@ -210,10 +234,10 @@ function registerEventScope(scopeId) {
 	};
 }
 function defineMoostEventHandler(options) {
-	const ci = getContextInjector();
+	const ci = getContextInjector$1();
 	return async () => {
 		const scopeId = useEventId().getId();
-		const logger = useEventLogger(options.loggerTitle);
+		const logger = useEventLogger$1(options.loggerTitle);
 		const unscope = registerEventScope(scopeId);
 		let response;
 		const hookOptions = {
@@ -233,7 +257,7 @@ function defineMoostEventHandler(options) {
 		const interceptorHandler = await options.getIterceptorHandler();
 		if (interceptorHandler?.count) try {
 			response = await ci.with("Interceptors:init", () => interceptorHandler.init());
-			if (response !== undefined) return await endWithResponse();
+			if (response !== void 0) return await endWithResponse();
 		} catch (error) {
 			options.logErrors && logger.error(error);
 			response = error;
@@ -249,7 +273,7 @@ function defineMoostEventHandler(options) {
 		}
 		if (interceptorHandler?.countBefore) {
 			response = await ci.with("Interceptors:before", () => interceptorHandler.fireBefore(response));
-			if (response !== undefined) return endWithResponse();
+			if (response !== void 0) return endWithResponse();
 		}
 		const callControllerMethod = () => {
 			if (options.callControllerMethod) return options.callControllerMethod(args);
@@ -258,7 +282,7 @@ function defineMoostEventHandler(options) {
 		try {
 			response = await ci.with(`Handler:${options.targetPath}`, {
 				"moost.handler": options.controllerMethod || "",
-				"moost.controller": getConstructor(instance).name
+				"moost.controller": getConstructor$1(instance).name
 			}, () => callControllerMethod());
 		} catch (error) {
 			options.logErrors && logger.error(error);
@@ -287,7 +311,7 @@ function defineMoostEventHandler(options) {
 function getInstanceOwnMethods(instance) {
 	const proto = Object.getPrototypeOf(instance);
 	return [
-		...getParentProps(getConstructor(instance)),
+		...getParentProps(getConstructor$1(instance)),
 		...Object.getOwnPropertyNames(proto),
 		...Object.getOwnPropertyNames(instance)
 	].filter((m) => typeof instance[m] === "function");
@@ -295,7 +319,7 @@ function getInstanceOwnMethods(instance) {
 function getInstanceOwnProps(instance) {
 	const proto = Object.getPrototypeOf(instance);
 	return [
-		...getParentProps(getConstructor(instance)),
+		...getParentProps(getConstructor$1(instance)),
 		...Object.getOwnPropertyNames(proto),
 		...Object.getOwnPropertyNames(instance)
 	].filter((m) => typeof instance[m] !== "function");
@@ -318,7 +342,7 @@ async function getCallableFn(targetInstance, fn, pipes, logger) {
 		return (...args) => instance.handler(...args);
 	}
 	if (typeof fn === "function") return fn;
-	const e = new Error(`getCallableFn failed for "${getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
+	const e = /* @__PURE__ */ new Error(`getCallableFn failed for "${getConstructor$1(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
 	logger.error(e);
 	throw e;
 }
@@ -353,7 +377,7 @@ var InterceptorHandler = class {
 		this.responseOverwritten = true;
 	}
 	async init() {
-		const ci = getContextInjector();
+		const ci = getContextInjector$1();
 		for (const { handler, name } of this.handlers) {
 			const response = await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "init" }, () => handler((fn) => {
 				this.before.push({
@@ -371,11 +395,11 @@ var InterceptorHandler = class {
 					fn
 				});
 			}));
-			if (response !== undefined) return response;
+			if (response !== void 0) return response;
 		}
 	}
 	async fireBefore(response) {
-		const ci = getContextInjector();
+		const ci = getContextInjector$1();
 		this.response = response;
 		for (const { name, fn } of this.before) {
 			await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "before" }, () => fn(this.replyFn.bind(this)));
@@ -384,7 +408,7 @@ var InterceptorHandler = class {
 		return this.response;
 	}
 	async fireAfter(response) {
-		const ci = getContextInjector();
+		const ci = getContextInjector$1();
 		this.response = response;
 		if (response instanceof Error) for (const { name, fn } of this.onError) await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "after" }, () => fn(response, this.replyFn.bind(this)));
 		else for (const { name, fn } of this.after) await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "onError" }, () => fn(response, this.replyFn.bind(this)));
@@ -467,18 +491,19 @@ async function bindControllerMethods(options) {
 		});
 		const resolveArgs = async () => {
 			const args = [];
-			for (const [i, { pipes: pipes$1, meta: paramMeta }] of argsPipes.entries()) args[i] = await runPipes(pipes$1, undefined, {
+			for (const [i, { pipes: pipes$1, meta: paramMeta }] of argsPipes.entries()) args[i] = await runPipes(pipes$1, void 0, {
 				classMeta: meta,
 				methodMeta,
 				paramMeta,
 				type: classConstructor,
 				key: method,
 				index: i,
-				targetMeta: paramMeta
+				targetMeta: paramMeta,
+				instantiate: (t) => useControllerContext().instantiate(t)
 			}, "PARAM");
 			return args;
 		};
-		const wm = new WeakMap();
+		const wm = /* @__PURE__ */ new WeakMap();
 		controllerOverview.handlers.push(...methodMeta.handlers.map((h) => {
 			const data = {
 				meta: methodMeta,
@@ -522,22 +547,67 @@ function Circular(resolver) {
 
 //#endregion
 //#region packages/moost/src/decorators/common.decorator.ts
-function Label(value) {
+/**
+* Apply Multiple Decorators
+*
+* @param decorators - array of decorators
+* @returns
+*/ function ApplyDecorators(...decorators) {
+	const mate$1 = getMoostMate();
+	return mate$1.apply(...decorators);
+}
+/**
+* ## Label
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Label metadata
+*/ function Label(value) {
 	return getMoostMate().decorate("label", value);
 }
-function Description(value) {
+/**
+* ## Description
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Description metadata
+*/ function Description(value) {
 	return getMoostMate().decorate("description", value);
 }
-function Value(value) {
+/**
+* ## Value
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Value metadata
+*/ function Value(value) {
 	return getMoostMate().decorate("value", value);
 }
-function Id(value) {
+/**
+* ## Id
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Id metadata
+*/ function Id(value) {
 	return getMoostMate().decorate("id", value);
 }
-function Optional() {
+/**
+* ## Optional
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Optional metadata
+*/ function Optional() {
 	return getMoostMate().decorate("optional", true);
 }
-function Required() {
+/**
+* ## Required
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Required metadata
+*/ function Required() {
 	const mate$1 = getMoostMate();
 	return mate$1.apply(mate$1.decorate("required", true), mate$1.decorateClass((meta, level, key, index) => {
 		if (typeof index !== "number" && meta && ["string", "symbol"].includes(typeof key)) {
@@ -550,7 +620,15 @@ function Required() {
 
 //#endregion
 //#region packages/moost/src/decorators/injectable.decorator.ts
-function Injectable(scope = true) {
+/**
+* ## Injectable
+* ### @Decorator
+* Mark the Class as Injectable to enable it to be used in dependency injection
+* @param scope - Scope for injection ("FOR_EVENT" | "SINGLETON" | true)
+* FOR_EVENT - will create a new instance for each incoming request
+* SINGLETON | true - will create a new instance only once
+* @param label - field label
+*/ function Injectable(scope = true) {
 	return getMoostMate().decorate("injectable", scope);
 }
 const insureInjectable = getMoostMate().decorate((meta) => {
@@ -560,25 +638,35 @@ const insureInjectable = getMoostMate().decorate((meta) => {
 
 //#endregion
 //#region packages/moost/src/decorators/controller.decorator.ts
-function Controller(prefix) {
+/**
+* ## Controller
+* ### @Decorator
+* Set Class as a Controller
+* @param prefix - define the prefix for all the paths of this controller
+*/ function Controller(prefix) {
 	const mate$1 = getMoostMate();
 	return mate$1.apply(insureInjectable, mate$1.decorate("controller", { prefix: prefix || "" }));
 }
 function ImportController(prefix, controller, provide) {
 	return getMoostMate().decorate("importController", {
-		prefix: typeof prefix === "string" ? prefix : undefined,
+		prefix: typeof prefix === "string" ? prefix : void 0,
 		typeResolver: typeof prefix === "string" ? controller : prefix,
-		provide: typeof prefix === "string" ? provide || undefined : controller || undefined
+		provide: typeof prefix === "string" ? provide || void 0 : controller || void 0
 	}, true);
 }
 
 //#endregion
 //#region packages/moost/src/decorators/inherit.decorator.ts
-const Inherit = () => getMoostMate().decorate("inherit", true);
+/**
+* ## Inherit
+* ### @Decorator
+* Inherit metadata from super class
+* @returns
+*/ const Inherit = () => getMoostMate().decorate("inherit", true);
 
 //#endregion
 //#region packages/moost/src/decorators/intercept.decorator.ts
-var TInterceptorPriority = /*#__PURE__*/ function(TInterceptorPriority$1) {
+var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority$1) {
 	TInterceptorPriority$1[TInterceptorPriority$1["BEFORE_ALL"] = 0] = "BEFORE_ALL";
 	TInterceptorPriority$1[TInterceptorPriority$1["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
 	TInterceptorPriority$1[TInterceptorPriority$1["GUARD"] = 2] = "GUARD";
@@ -588,7 +676,14 @@ var TInterceptorPriority = /*#__PURE__*/ function(TInterceptorPriority$1) {
 	TInterceptorPriority$1[TInterceptorPriority$1["AFTER_ALL"] = 6] = "AFTER_ALL";
 	return TInterceptorPriority$1;
 }({});
-function Intercept(handler, priority, name) {
+/**
+* ## Intercept
+* ### @Decorator
+* Set interceptor
+* @param handler interceptor fn (use defineInterceptorFn)
+* @param priority interceptor priority
+* @returns
+*/ function Intercept(handler, priority, name) {
 	return getMoostMate().decorate("interceptors", {
 		handler,
 		priority: priority || handler.priority || 4,
@@ -598,9 +693,15 @@ function Intercept(handler, priority, name) {
 
 //#endregion
 //#region packages/moost/src/decorators/resolve.decorator.ts
-function Resolve(resolver, label) {
+/**
+* Hook to the Response Status
+* @decorator
+* @param resolver - resolver function
+* @param label - field label
+* @paramType unknown
+*/ function Resolve(resolver, label) {
 	return (target, key, index) => {
-		const i = typeof index === "number" ? index : undefined;
+		const i = typeof index === "number" ? index : void 0;
 		getMoostMate().decorate("resolver", (metas, level) => {
 			let newLabel = label;
 			if (!newLabel && level === "PROP" && typeof metas.key === "string") newLabel = metas.key;
@@ -609,16 +710,37 @@ function Resolve(resolver, label) {
 		})(target, key, i);
 	};
 }
-function Param(name) {
+/**
+* Get Param Value from url parh
+* @decorator
+* @param name - param name
+* @paramType string
+*/ function Param(name) {
 	return getMoostMate().apply(getMoostMate().decorate("paramSource", "ROUTE"), getMoostMate().decorate("paramName", name), Resolve(() => useRouteParams().get(name), name));
 }
-function Params() {
+/**
+* Get Parsed Params from url parh
+* @decorator
+* @paramType object
+*/ function Params() {
 	return Resolve(() => useRouteParams().params, "params");
 }
-function Const(value, label) {
+/**
+* Provide Const Value
+* @decorator
+* @param value - provided value
+* @param label - label of the field
+* @paramType unknown
+*/ function Const(value, label) {
 	return Resolve(() => value, label);
 }
-function ConstFactory(factory, label) {
+/**
+* Provide Const Value from Factory fn
+* @decorator
+* @param factory - value Factory fn
+* @param label - label of the field
+* @paramType unknown
+*/ function ConstFactory(factory, label) {
 	return Resolve(async () => factory(), label);
 }
 function fillLabel(target, key, index, name) {
@@ -632,10 +754,18 @@ function fillLabel(target, key, index, name) {
 
 //#endregion
 //#region packages/moost/src/decorators/logger.decorator.ts
-function InjectEventLogger(topic) {
-	return Resolve(() => useEventLogger(topic));
+/**
+* Resolves event logger from event context
+* @param topic
+* @returns Resolver to '@wooksjs/event-core' (EventLogger)
+*/ function InjectEventLogger(topic) {
+	return Resolve(() => useEventLogger$1(topic));
 }
-function InjectMoostLogger(topic) {
+/**
+* Resolves app-level logger
+* @param topic - logger topic (can be overrided by @LoggerTopic)
+* @returns
+*/ function InjectMoostLogger(topic) {
 	return Resolve(async (metas) => {
 		const { instantiate, getController } = useControllerContext();
 		const controller = getController();
@@ -644,13 +774,17 @@ function InjectMoostLogger(topic) {
 		return moostApp.getLogger(meta?.loggerTopic || topic || meta?.id);
 	});
 }
-function LoggerTopic(topic) {
+/**
+* Sets logger topic (used in @InjectMoostLogger)
+* @param topic - logger topic (banner)
+* @returns
+*/ function LoggerTopic(topic) {
 	return getMoostMate().decorate("loggerTopic", topic);
 }
 
 //#endregion
 //#region packages/moost/src/pipes/types.ts
-var TPipePriority = /*#__PURE__*/ function(TPipePriority$1) {
+var TPipePriority = /* @__PURE__ */ function(TPipePriority$1) {
 	TPipePriority$1[TPipePriority$1["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
 	TPipePriority$1[TPipePriority$1["RESOLVE"] = 1] = "RESOLVE";
 	TPipePriority$1[TPipePriority$1["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
@@ -665,7 +799,14 @@ var TPipePriority = /*#__PURE__*/ function(TPipePriority$1) {
 
 //#endregion
 //#region packages/moost/src/decorators/pipe.decorator.ts
-function Pipe(handler, priority) {
+/**
+* ## Pipe
+* ### @Decorator
+* Attach pipe
+* @param handler pipe handler
+* @param priority pipe priority
+* @returns
+*/ function Pipe(handler, priority) {
 	if (typeof priority !== "number") priority = typeof handler.priority === "number" ? handler.priority : TPipePriority.TRANSFORM;
 	return getMoostMate().decorate("pipes", {
 		handler,
@@ -675,40 +816,104 @@ function Pipe(handler, priority) {
 
 //#endregion
 //#region packages/moost/src/decorators/provide.decorator.ts
-function Provide(type, fn) {
+/**
+* ## Provide
+* ### @Decorator
+* Defines provide registry for class (and all the children)
+* @param type - string or class constructor
+* @param fn - factory function for provided value
+*/ function Provide(type, fn) {
 	return getMoostMate().decorate((meta) => {
 		meta.provide = meta.provide || {};
-		Object.assign(meta.provide, createProvideRegistry([type, fn]));
+		Object.assign(meta.provide, createProvideRegistry$1([type, fn]));
 		return meta;
 	});
 }
-function Replace(type, newType) {
+/**
+* ## Replace
+* ### @Decorator
+* Defines class to replace in DI
+* @param type - class to replace
+* @param newType - new class
+*/ function Replace(type, newType) {
 	return getMoostMate().decorate((meta) => {
 		meta.replace = meta.replace || {};
-		Object.assign(meta.replace, createReplaceRegistry([type, newType]));
+		Object.assign(meta.replace, createReplaceRegistry$1([type, newType]));
 		return meta;
 	});
 }
-function Inject(type) {
+/**
+* ## Inject
+* ### @Decorator
+* Defines a key from provide registry to inject value
+* (For optional values use with @Optional())
+* @param type - string or class constructor
+*/ function Inject(type) {
 	return getMoostMate().decorate("inject", type);
 }
-function InjectFromScope(name) {
+/**
+* Injects instance from scope
+*
+* (scope must be defined by `defineInfactScope` fn)
+* @param name scope name
+*/ function InjectFromScope(name) {
 	return getMoostMate().decorate("fromScope", name);
 }
-function InjectScopeVars(name) {
+/**
+* Inject vars from scope for instances
+* instantiated with `@InjectFromScope` decorator
+*/ function InjectScopeVars(name) {
 	return Resolve(({ scopeId }) => {
 		if (scopeId) return name ? getInfactScopeVars(scopeId)?.[name] : getInfactScopeVars(scopeId);
-		return undefined;
+		return void 0;
 	});
 }
 
 //#endregion
 //#region packages/moost/src/define.ts
-function defineInterceptorFn(fn, priority = TInterceptorPriority.INTERCEPTOR) {
+/**
+* ### Define Interceptor Function
+*
+* ```ts
+* defineInterceptorFn((before, after, onError) => {
+*         //init
+*         before(() => {
+*              // before handler
+*         })
+*         after((response, reply) => {
+*              // after handler
+*         })
+*         onError((error, reply) => {
+*              // when error occured
+*         })
+*     },
+*     TInterceptorPriority.INTERCEPTOR,
+* )
+* ```
+*
+* @param fn interceptor function
+* @param priority priority of the interceptor where BEFORE_ALL = 0, BEFORE_GUARD = 1, GUARD = 2, AFTER_GUARD = 3, INTERCEPTOR = 4, CATCH_ERROR = 5, AFTER_ALL = 6
+* @returns
+*/ function defineInterceptorFn(fn, priority = TInterceptorPriority.INTERCEPTOR) {
 	fn.priority = priority;
 	return fn;
 }
-function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
+/**
+* ### Define Pipe Function
+*
+* ```ts
+* // example of a transform pipe
+* const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
+*         return typeof value === 'string' ? value.toUpperCase() : value
+*     },
+*     TPipePriority.TRANSFORM,
+* )
+* ```
+*
+* @param fn interceptor function
+* @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
+* @returns
+*/ function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
 	fn.priority = priority;
 	return fn;
 }
@@ -718,7 +923,7 @@ function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
 const resolvePipe = definePipeFn((_value, metas, level) => {
 	const resolver = metas.targetMeta?.resolver;
 	if (resolver) return resolver(metas, level);
-	return undefined;
+	return void 0;
 }, TPipePriority.RESOLVE);
 
 //#endregion
@@ -740,7 +945,56 @@ function _define_property(obj, key, value) {
 	else obj[key] = value;
 	return obj;
 }
-var Moost = class Moost extends Hookable {
+/**
+* ## Moost
+* Main moostjs class that serves as a shell for Moost Adapters
+*
+* ### Usage with HTTP Adapter
+* ```ts
+* │  // HTTP server example
+* │  import { MoostHttp, Get } from '@moostjs/event-http'
+* │  import { Moost, Param } from 'moost'
+* │
+* │  class MyServer extends Moost {
+* │      @Get('test/:name')
+* │      test(@Param('name') name: string) {
+* │          return { message: `Hello ${name}!` }
+* │      }
+* │  }
+* │
+* │  const app = new MyServer()
+* │  const http = new MoostHttp()
+* │  app.adapter(http).listen(3000, () => {
+* │      app.getLogger('MyApp').log('Up on port 3000')
+* │  })
+* │  app.init()
+* ```
+* ### Usage with CLI Adapter
+* ```ts
+* │  // CLI example
+* │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
+* │  import { Moost, Param } from 'moost'
+* │
+* │  class MyApp extends Moost {
+* │      @Cli('command/:arg')
+* │      command(
+* │         @Param('arg')
+* │         arg: string,
+* │         @CliOption('test', 't')
+* │         test: boolean,
+* │      ) {
+* │          return `command run with flag arg=${ arg }, test=${ test }`
+* │      }
+* │  }
+* │
+* │  const app = new MyApp()
+* │  app.applyGlobalInterceptors(cliHelpInterceptor())
+* │
+* │  const cli = new MoostCli()
+* │  app.adapter(cli)
+* │  app.init()
+* ```
+*/ var Moost = class Moost extends Hookable {
 	_fireEventStart(source) {
 		this.callHook("event-start", source);
 	}
@@ -758,7 +1012,7 @@ var Moost = class Moost extends Hookable {
 	* @param topic
 	* @returns
 	*/ getLogger(topic) {
-		if (topic && this.logger instanceof ProstoLogger) return this.logger.createTopic(topic);
+		if (topic && this.logger instanceof ProstoLogger$1) return this.logger.createTopic(topic);
 		return this.logger;
 	}
 	adapter(a) {
@@ -772,10 +1026,10 @@ var Moost = class Moost extends Hookable {
 	* ### init
 	* Ititializes adapter. Must be called after adapters are attached.
 	*/ async init() {
-		this.setProvideRegistry(createProvideRegistry([Moost, () => this], [ProstoLogger, () => this.logger], ["MOOST_LOGGER", () => this.logger]));
+		this.setProvideRegistry(createProvideRegistry$1([Moost, () => this], [ProstoLogger$1, () => this.logger], ["MOOST_LOGGER", () => this.logger]));
 		for (const a of this.adapters) {
-			const constructor = getConstructor(a);
-			if (constructor) this.setProvideRegistry(createProvideRegistry([constructor, () => a]));
+			const constructor = getConstructor$1(a);
+			if (constructor) this.setProvideRegistry(createProvideRegistry$1([constructor, () => a]));
 			if (typeof a.getProvideRegistry === "function") this.setProvideRegistry(a.getProvideRegistry());
 		}
 		this.unregisteredControllers.unshift(this);
@@ -808,7 +1062,7 @@ var Moost = class Moost extends Hookable {
 		const mate$1 = getMoostMate();
 		const classMeta = mate$1.read(controller);
 		const infact$1 = getMoostInfact();
-		const isControllerConsructor = isConstructor(controller);
+		const isControllerConsructor = isConstructor$1(controller);
 		const pipes = [...this.pipes, ...classMeta?.pipes || []].sort((a, b) => a.priority - b.priority);
 		let instance;
 		const infactOpts = {
@@ -828,7 +1082,7 @@ var Moost = class Moost extends Hookable {
 			infact$1.setInstanceRegistries(instance, provide, replace, { pipes });
 		}
 		const getInstance = instance ? () => Promise.resolve(instance) : async () => await infact$1.get(controller, { ...infactOpts });
-		const classConstructor = isConstructor(controller) ? controller : getConstructor(controller);
+		const classConstructor = isConstructor$1(controller) ? controller : getConstructor$1(controller);
 		this.controllersOverview.push(await bindControllerMethods({
 			getInstance,
 			classConstructor,
@@ -853,19 +1107,12 @@ var Moost = class Moost extends Hookable {
 				...classMeta.replace
 			};
 			for (const ic of classMeta.importController) if (ic.typeResolver) {
-				const isConstr = isConstructor(ic.typeResolver);
+				const isConstr = isConstructor$1(ic.typeResolver);
 				const isFunc = typeof ic.typeResolver === "function";
-				await this.bindController(
-					// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-					isConstr ? ic.typeResolver : isFunc ? await ic.typeResolver() : ic.typeResolver,
-					ic.provide ? {
-						...mergedProvide,
-						...ic.provide
-					} : mergedProvide,
-					mergedReplace,
-					`${globalPrefix}/${prefix || ""}`,
-					ic.prefix
-);
+				await this.bindController(isConstr ? ic.typeResolver : isFunc ? await ic.typeResolver() : ic.typeResolver, ic.provide ? {
+					...mergedProvide,
+					...ic.provide
+				} : mergedProvide, mergedReplace, `${globalPrefix}/${prefix || ""}`, ic.prefix);
 			}
 		}
 	}
@@ -878,7 +1125,7 @@ var Moost = class Moost extends Hookable {
 			handler: item.handler,
 			priority: item.priority
 		});
-		this.globalInterceptorHandler = undefined;
+		this.globalInterceptorHandler = void 0;
 		return this;
 	}
 	/**
@@ -907,7 +1154,7 @@ var Moost = class Moost extends Hookable {
 			priority: item.priority,
 			name: item.name || item.handler._name || item.handler.name || "<anonymous>"
 		});
-		this.globalInterceptorHandler = undefined;
+		this.globalInterceptorHandler = void 0;
 		return this;
 	}
 	/**
@@ -943,11 +1190,11 @@ var Moost = class Moost extends Hookable {
 	logMappedHandler(eventName, classConstructor, method, stroke, prefix) {
 		const c = stroke ? "\x1B[9m" : "";
 		const coff = stroke ? "\x1B[29m" : "";
-		this.logger.info(`${prefix || ""}${c}${eventName} ${"\x1B[0m\x1B[2m\x1B[32m" + c}→ ${classConstructor.name}.${"\x1B[36m" + c}${method}${"\x1B[32m"}()${coff}`);
+		this.logger.info(`${prefix || ""}${c}${eventName} ${"\x1B[0m\x1B[2m\x1B[32m" + c}→ ${classConstructor.name}.${"\x1B[36m" + c}${method}()${coff}`);
 	}
 	constructor(options) {
-		super(), _define_property(this, "options", void 0), _define_property(this, "logger", void 0), _define_property(this, "pipes", void 0), _define_property(this, "interceptors", void 0), _define_property(this, "adapters", void 0), _define_property(this, "controllersOverview", void 0), _define_property(this, "provide", void 0), _define_property(this, "replace", void 0), _define_property(this, "unregisteredControllers", void 0), _define_property(this, "globalInterceptorHandler", void 0), this.options = options, this.pipes = Array.from(sharedPipes), this.interceptors = [], this.adapters = [], this.controllersOverview = [], this.provide = createProvideRegistry([Infact, getMoostInfact], [Mate, getMoostMate]), this.replace = {}, this.unregisteredControllers = [];
-		this.logger = options?.logger || getDefaultLogger(`${"\x1B[2m\x1B[35m"}moost`);
+		super(), _define_property(this, "options", void 0), _define_property(this, "logger", void 0), _define_property(this, "pipes", void 0), _define_property(this, "interceptors", void 0), _define_property(this, "adapters", void 0), _define_property(this, "controllersOverview", void 0), _define_property(this, "provide", void 0), _define_property(this, "replace", void 0), _define_property(this, "unregisteredControllers", void 0), _define_property(this, "globalInterceptorHandler", void 0), this.options = options, this.pipes = Array.from(sharedPipes), this.interceptors = [], this.adapters = [], this.controllersOverview = [], this.provide = createProvideRegistry$1([Infact, getMoostInfact], [Mate, getMoostMate]), this.replace = {}, this.unregisteredControllers = [];
+		this.logger = options?.logger || getDefaultLogger(`moost`);
 		setDefaultLogger(this.logger);
 		const mate$1 = getMoostMate();
 		Object.assign(mate$1, { logger: this.getLogger("mate") });
@@ -955,4 +1202,4 @@ var Moost = class Moost extends Hookable {
 };
 
 //#endregion
-export { Circular, Const, ConstFactory, ContextInjector, Controller, Description, EventLogger, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, InterceptorHandler, Label, LoggerTopic, Moost, Optional, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, clearGlobalWooks, createProvideRegistry, createReplaceRegistry, defineInfactScope, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getConstructor, getContextInjector, getGlobalWooks, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, isConstructor, registerEventScope, replaceContextInjector, resolvePipe, setControllerContext, setInfactLoggingOptions, useAsyncEventContext, useControllerContext, useEventLogger };
+export { ApplyDecorators, Circular, Const, ConstFactory, ContextInjector, Controller, Description, EventLogger, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, InterceptorHandler, Label, LoggerTopic, Moost, Optional, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, clearGlobalWooks, createLogger, createProvideRegistry, createReplaceRegistry, defineInfactScope, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getConstructor, getContextInjector, getGlobalWooks, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, isConstructor, loggerConsoleTransport, registerEventScope, replaceContextInjector, resolvePipe, setControllerContext, setInfactLoggingOptions, useAsyncEventContext, useControllerContext, useEventLogger };