moost 0.3.11 → 0.3.12

package/dist/index.cjs

@@ -86,10 +86,9 @@ function getNewMoostInfact() {
 }
 
 function getInstanceOwnMethods(instance) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const proto = Object.getPrototypeOf(instance);
     return [
-        ...getParentProps(mate$1.getConstructor(instance)), // Inheritance support
+        ...getParentProps(mate$1.getConstructor(instance)),
         ...Object.getOwnPropertyNames(proto),
         ...Object.getOwnPropertyNames(instance),
     ].filter((m) => typeof instance[m] === 'function');
@@ -222,7 +221,6 @@ async function bindControllerMethods(options) {
     const { adapters } = opts;
     opts.globalPrefix = opts.globalPrefix || '';
     opts.provide = opts.provide || {};
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const fakeInstance = Object.create(classConstructor.prototype);
     const methods = getInstanceOwnMethods(fakeInstance);
     const mate = getMoostMate();
@@ -243,14 +241,12 @@ async function bindControllerMethods(options) {
         if (!methodMeta.handlers || !methodMeta.handlers.length)
             continue;
         const pipes = [...(opts.pipes || []), ...(methodMeta.pipes || [])].sort((a, b) => a.priority - b.priority);
-        // preparing interceptors
         const interceptors = [
             ...(opts.interceptors || []),
             ...(meta.interceptors || []),
             ...(methodMeta.interceptors || []),
         ].sort((a, b) => a.priority - b.priority);
         const getIterceptorHandler = getIterceptorHandlerFactory(interceptors, getInstance, pipes, options.logger);
-        // preparing pipes
         const argsPipes = [];
         for (const p of methodMeta.params || []) {
             argsPipes.push({
@@ -313,87 +309,34 @@ async function bindControllerMethods(options) {
     return controllerOverview;
 }
 
-/**
- * ## 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);
 }
-/**
- * ## 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);
 }
-/**
- * ## 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);
 }
-/**
- * ## 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);
 }
-/**
- * ## 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);
 }
-/**
- * ## Required
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Required metadata
- */
 function Required() {
     const mate = getMoostMate();
-    return mate.apply(mate.decorate('required', true), 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-    mate.decorateClass((meta, level, key, index) => {
+    return mate.apply(mate.decorate('required', true), mate.decorateClass((meta, level, key, index) => {
         if (typeof index !== 'number' &&
             meta &&
             ['string', 'symbol'].includes(typeof key)) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
             meta.requiredProps = meta.requiredProps || [];
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             meta.requiredProps.push(key);
         }
         return meta;
     }));
 }
 
-/**
- * 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;
@@ -407,48 +350,18 @@ function Resolve(resolver, label) {
         })(target, key, i);
     };
 }
-/**
- * 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(() => eventCore.useRouteParams().get(name), name));
 }
-/**
- * Get Parsed Params from url parh
- * @decorator
- * @paramType object
- */
 function Params() {
     return Resolve(() => eventCore.useRouteParams().params, 'params');
 }
-/**
- * Provide Const Value
- * @decorator
- * @param value - provided value
- * @param label - label of the field
- * @paramType unknown
- */
 function Const(value, label) {
     return Resolve(() => value, 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 () => await factory(), label);
 }
-/**
- * Resolves event logger from event context
- * @param topic
- * @returns Resolver to '@wooksjs/event-core' (EventLogger)
- */
 function InjectEventLogger(topic) {
     return Resolve(() => eventCore.useEventLogger(topic));
 }
@@ -470,15 +383,6 @@ function fillLabel(target, key, index, name) {
     }
 }
 
-/**
- * ## 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);
 }
@@ -488,12 +392,6 @@ const insureInjectable = getMoostMate().decorate((meta) => {
     return meta;
 });
 
-/**
- * ## Controller
- * ### @Decorator
- * Set Class as a Controller
- * @param prefix - define the prefix for all the paths of this controller
- */
 function Controller(prefix) {
     const mate = getMoostMate();
     return mate.apply(insureInjectable, mate.decorate('controller', { prefix: prefix || '' }));
@@ -524,14 +422,6 @@ exports.TInterceptorPriority = void 0;
     TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
     TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
 })(exports.TInterceptorPriority || (exports.TInterceptorPriority = {}));
-/**
- * ## Intercept
- * ### @Decorator
- * Set interceptor
- * @param handler interceptor fn (use defineInterceptorFn)
- * @param priority interceptor priority
- * @returns
- */
 function Intercept(handler, priority) {
     return getMoostMate().decorate('interceptors', {
         handler,
@@ -541,13 +431,6 @@ function Intercept(handler, priority) {
     }, true);
 }
 
-/**
- * ## 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 || {};
@@ -555,23 +438,10 @@ function Provide(type, fn) {
         return meta;
     });
 }
-/**
- * ## 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);
 }
 
-/**
- * ## Inherit
- * ### @Decorator
- * Inherit metadata from super class
- * @returns
- */
 const Inherit = () => getMoostMate().decorate('inherit', true);
 
 exports.TPipePriority = void 0;
@@ -587,14 +457,6 @@ exports.TPipePriority = void 0;
     TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
 })(exports.TPipePriority || (exports.TPipePriority = {}));
 
-/**
- * ## Pipe
- * ### @Decorator
- * Attach pipe
- * @param handler pipe handler
- * @param priority pipe priority
- * @returns
- */
 function Pipe(handler, priority) {
     if (typeof priority !== 'number') {
         priority =
@@ -605,50 +467,10 @@ function Pipe(handler, priority) {
     return getMoostMate().decorate('pipes', { handler, priority }, true);
 }
 
-/**
- * ### 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 = exports.TInterceptorPriority.INTERCEPTOR) {
     fn.priority = priority;
     return fn;
 }
-/**
- * ### 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 = exports.TPipePriority.TRANSFORM) {
     fn.priority = priority;
     return fn;
@@ -680,56 +502,6 @@ function getDefaultLogger(topic) {
     }, topic);
 }
 
-/**
- * ## 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()
- * ```
- */
 class Moost {
     constructor(options) {
         this.options = options;
@@ -744,17 +516,6 @@ class Moost {
         const mate = getMoostMate();
         Object.assign(mate, { logger: this.getLogger('mate') });
     }
-    /**
-     * ### getLogger
-     * Provides application logger
-     * ```js
-     * // get logger with topic = "App"
-     * const logger = app.getLogger('App')
-     * logger.log('...')
-     * ```
-     * @param topic
-     * @returns
-     */
     getLogger(topic) {
         if (this.logger instanceof logger.ProstoLogger) {
             return this.logger.createTopic(topic);
@@ -768,10 +529,6 @@ class Moost {
     getControllersOverview() {
         return this.controllersOverview;
     }
-    /**
-     * ### init
-     * Ititializes adapter. Must be called after adapters are attached.
-     */
     async init() {
         this.setProvideRegistry(infact$1.createProvideRegistry([Moost, () => this], [logger.ProstoLogger, () => this.logger], ['MOOST_LOGGER', () => this.logger]));
         for (const a of this.adapters) {
@@ -826,16 +583,13 @@ class Moost {
             instance = controller;
             infact.setProvideRegByInstance(instance, provide);
         }
-        // getInstance - instance factory for resolving SINGLETON and FOR_EVENT instance
         const getInstance = instance
             ? () => Promise.resolve(instance)
             : async () => {
-                // if (!instance) {
                 infact.silent(true);
                 const { restoreCtx } = eventCore.useEventContext();
                 const instance = (await infact.get(controller, { ...infactOpts, syncContextFn: restoreCtx }));
                 infact.silent(false);
-                // }
                 return instance;
             };
         const classConstructor = mate$1.isConstructor(controller)
@@ -861,9 +615,7 @@ class Moost {
                 if (ic.typeResolver) {
                     const isConstr = mate$1.isConstructor(ic.typeResolver);
                     const isFunc = typeof ic.typeResolver === 'function';
-                    await this.bindController(
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    isConstr
+                    await this.bindController(isConstr
                         ? ic.typeResolver
                         : isFunc
                             ? await ic.typeResolver()
@@ -894,12 +646,6 @@ class Moost {
         this.globalInterceptorHandler = undefined;
         return this;
     }
-    /**
-     * Provides InterceptorHandler with global interceptors and pipes.
-     * Used to process interceptors when event handler was not found.
-     *
-     * @returns IterceptorHandler
-     */
     getGlobalInterceptorHandler() {
         if (!this.globalInterceptorHandler) {
             const mate = getMoostMate();
@@ -932,20 +678,10 @@ class Moost {
         this.globalInterceptorHandler = undefined;
         return this;
     }
-    /**
-     * Register new entried to provide as dependency injections
-     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
-     * @returns
-     */
     setProvideRegistry(provide) {
         this.provide = { ...this.provide, ...provide };
         return this;
     }
-    /**
-     * Register controllers (similar to @ImportController decorator)
-     * @param controllers - list of target controllers (instances)
-     * @returns
-     */
     registerControllers(...controllers) {
         this.unregisteredControllers.push(...controllers);
         return this;
@@ -963,9 +699,7 @@ function useControllerContext() {
     const { get } = store('controller');
     const getController = () => get('instance');
     const getMethod = () => get('method');
-    // todo: add generic types to getControllerMeta
     const getControllerMeta = () => getMoostMate().read(getController());
-    // todo: add generic types to getMethodMeta
     const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
     function instantiate(c) {
         return getMoostInfact().getForInstance(getController(), c);
@@ -1029,12 +763,9 @@ function defineMoostEventHandler(options) {
         }
         let args = [];
         if (options.resolveArgs) {
-            // params
             restoreCtx();
             try {
-                // logger.trace(`resolving method args for "${ opts.method as string }"`)
                 args = await options.resolveArgs();
-                // logger.trace(`args for method "${ opts.method as string }" resolved (count ${String(args.length)})`)
             }
             catch (e) {
                 options.logErrors && logger.error(e);
@@ -1048,7 +779,6 @@ function defineMoostEventHandler(options) {
             if (typeof response !== 'undefined')
                 return endWithResponse();
         }
-        // fire request handler
         const callControllerMethod = () => {
             restoreCtx();
             if (options.callControllerMethod) {
@@ -1067,11 +797,9 @@ function defineMoostEventHandler(options) {
             return endWithResponse(true);
         }
         async function endWithResponse(raise = false) {
-            // fire after interceptors
             if (interceptorHandler) {
                 restoreCtx();
                 try {
-                    // logger.trace('firing after interceptors')
                     response = await interceptorHandler.fireAfter(response);
                 }
                 catch (e) {