moost 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/moost.cjs.prod.js

@@ -16,7 +16,7 @@ function getMoostMate() {
     return moostMate;
 }
 
-const prefix = '__moost_';
+const prefix = '__moost__';
 function useCacheObject(name, def) {
     const cc = wooks.useCurrentWooksContext().getCtx().customContext;
     const key = prefix + name;
@@ -37,9 +37,10 @@ function useControllerMeta() {
         getMethodMeta: () => getMoostMate().read(controller, method),
     };
 }
-function setComposableControllerContext(controller, method) {
-    setCacheObject('controller', controller);
-    setCacheObject('method', method);
+function setComposableControllerContext(data) {
+    setCacheObject('controller', data.controller);
+    setCacheObject('method', data.method);
+    setCacheObject('pathBuilder', data.pathBuilder);
 }
 
 async function runPipes(pipes, meta, restoreCtx) {
@@ -106,7 +107,7 @@ function getNewMoostInfact() {
 }
 
 function bindHandler(getInstance, method, wooksApp, options) {
-    wooksApp.on(options.httpMethod, options.path, async () => {
+    const pathBuilder = wooksApp.on(options.httpMethod, options.path, async () => {
         const { restoreCtx } = wooks.useCurrentWooksContext();
         const { reqId, rawRequest } = wooks.useRequest();
         const infact = getMoostInfact();
@@ -115,7 +116,11 @@ function bindHandler(getInstance, method, wooksApp, options) {
         rawRequest.on('end', () => infact.unregisterScope(scopeId));
         const instance = await getInstance();
         restoreCtx();
-        setComposableControllerContext(instance, method);
+        setComposableControllerContext({
+            controller: instance,
+            method: method,
+            pathBuilder: pathBuilder,
+        });
         let response;
         let responseOverwritten = false;
         const before = [];
@@ -125,10 +130,12 @@ function bindHandler(getInstance, method, wooksApp, options) {
             response = reply;
             responseOverwritten = true;
         }
+        // init interceptors
         for (const handler of options.interceptorHandlers) {
             restoreCtx();
             await handler((fn) => { before.push(fn); }, (fn) => { after.unshift(fn); }, (fn) => { onError.unshift(fn); });
         }
+        // params
         let args = [];
         try {
             restoreCtx();
@@ -138,12 +145,14 @@ function bindHandler(getInstance, method, wooksApp, options) {
             response = e;
         }
         if (!response) {
+            // fire before interceptors
             for (const handler of before) {
                 restoreCtx();
                 await handler(replyFn);
                 if (responseOverwritten)
                     break;
             }
+            // fire request handler
             if (!responseOverwritten) {
                 try {
                     restoreCtx();
@@ -154,6 +163,7 @@ function bindHandler(getInstance, method, wooksApp, options) {
                 }
             }
         }
+        // fire after interceptors
         if (response instanceof Error) {
             for (const handler of onError) {
                 restoreCtx();
@@ -180,6 +190,7 @@ async function applyPipesToArgs(argsPipes) {
 }
 
 function getInstanceOwnMethods(instance) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const proto = Object.getPrototypeOf(instance);
     return [
         ...Object.getOwnPropertyNames(proto),
@@ -187,8 +198,10 @@ function getInstanceOwnMethods(instance) {
     ].filter(m => typeof instance[m] === 'function');
 }
 
+/* istanbul ignore file */
 const banner = () => `[moost][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
 
+/* istanbul ignore file */
 function log(text) {
     console.log('' + '' + banner() + text + '');
 }
@@ -199,6 +212,7 @@ function logError(error) {
     console.error('' + '' + banner() + error + '');
 }
 
+/* istanbul ignore file */
 function panic(error) {
     logError(error);
     return new Error(error);
@@ -237,6 +251,7 @@ function bindControllerMethods(getInstance, classConstructor, wooksApp, options)
         const methodMeta = getMoostMate().read(fakeInstance, method) || {};
         if (!methodMeta.httpHandler || !methodMeta.httpHandler.length)
             continue;
+        // preparing interceptors
         const interceptors = [...(opts.interceptors || []), ...(meta.interceptors || []), ...(methodMeta.interceptors || [])].sort((a, b) => a.priority - b.priority);
         const interceptorHandlers = [];
         for (const { handler } of interceptors) {
@@ -253,6 +268,7 @@ function bindControllerMethods(getInstance, classConstructor, wooksApp, options)
                 interceptorHandlers.push(handler);
             }
         }
+        // preparing pipes
         const pipes = [...(opts.pipes || []), ...(meta.pipes || []), ...(methodMeta.pipes || [])];
         const argsPipes = [];
         for (const p of methodMeta.params || []) {
@@ -261,6 +277,7 @@ function bindControllerMethods(getInstance, classConstructor, wooksApp, options)
                 pipes: [...pipes, ...(p.pipes || [])].sort((a, b) => a.priority - b.priority),
             });
         }
+        // preparing provide
         const provide = { ...(opts.provide || {}), ...(meta.provide || {}) };
         for (const { method: httpMethod, path: httpPath } of methodMeta.httpHandler) {
             const path = typeof httpPath === 'string' ? httpPath : typeof method === 'string' ? method : '';
@@ -296,24 +313,58 @@ function Optional() {
 }
 function Required() {
     const mate = getMoostMate();
-    return mate.apply(mate.decorate('required', true), mate.decorateClass((meta, key, index) => {
+    return mate.apply(mate.decorate('required', true), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    mate.decorateClass((meta, 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) => {
         fillLabel(target, key, index, label);
         getMoostMate().decorate('resolver', resolver)(target, key, index);
     };
 }
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @paramType TStatusHook
+ */
 const StatusHook = Resolve(() => wooks.useStatus(), 'status');
+/**
+ * Hook to the Response Header
+ * @decorator
+ * @param name - header name
+ * @paramType THeaderHook
+ */
 const HeaderHook = (name) => Resolve(() => wooks.useRespHeader(name), name);
+/**
+ * Hook to the Response Cookie
+ * @decorator
+ * @param name - header name
+ * @paramType TCookieHook
+ */
 const CookieHook = (name) => Resolve(() => wooks.useRespCookie(name), name);
+/**
+ * Parse Authorisation Header
+ * @decorator
+ * @param name - define what to take from the Auth header
+ * @paramType string
+ */
 function Authorization(name) {
     return Resolve(() => {
         var _a, _b;
@@ -332,21 +383,50 @@ function Authorization(name) {
         }
     }, 'authorization');
 }
+/**
+ * Get Request Header Value
+ * @decorator
+ * @param name - header name
+ * @paramType string
+ */
 function Header(name) {
     return Resolve(() => {
         const headers = wooks.useHeaders();
         return headers[name];
     }, 'header: ' + name);
 }
+/**
+ * Get Request Cookie Value
+ * @decorator
+ * @param name - cookie name
+ * @paramType string
+ */
 function Cookie(name) {
     return Resolve(() => wooks.useCookies().getCookie(name), 'cookie: ' + name);
 }
+/**
+ * Get Param Value from url parh
+ * @decorator
+ * @param name - param name
+ * @paramType string
+ */
 function Param(name) {
     return Resolve(() => wooks.useRouteParams().getRouteParam(name), name);
 }
+/**
+ * Get Parsed Params from url parh
+ * @decorator
+ * @paramType object
+ */
 function Params() {
     return Resolve(() => wooks.useRouteParams().routeParams, 'params');
 }
+/**
+ * Get Query Item value or the whole parsed Query as an object
+ * @decorator
+ * @param name - query item name (optional)
+ * @paramType string | object
+ */
 function Query(name) {
     return Resolve(() => {
         const { jsonSearchParams, urlSearchParams } = wooks.useSearchParams();
@@ -360,33 +440,86 @@ function Query(name) {
         return Object.keys(json).length ? json : undefined;
     }, name || 'Query');
 }
+/**
+ * Get Requested URL
+ * @decorator
+ * @paramType string
+ */
 function Url() {
     return Resolve(() => wooks.useRequest().url, 'url');
 }
+/**
+ * Get Requested HTTP Method
+ * @decorator
+ * @paramType string
+ */
 function Method() {
     return Resolve(() => wooks.useRequest().method, 'http_method');
 }
+/**
+ * Get Raw Request Instance
+ * @decorator
+ * @paramType IncomingMessage
+ */
 function Req() {
     return Resolve(() => wooks.useRequest().rawRequest, 'request');
 }
+/**
+ * Get Request Unique Identificator (UUID)
+ * @decorator
+ * @paramType string
+ */
 function ReqId() {
     return Resolve(() => wooks.useRequest().reqId(), 'reqId');
 }
+/**
+ * Get Request IP Address
+ * @decorator
+ * @paramType string
+ */
 function Ip(opts) {
     return Resolve(() => wooks.useRequest().getIp(opts), 'ip');
 }
+/**
+ * Get Request IP Address list
+ * @decorator
+ * @paramType string[]
+ */
 function IpList() {
     return Resolve(() => wooks.useRequest().getIpList(), 'ipList');
 }
+/**
+ * Get Raw Response Object
+ * @decorator
+ * @param options - passthrough options
+ * @paramType string
+ */
 function Res(options) {
     return Resolve(() => wooks.useResponse().rawResponse(options), 'response');
 }
+/**
+ * Provide Const Value
+ * @decorator
+ * @param value - provided value
+ * @param label - label of the field
+ * @paramType unknown
+ */
 function Const(value, label) {
     return Resolve(() => value, label);
 }
+/**
+ * Get Parsed Request Body
+ * @decorator
+ * @paramType object | string | unknown
+ */
 function Body() {
     return Resolve(() => wooks.useBody().parseBody(), 'body');
 }
+/**
+ * Get Raw Request Body Buffer
+ * @decorator
+ * @paramType Promise<Buffer>
+ */
 function RawBody() {
     return Resolve(() => wooks.useBody().rawBody(), 'body');
 }
@@ -399,6 +532,14 @@ function fillLabel(target, key, index, name) {
     }
 }
 
+/**
+ * Mark the Class as Injectable to enable it to be used in dependency injection
+ * @decorator
+ * @param scope - Scope for injection ("FOR_REQUEST" | "SINGLETON" | true)
+ * FOR_REQUEST - 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);
 }
@@ -408,6 +549,11 @@ const insureInjectable = getMoostMate().decorate((meta) => {
     return meta;
 });
 
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @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 || '' }));
@@ -486,17 +632,36 @@ function IsBoolean(...args) {
     return Validate(valido$1.validoIsBoolean(...args));
 }
 
+const valido = new valido$1.Valido({
+    getDtoMeta(value, _type) {
+        let type = _type;
+        if (!type) {
+            type = mate.getConstructor(value);
+        }
+        const mate$1 = getMoostMate();
+        return mate$1.read(type);
+    },
+    getDtoParamMeta(value, type, key) {
+        const mate = getMoostMate();
+        return mate.read(type, key);
+    },
+});
+function getMoostValido() {
+    return valido;
+}
+
 class Moost {
     constructor(options) {
         this.options = options;
         this.pipes = [...sharedPipes];
         this.interceptors = [];
-        this.provide = {};
+        this.provide = infact.createProvideRegistry([infact.Infact, getMoostInfact], [mate.Mate, getMoostMate], [valido$1.Valido, getMoostValido]);
         this.unregisteredControllers = [];
     }
     async listen(port, hostname, cb) {
         var _a, _b, _c;
         this.wooksApp = new wooks.Wooks((_a = this.options) === null || _a === void 0 ? void 0 : _a.wooksOptions);
+        this.setProvideRegistry(infact.createProvideRegistry([wooks.Wooks, () => this.wooksApp], [Moost, () => this]));
         const _port = Number(((_b = this.options) === null || _b === void 0 ? void 0 : _b.port) || port);
         const _hostname = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.hostname) || hostname;
         if (!_port) {
@@ -544,10 +709,13 @@ class Moost {
                 instance = controller;
                 infact.setProvideRegByInstance(instance, provide);
             }
+            // getInstance - instance factory for resolving SINGLETON and FOR_REQUEST instance
             const getInstance = instance ? () => Promise.resolve(instance) : async () => {
+                // if (!instance) {
                 infact.silent();
                 const instance = await infact.get(controller, provide);
                 infact.silent(false);
+                // }
                 return instance;
             };
             const classConstructor = mate.isConstructor(controller) ? controller : mate.getConstructor(controller);
@@ -605,10 +773,20 @@ class Moost {
         }
         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;
@@ -674,24 +852,6 @@ function typeError(value, targetType, label) {
     throw new wooks.WooksError(400, `${prefix}${JSON.stringify(value)} is not a ${targetType} type`);
 }
 
-const valido = new valido$1.Valido({
-    getDtoMeta(value, _type) {
-        let type = _type;
-        if (!type) {
-            type = mate.getConstructor(value);
-        }
-        const mate$1 = getMoostMate();
-        return mate$1.read(type);
-    },
-    getDtoParamMeta(value, type, key) {
-        const mate = getMoostMate();
-        return mate.read(type, key);
-    },
-});
-function getMoostValido() {
-    return valido;
-}
-
 const DEFAULT_ERROR_LIMIT = 10;
 function firstString(errors) {
     const keys = Object.keys(errors);

package/dist/moost.d.ts

@@ -13,18 +13,53 @@ import { Wooks } from 'wooks';
 
 export declare const All: (path?: string) => MethodDecorator;
 
+/**
+ * Parse Authorisation Header
+ * @decorator
+ * @param name - define what to take from the Auth header
+ * @paramType string
+ */
 export declare function Authorization(name: 'username' | 'password' | 'bearer' | 'raw' | 'type'): ParameterDecorator;
 
+/**
+ * Get Parsed Request Body
+ * @decorator
+ * @paramType object | string | unknown
+ */
 export declare function Body(): ParameterDecorator;
 
 export declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;
 
+/**
+ * Provide Const Value
+ * @decorator
+ * @param value - provided value
+ * @param label - label of the field
+ * @paramType unknown
+ */
 export declare function Const(value: unknown, label?: string): ParameterDecorator;
 
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @param prefix - define the prefix for all the paths of this controller
+ */
 export declare function Controller(prefix?: string): ClassDecorator;
 
+/**
+ * Get Request Cookie Value
+ * @decorator
+ * @param name - cookie name
+ * @paramType string
+ */
 export declare function Cookie(name: string): ParameterDecorator;
 
+/**
+ * Hook to the Response Cookie
+ * @decorator
+ * @param name - header name
+ * @paramType TCookieHook
+ */
 export declare const CookieHook: (name: string) => ParameterDecorator;
 
 export declare const Delete: (path?: string) => MethodDecorator;
@@ -37,26 +72,69 @@ export declare const Get: (path?: string) => MethodDecorator;
 
 export declare function getMoostMate(): Mate<TMoostMetadata>;
 
+/**
+ * Get Request Header Value
+ * @decorator
+ * @param name - header name
+ * @paramType string
+ */
 export declare function Header(name: string): ParameterDecorator;
 
+/**
+ * Hook to the Response Header
+ * @decorator
+ * @param name - header name
+ * @paramType THeaderHook
+ */
 export declare const HeaderHook: (name: string) => ParameterDecorator;
 
 export declare function HttpMethod(method: '*' | 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS', path?: string): MethodDecorator;
 
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @param controller - target controller (instance) to import
+ * @param provide - provide registry for the target controller
+ */
 export declare function ImportController(controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
 
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @param prefix - redefine the prefix for all the paths of this controller
+ * @param controller - point to a controller (instance) to import
+ * @param provide - provide registry for the target controller
+ */
 export declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
 
 export declare function Inject(type: string | TClassConstructor): ParameterDecorator;
 
+/**
+ * Mark the Class as Injectable to enable it to be used in dependency injection
+ * @decorator
+ * @param scope - Scope for injection ("FOR_REQUEST" | "SINGLETON" | true)
+ * FOR_REQUEST - will create a new instance for each incoming request
+ * SINGLETON | true - will create a new instance only once
+ * @param label - field label
+ */
 export declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;
 
 export declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, priority?: TInterceptorPriority): ClassDecorator & MethodDecorator;
 
+/**
+ * Get Request IP Address
+ * @decorator
+ * @paramType string
+ */
 export declare function Ip(opts?: {
     trustProxy: boolean;
 }): ParameterDecorator;
 
+/**
+ * Get Request IP Address list
+ * @decorator
+ * @paramType string[]
+ */
 export declare function IpList(): ParameterDecorator;
 
 export declare function IsArray<T = unknown>(opts?: TValidateArrayOptions<T>): PropertyDecorator & ParameterDecorator;
@@ -71,6 +149,11 @@ export declare function IsTypeOf(type: 'string' | 'object' | 'number' | 'boolean
 
 export declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
 
+/**
+ * Get Requested HTTP Method
+ * @decorator
+ * @paramType string
+ */
 export declare function Method(): ParameterDecorator;
 
 export declare class Moost {
@@ -92,14 +175,35 @@ export declare class Moost {
     protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
     applyGlobalPipes(...items: (TPipeFn | TPipeData)[]): this;
     applyGlobalInterceptors(...items: (TInterceptorData['handler'] | TInterceptorData)[]): this;
+    /**
+     * Register new entried to provide as dependency injections
+     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
+     * @returns
+     */
     setProvideRegistry(provide: TProvideRegistry): this;
+    /**
+     * Register controllers (similar to @ImportController decorator)
+     * @param controllers - list of target controllers (instances)
+     * @returns
+     */
     registerControllers(...controllers: (TObject | TFunction)[]): this;
 }
 
 export declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
 
+/**
+ * Get Param Value from url parh
+ * @decorator
+ * @param name - param name
+ * @paramType string
+ */
 export declare function Param(name: string): ParameterDecorator;
 
+/**
+ * Get Parsed Params from url parh
+ * @decorator
+ * @paramType object
+ */
 export declare function Params(): ParameterDecorator;
 
 export declare const Patch: (path?: string) => MethodDecorator;
@@ -110,25 +214,64 @@ export declare function Provide(type: string | TClassConstructor, fn: TProvideFn
 
 export declare const Put: (path?: string) => MethodDecorator;
 
+/**
+ * Get Query Item value or the whole parsed Query as an object
+ * @decorator
+ * @param name - query item name (optional)
+ * @paramType string | object
+ */
 export declare function Query(name?: string): ParameterDecorator;
 
+/**
+ * Get Raw Request Body Buffer
+ * @decorator
+ * @paramType Promise<Buffer>
+ */
 export declare function RawBody(): ParameterDecorator;
 
+/**
+ * Get Raw Request Instance
+ * @decorator
+ * @paramType IncomingMessage
+ */
 export declare function Req(): ParameterDecorator;
 
+/**
+ * Get Request Unique Identificator (UUID)
+ * @decorator
+ * @paramType string
+ */
 export declare function ReqId(): ParameterDecorator;
 
 declare function Required_2(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
 export { Required_2 as Required }
 
+/**
+ * Get Raw Response Object
+ * @decorator
+ * @param options - passthrough options
+ * @paramType string
+ */
 export declare function Res(options?: {
     passthrough: boolean;
 }): ParameterDecorator;
 
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @param resolver - resolver function
+ * @param label - field label
+ * @paramType unknown
+ */
 export declare function Resolve(resolver: () => unknown, label?: string): ParameterDecorator;
 
 export declare const resolvePipe: TPipeFn;
 
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @paramType TStatusHook
+ */
 export declare const StatusHook: ParameterDecorator;
 
 declare type TAny = any;
@@ -268,6 +411,11 @@ declare interface TValidatePipeOptions {
     errorLimit?: number;
 }
 
+/**
+ * Get Requested URL
+ * @decorator
+ * @paramType string
+ */
 export declare function Url(): ParameterDecorator;
 
 export declare function useControllerMeta<T extends TMoostMetadata = TMoostMetadata>(): {