moost 0.0.1-beta.1 → 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,21 +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;
@@ -329,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();
@@ -357,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');
 }
@@ -396,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);
 }
@@ -405,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 || '' }));
@@ -483,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) {
@@ -541,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);
@@ -602,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;
@@ -671,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);
@@ -725,10 +888,12 @@ exports.Circular = Circular;
 exports.Const = Const;
 exports.Controller = Controller;
 exports.Cookie = Cookie;
+exports.CookieHook = CookieHook;
 exports.Delete = Delete;
 exports.Dto = Dto;
 exports.Get = Get;
 exports.Header = Header;
+exports.HeaderHook = HeaderHook;
 exports.HttpMethod = HttpMethod;
 exports.ImportController = ImportController;
 exports.Inject = Inject;
@@ -758,6 +923,7 @@ exports.ReqId = ReqId;
 exports.Required = Required;
 exports.Res = Res;
 exports.Resolve = Resolve;
+exports.StatusHook = StatusHook;
 exports.Url = Url;
 exports.Validate = Validate;
 exports.genericTypesCastPipe = genericTypesCastPipe;