@moostjs/event-http 0.3.10 → 0.3.12

package/dist/index.cjs

@@ -7,714 +7,465 @@ var http = require('http');
 var https = require('https');
 var eventCore = require('@wooksjs/event-core');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-
-function __awaiter$1(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+const LOGGER_TITLE = 'moost-http';
+const CONTEXT_TYPE = 'HTTP';
+class MoostHttp {
+    constructor(httpApp) {
+        this.pathBuilders = {};
+        if (httpApp && httpApp instanceof eventHttp.WooksHttp) {
+            this.httpApp = httpApp;
+        }
+        else if (httpApp) {
+            this.httpApp = eventHttp.createHttpApp({
+                ...httpApp,
+                onNotFound: this.onNotFound.bind(this),
+            });
+        }
+        else {
+            this.httpApp = eventHttp.createHttpApp({
+                onNotFound: this.onNotFound.bind(this),
+            });
+        }
+    }
+    getHttpApp() {
+        return this.httpApp;
+    }
+    getServerCb() {
+        return this.httpApp.getServerCb();
+    }
+    listen(...args) {
+        return this.httpApp.listen(...args);
+    }
+    async onNotFound() {
+        const response = await moost.defineMoostEventHandler({
+            loggerTitle: LOGGER_TITLE,
+            getIterceptorHandler: () => this.moost?.getGlobalInterceptorHandler(),
+            getControllerInstance: () => this.moost,
+            callControllerMethod: () => undefined,
+        })();
+        if (!response) {
+            throw new eventHttp.HttpError(404, 'Resource Not Found');
+        }
+        return response;
+    }
+    onInit(moost) {
+        this.moost = moost;
+    }
+    getProvideRegistry() {
+        return infact.createProvideRegistry([eventHttp.WooksHttp, () => this.getHttpApp()], ['WooksHttp', () => this.getHttpApp()], [
+            http.Server,
+            () => this.getHttpApp().getServer(),
+        ], [
+            https.Server,
+            () => this.getHttpApp().getServer(),
+        ]);
+    }
+    getLogger() {
+        return this.getHttpApp().getLogger('moost-http');
+    }
+    bindHandler(opts) {
+        let fn;
+        for (const handler of opts.handlers) {
+            if (handler.type !== 'HTTP')
+                continue;
+            const httpPath = handler.path;
+            const path = typeof httpPath === 'string'
+                ? httpPath
+                : typeof opts.method === 'string'
+                    ? opts.method
+                    : '';
+            const targetPath = `${opts.prefix || ''}/${path}`.replace(/\/\/+/g, '/') + `${path.endsWith('//') ? '/' : ''}`;
+            if (!fn) {
+                fn = moost.defineMoostEventHandler({
+                    contextType: CONTEXT_TYPE,
+                    loggerTitle: LOGGER_TITLE,
+                    getIterceptorHandler: opts.getIterceptorHandler,
+                    getControllerInstance: opts.getInstance,
+                    controllerMethod: opts.method,
+                    resolveArgs: opts.resolveArgs,
+                    manualUnscope: true,
+                    hooks: {
+                        init: ({ unscope }) => {
+                            const { rawRequest } = eventHttp.useRequest();
+                            rawRequest.on('end', unscope);
+                        },
+                    },
+                });
+            }
+            const routerBinding = this.httpApp.on(handler.method, targetPath, fn);
+            const { getPath: pathBuilder } = routerBinding;
+            const methodMeta = moost.getMoostMate().read(opts.fakeInstance, opts.method) ||
+                {};
+            const id = (methodMeta.id || opts.method);
+            if (id) {
+                const methods = (this.pathBuilders[id] =
+                    this.pathBuilders[id] || {});
+                if (handler.method === '*') {
+                    methods.GET = pathBuilder;
+                    methods.PUT = pathBuilder;
+                    methods.PATCH = pathBuilder;
+                    methods.POST = pathBuilder;
+                    methods.DELETE = pathBuilder;
+                }
+                else {
+                    methods[handler.method] = pathBuilder;
+                }
+            }
+            opts.logHandler(`${''}(${handler.method})${''}${targetPath}`);
+            const args = routerBinding.getArgs();
+            const params = {};
+            args.forEach(a => params[a] = `{${a}}`);
+            opts.register(handler, routerBinding.getPath(params), args);
+        }
+    }
 }
 
-const LOGGER_TITLE = 'moost-http';
-const CONTEXT_TYPE = 'HTTP';
-/**
- * ## Moost HTTP Adapter
- *
- * Moost Adapter for HTTP events
- *
- * ```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()
- * ```
- */
-class MoostHttp {
-    constructor(httpApp) {
-        this.pathBuilders = {};
-        if (httpApp && httpApp instanceof eventHttp.WooksHttp) {
-            this.httpApp = httpApp;
-        }
-        else if (httpApp) {
-            this.httpApp = eventHttp.createHttpApp(Object.assign(Object.assign({}, httpApp), { onNotFound: this.onNotFound.bind(this) }));
-        }
-        else {
-            this.httpApp = eventHttp.createHttpApp({
-                onNotFound: this.onNotFound.bind(this),
-            });
-        }
-    }
-    getHttpApp() {
-        return this.httpApp;
-    }
-    getServerCb() {
-        return this.httpApp.getServerCb();
-    }
-    listen(...args) {
-        return this.httpApp.listen(...args);
-    }
-    onNotFound() {
-        return __awaiter$1(this, void 0, void 0, function* () {
-            const response = yield moost.defineMoostEventHandler({
-                loggerTitle: LOGGER_TITLE,
-                getIterceptorHandler: () => { var _a; return (_a = this.moost) === null || _a === void 0 ? void 0 : _a.getGlobalInterceptorHandler(); },
-                getControllerInstance: () => this.moost,
-                callControllerMethod: () => undefined,
-            })();
-            if (!response) {
-                throw new eventHttp.HttpError(404, 'Resource Not Found');
-            }
-            return response;
-        });
-    }
-    onInit(moost) {
-        this.moost = moost;
-    }
-    getProvideRegistry() {
-        return infact.createProvideRegistry([eventHttp.WooksHttp, () => this.getHttpApp()], ['WooksHttp', () => this.getHttpApp()], [
-            http.Server,
-            () => this.getHttpApp().getServer(),
-        ], [
-            https.Server,
-            () => this.getHttpApp().getServer(),
-        ]);
-    }
-    getLogger() {
-        return this.getHttpApp().getLogger('moost-http');
-    }
-    bindHandler(opts) {
-        let fn;
-        for (const handler of opts.handlers) {
-            if (handler.type !== 'HTTP')
-                continue;
-            const httpPath = handler.path;
-            const path = typeof httpPath === 'string'
-                ? httpPath
-                : typeof opts.method === 'string'
-                    ? opts.method
-                    : '';
-            const targetPath = `${opts.prefix || ''}/${path}`.replace(/\/\/+/g, '/') + `${path.endsWith('//') ? '/' : ''}`; // explicit double slash "//" -> force url to end with slash
-            if (!fn) {
-                fn = moost.defineMoostEventHandler({
-                    contextType: CONTEXT_TYPE,
-                    loggerTitle: LOGGER_TITLE,
-                    getIterceptorHandler: opts.getIterceptorHandler,
-                    getControllerInstance: opts.getInstance,
-                    controllerMethod: opts.method,
-                    resolveArgs: opts.resolveArgs,
-                    manualUnscope: true,
-                    hooks: {
-                        init: ({ unscope }) => {
-                            const { rawRequest } = eventHttp.useRequest();
-                            rawRequest.on('end', unscope); // will unscope on request end
-                        },
-                    },
-                });
-            }
-            const routerBinding = this.httpApp.on(handler.method, targetPath, fn);
-            const { getPath: pathBuilder } = routerBinding;
-            const methodMeta = moost.getMoostMate().read(opts.fakeInstance, opts.method) ||
-                {};
-            const id = (methodMeta.id || opts.method);
-            if (id) {
-                const methods = (this.pathBuilders[id] =
-                    this.pathBuilders[id] || {});
-                if (handler.method === '*') {
-                    methods.GET = pathBuilder;
-                    methods.PUT = pathBuilder;
-                    methods.PATCH = pathBuilder;
-                    methods.POST = pathBuilder;
-                    methods.DELETE = pathBuilder;
-                }
-                else {
-                    methods[handler.method] = pathBuilder;
-                }
-            }
-            opts.logHandler(`${''}(${handler.method})${''}${targetPath}`);
-            const args = routerBinding.getArgs();
-            const params = {};
-            args.forEach(a => params[a] = `{${a}}`);
-            opts.register(handler, routerBinding.getPath(params), args);
-        }
-    }
+function HttpMethod(method, path) {
+    return moost.getMoostMate().decorate('handlers', { method, path, type: 'HTTP' }, true);
 }
-
-function HttpMethod(method, path) {
-    return moost.getMoostMate().decorate('handlers', { method, path, type: 'HTTP' }, true);
-}
-const All = (path) => HttpMethod('*', path);
-const Get = (path) => HttpMethod('GET', path);
-const Post = (path) => HttpMethod('POST', path);
-const Put = (path) => HttpMethod('PUT', path);
-const Delete = (path) => HttpMethod('DELETE', path);
+const All = (path) => HttpMethod('*', path);
+const Get = (path) => HttpMethod('GET', path);
+const Post = (path) => HttpMethod('POST', path);
+const Put = (path) => HttpMethod('PUT', path);
+const Delete = (path) => HttpMethod('DELETE', path);
 const Patch = (path) => HttpMethod('PATCH', path);
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+const compressors = {
+    identity: {
+        compress: (v) => v,
+        uncompress: (v) => v,
+    },
+};
+async function uncompressBody(encodings, body) {
+    let newBody = body;
+    for (const e of encodings.reverse()) {
+        if (!compressors[e]) {
+            throw new Error(`Usupported compression type "${e}".`);
+        }
+        newBody = await compressors[e].uncompress(body);
+    }
+    return newBody;
 }
 
-const compressors = {
-    identity: {
-        compress: (v) => v,
-        uncompress: (v) => v,
-    },
-};
-function uncompressBody(encodings, body) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let newBody = body;
-        for (const e of encodings.reverse()) {
-            if (!compressors[e]) {
-                throw new Error(`Usupported compression type "${e}".`);
-            }
-            newBody = yield compressors[e].uncompress(body);
-        }
-        return newBody;
-    });
+function useBody() {
+    const { store } = eventHttp.useHttpContext();
+    const { init } = store('request');
+    const { rawBody } = eventHttp.useRequest();
+    const { 'content-type': contentType, 'content-encoding': contentEncoding } = eventHttp.useHeaders();
+    function contentIs(type) {
+        return (contentType || '').indexOf(type) >= 0;
+    }
+    const isJson = () => init('isJson', () => contentIs('application/json'));
+    const isHtml = () => init('isHtml', () => contentIs('text/html'));
+    const isXml = () => init('isXml', () => contentIs('text/xml'));
+    const isText = () => init('isText', () => contentIs('text/plain'));
+    const isBinary = () => init('isBinary', () => contentIs('application/octet-stream'));
+    const isFormData = () => init('isFormData', () => contentIs('multipart/form-data'));
+    const isUrlencoded = () => init('isUrlencoded', () => contentIs('application/x-www-form-urlencoded'));
+    const isCompressed = () => init('isCompressed', () => {
+        const parts = contentEncodings();
+        for (const p of parts) {
+            if (['deflate', 'gzip', 'br'].includes(p))
+                return true;
+        }
+        return false;
+    });
+    const contentEncodings = () => init('contentEncodings', () => (contentEncoding || '')
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => !!p));
+    const parseBody = () => init('parsed', async () => {
+        const body = await uncompressBody(contentEncodings(), (await rawBody()).toString());
+        if (isJson())
+            return jsonParser(body);
+        else if (isFormData())
+            return formDataParser(body);
+        else if (isUrlencoded())
+            return urlEncodedParser(body);
+        else if (isBinary())
+            return textParser(body);
+        else
+            return textParser(body);
+    });
+    function jsonParser(v) {
+        try {
+            return JSON.parse(v);
+        }
+        catch (e) {
+            throw new eventHttp.HttpError(400, e.message);
+        }
+    }
+    function textParser(v) {
+        return v;
+    }
+    function formDataParser(v) {
+        const boundary = '--' +
+            (/boundary=([^;]+)(?:;|$)/.exec(contentType || '') || [, ''])[1];
+        if (!boundary)
+            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'form-data boundary not recognized');
+        const parts = v.trim().split(boundary);
+        const result = {};
+        let key = '';
+        let partContentType = 'text/plain';
+        for (const part of parts) {
+            parsePart();
+            key = '';
+            partContentType = 'text/plain';
+            let valueMode = false;
+            const lines = part
+                .trim()
+                .split(/\n/g)
+                .map((s) => s.trim());
+            for (const line of lines) {
+                if (valueMode) {
+                    if (!result[key]) {
+                        result[key] = line;
+                    }
+                    else {
+                        result[key] += '\n' + line;
+                    }
+                }
+                else {
+                    if (!line || line === '--') {
+                        valueMode = !!key;
+                        if (valueMode) {
+                            key = key.replace(/^["']/, '').replace(/["']$/, '');
+                        }
+                        continue;
+                    }
+                    if (line
+                        .toLowerCase()
+                        .startsWith('content-disposition: form-data;')) {
+                        key = (/name=([^;]+)/.exec(line) || [])[1];
+                        if (!key)
+                            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'Could not read multipart name: ' + line);
+                        continue;
+                    }
+                    if (line.toLowerCase().startsWith('content-type:')) {
+                        partContentType = (/content-type:\s?([^;]+)/i.exec(line) || [])[1];
+                        if (!partContentType)
+                            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'Could not read content-type: ' + line);
+                        continue;
+                    }
+                }
+            }
+        }
+        parsePart();
+        function parsePart() {
+            if (key) {
+                if (partContentType.indexOf('application/json') >= 0) {
+                    result[key] = JSON.parse(result[key]);
+                }
+            }
+        }
+        return result;
+    }
+    function urlEncodedParser(v) {
+        return new eventHttp.WooksURLSearchParams(v.trim()).toJson();
+    }
+    return {
+        isJson,
+        isHtml,
+        isXml,
+        isText,
+        isBinary,
+        isFormData,
+        isUrlencoded,
+        isCompressed,
+        contentEncodings,
+        parseBody,
+        rawBody,
+    };
 }
 
-function useBody() {
-    const { store } = eventHttp.useHttpContext();
-    const { init } = store('request');
-    const { rawBody } = eventHttp.useRequest();
-    const { 'content-type': contentType, 'content-encoding': contentEncoding } = eventHttp.useHeaders();
-    function contentIs(type) {
-        return (contentType || '').indexOf(type) >= 0;
-    }
-    const isJson = () => init('isJson', () => contentIs('application/json'));
-    const isHtml = () => init('isHtml', () => contentIs('text/html'));
-    const isXml = () => init('isXml', () => contentIs('text/xml'));
-    const isText = () => init('isText', () => contentIs('text/plain'));
-    const isBinary = () => init('isBinary', () => contentIs('application/octet-stream'));
-    const isFormData = () => init('isFormData', () => contentIs('multipart/form-data'));
-    const isUrlencoded = () => init('isUrlencoded', () => contentIs('application/x-www-form-urlencoded'));
-    const isCompressed = () => init('isCompressed', () => {
-        const parts = contentEncodings();
-        for (const p of parts) {
-            if (['deflate', 'gzip', 'br'].includes(p))
-                return true;
-        }
-        return false;
-    });
-    const contentEncodings = () => init('contentEncodings', () => (contentEncoding || '')
-        .split(',')
-        .map((p) => p.trim())
-        .filter((p) => !!p));
-    const parseBody = () => init('parsed', () => __awaiter(this, void 0, void 0, function* () {
-        const body = yield uncompressBody(contentEncodings(), (yield rawBody()).toString());
-        if (isJson())
-            return jsonParser(body);
-        else if (isFormData())
-            return formDataParser(body);
-        else if (isUrlencoded())
-            return urlEncodedParser(body);
-        else if (isBinary())
-            return textParser(body);
-        else
-            return textParser(body);
-    }));
-    function jsonParser(v) {
-        try {
-            return JSON.parse(v);
-        }
-        catch (e) {
-            throw new eventHttp.HttpError(400, e.message);
-        }
-    }
-    function textParser(v) {
-        return v;
-    }
-    function formDataParser(v) {
-        const boundary = '--' +
-            (/boundary=([^;]+)(?:;|$)/.exec(contentType || '') || [, ''])[1];
-        if (!boundary)
-            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'form-data boundary not recognized');
-        const parts = v.trim().split(boundary);
-        const result = {};
-        let key = '';
-        let partContentType = 'text/plain';
-        for (const part of parts) {
-            parsePart();
-            key = '';
-            partContentType = 'text/plain';
-            let valueMode = false;
-            const lines = part
-                .trim()
-                .split(/\n/g)
-                .map((s) => s.trim());
-            for (const line of lines) {
-                if (valueMode) {
-                    if (!result[key]) {
-                        result[key] = line;
-                    }
-                    else {
-                        result[key] += '\n' + line;
-                    }
-                }
-                else {
-                    if (!line || line === '--') {
-                        valueMode = !!key;
-                        if (valueMode) {
-                            key = key.replace(/^["']/, '').replace(/["']$/, '');
-                        }
-                        continue;
-                    }
-                    if (line
-                        .toLowerCase()
-                        .startsWith('content-disposition: form-data;')) {
-                        key = (/name=([^;]+)/.exec(line) || [])[1];
-                        if (!key)
-                            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'Could not read multipart name: ' + line);
-                        continue;
-                    }
-                    if (line.toLowerCase().startsWith('content-type:')) {
-                        partContentType = (/content-type:\s?([^;]+)/i.exec(line) || [])[1];
-                        if (!partContentType)
-                            throw new eventHttp.HttpError(eventHttp.EHttpStatusCode.BadRequest, 'Could not read content-type: ' + line);
-                        continue;
-                    }
-                }
-            }
-        }
-        parsePart();
-        function parsePart() {
-            if (key) {
-                if (partContentType.indexOf('application/json') >= 0) {
-                    result[key] = JSON.parse(result[key]);
-                }
-            }
-        }
-        return result;
-    }
-    function urlEncodedParser(v) {
-        return new eventHttp.WooksURLSearchParams(v.trim()).toJson();
-    }
-    return {
-        isJson,
-        isHtml,
-        isXml,
-        isText,
-        isBinary,
-        isFormData,
-        isUrlencoded,
-        isCompressed,
-        contentEncodings,
-        parseBody,
-        rawBody,
-    };
+const StatusHook = () => moost.Resolve((metas, level) => {
+    const hook = eventHttp.useStatus();
+    if (level === 'PARAM') {
+        return hook;
+    }
+    if (level === 'PROP' && metas.instance && metas.key) {
+        const initialValue = metas.instance[metas.key];
+        eventCore.attachHook(metas.instance, {
+            get: () => hook.value,
+            set: (v) => (hook.value = v),
+        }, metas.key);
+        return typeof initialValue === 'number' ? initialValue : 200;
+    }
+}, 'statusCode');
+const HeaderHook = (name) => moost.Resolve((metas, level) => {
+    const hook = eventHttp.useSetHeader(name);
+    if (level === 'PARAM') {
+        return hook;
+    }
+    if (level === 'PROP' && metas.instance && metas.key) {
+        const initialValue = metas.instance[metas.key];
+        eventCore.attachHook(metas.instance, {
+            get: () => hook.value,
+            set: (v) => (hook.value = v),
+        }, metas.key);
+        return typeof initialValue === 'string' ? initialValue : '';
+    }
+}, name);
+const CookieHook = (name) => moost.Resolve((metas, level) => {
+    const hook = eventHttp.useSetCookie(name);
+    if (level === 'PARAM') {
+        return hook;
+    }
+    if (level === 'PROP' && metas.instance && metas.key) {
+        const initialValue = metas.instance[metas.key];
+        eventCore.attachHook(metas.instance, {
+            get: () => hook.value,
+            set: (v) => (hook.value = v),
+        }, metas.key);
+        return typeof initialValue === 'string' ? initialValue : '';
+    }
+}, name);
+const CookieAttrsHook = (name) => moost.Resolve((metas, level) => {
+    const hook = eventHttp.useSetCookie(name);
+    if (level === 'PARAM') {
+        return eventCore.attachHook({}, {
+            get: () => hook.attrs,
+            set: (v) => (hook.attrs = v),
+        });
+    }
+    if (level === 'PROP' && metas.instance && metas.key) {
+        const initialValue = metas.instance[metas.key];
+        eventCore.attachHook(metas.instance, {
+            get: () => hook.attrs,
+            set: (v) => (hook.attrs = v),
+        }, metas.key);
+        return typeof initialValue === 'object' ? initialValue : {};
+    }
+}, name);
+function Authorization(name) {
+    return moost.Resolve(() => {
+        const auth = eventHttp.useAuthorization();
+        switch (name) {
+            case 'username':
+                return auth.isBasic()
+                    ? auth.basicCredentials()?.username
+                    : undefined;
+            case 'password':
+                return auth.isBasic()
+                    ? auth.basicCredentials()?.password
+                    : undefined;
+            case 'bearer':
+                return auth.isBearer() ? auth.authorization : undefined;
+            case 'raw':
+                return auth.authRawCredentials();
+            case 'type':
+                return auth.authType();
+        }
+    }, 'authorization');
 }
-
-/**
- * Hook to the Response Status
- * @decorator
- * @paramType TStatusHook
- */
-const StatusHook = () => moost.Resolve((metas, level) => {
-    const hook = eventHttp.useStatus();
-    if (level === 'PARAM') {
-        return hook;
-    }
-    if (level === 'PROP' && metas.instance && metas.key) {
-        const initialValue = metas.instance[metas.key];
-        eventCore.attachHook(metas.instance, {
-            get: () => hook.value,
-            set: (v) => (hook.value = v),
-        }, metas.key);
-        return typeof initialValue === 'number' ? initialValue : 200;
-    }
-}, 'statusCode');
-/**
- * Hook to the Response Header
- * @decorator
- * @param name - header name
- * @paramType THeaderHook
- */
-const HeaderHook = (name) => moost.Resolve((metas, level) => {
-    const hook = eventHttp.useSetHeader(name);
-    if (level === 'PARAM') {
-        return hook;
-    }
-    if (level === 'PROP' && metas.instance && metas.key) {
-        const initialValue = metas.instance[metas.key];
-        eventCore.attachHook(metas.instance, {
-            get: () => hook.value,
-            set: (v) => (hook.value = v),
-        }, metas.key);
-        return typeof initialValue === 'string' ? initialValue : '';
-    }
-}, name);
-/**
- * Hook to the Response Cookie
- * @decorator
- * @param name - cookie name
- * @paramType TCookieHook
- */
-const CookieHook = (name) => moost.Resolve((metas, level) => {
-    const hook = eventHttp.useSetCookie(name);
-    if (level === 'PARAM') {
-        return hook;
-    }
-    if (level === 'PROP' && metas.instance && metas.key) {
-        const initialValue = metas.instance[metas.key];
-        eventCore.attachHook(metas.instance, {
-            get: () => hook.value,
-            set: (v) => (hook.value = v),
-        }, metas.key);
-        return typeof initialValue === 'string' ? initialValue : '';
-    }
-}, name);
-/**
- * Hook to the Response Cookie Attributes
- * @decorator
- * @param name - cookie name
- * @paramType TCookieAttributes
- */
-const CookieAttrsHook = (name) => moost.Resolve((metas, level) => {
-    const hook = eventHttp.useSetCookie(name);
-    if (level === 'PARAM') {
-        return eventCore.attachHook({}, {
-            get: () => hook.attrs,
-            set: (v) => (hook.attrs = v),
-        });
-    }
-    if (level === 'PROP' && metas.instance && metas.key) {
-        const initialValue = metas.instance[metas.key];
-        eventCore.attachHook(metas.instance, {
-            get: () => hook.attrs,
-            set: (v) => (hook.attrs = v),
-        }, metas.key);
-        return typeof initialValue === 'object' ? initialValue : {};
-    }
-}, name);
-/**
- * Parse Authorisation Header
- * @decorator
- * @param name - define what to take from the Auth header
- * @paramType string
- */
-function Authorization(name) {
-    return moost.Resolve(() => {
-        var _a, _b;
-        const auth = eventHttp.useAuthorization();
-        switch (name) {
-            case 'username':
-                return auth.isBasic()
-                    ? (_a = auth.basicCredentials()) === null || _a === void 0 ? void 0 : _a.username
-                    : undefined;
-            case 'password':
-                return auth.isBasic()
-                    ? (_b = auth.basicCredentials()) === null || _b === void 0 ? void 0 : _b.password
-                    : undefined;
-            case 'bearer':
-                return auth.isBearer() ? auth.authorization : undefined;
-            case 'raw':
-                return auth.authRawCredentials();
-            case 'type':
-                return auth.authType();
-        }
-    }, 'authorization');
-}
-/**
- * Get Request Header Value
- * @decorator
- * @param name - header name
- * @paramType string
- */
-function Header(name) {
-    return moost.Resolve(() => {
-        const headers = eventHttp.useHeaders();
-        return headers[name];
-    }, 'header: ' + name);
-}
-/**
- * Get Request Cookie Value
- * @decorator
- * @param name - cookie name
- * @paramType string
- */
-function Cookie(name) {
-    return moost.Resolve(() => eventHttp.useCookies().getCookie(name), 'cookie: ' + name);
-}
-/**
- * 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) {
-    const isItem = !!name;
-    const _name = isItem ? name : 'Query';
-    return moost.getMoostMate().apply(moost.getMoostMate().decorate('paramSource', isItem ? 'QUERY_ITEM' : 'QUERY'), moost.getMoostMate().decorate('paramName', _name), moost.Resolve(() => {
-        const { jsonSearchParams, urlSearchParams } = eventHttp.useSearchParams();
-        if (isItem) {
-            const p = urlSearchParams();
-            const value = p.get(name);
-            return value === null ? undefined : value;
-        }
-        const json = jsonSearchParams();
-        return Object.keys(json).length ? json : undefined;
-    }, _name));
-}
-/**
- * Get Requested URL
- * @decorator
- * @paramType string
- */
-function Url() {
-    return moost.Resolve(() => eventHttp.useRequest().url || '', 'url');
-}
-/**
- * Get Requested HTTP Method
- * @decorator
- * @paramType string
- */
-function Method() {
-    return moost.Resolve(() => eventHttp.useRequest().method, 'http_method');
-}
-/**
- * Get Raw Request Instance
- * @decorator
- * @paramType IncomingMessage
- */
-function Req() {
-    return moost.Resolve(() => eventHttp.useRequest().rawRequest, 'request');
-}
-/**
- * Get Raw Response Instance
- * @decorator
- * @param opts (optional) { passthrough: boolean }
- * @paramType ServerResponse
- */
-function Res(opts) {
-    return moost.Resolve(() => eventHttp.useResponse().rawResponse(opts), 'response');
-}
-/**
- * Get Request Unique Identificator (UUID)
- * @decorator
- * @paramType string
- */
-function ReqId() {
-    return moost.Resolve(() => eventHttp.useRequest().reqId(), 'reqId');
-}
-/**
- * Get Request IP Address
- * @decorator
- * @paramType string
- */
-function Ip(opts) {
-    return moost.Resolve(() => eventHttp.useRequest().getIp(opts), 'ip');
-}
-/**
- * Get Request IP Address list
- * @decorator
- * @paramType string[]
- */
-function IpList() {
-    return moost.Resolve(() => eventHttp.useRequest().getIpList(), 'ipList');
-}
-/**
- * Get Parsed Request Body
- * @decorator
- * @paramType object | string | unknown
- */
-function Body() {
-    return moost.getMoostMate().apply(moost.getMoostMate().decorate('paramSource', 'BODY'), moost.Resolve(() => useBody().parseBody(), 'body'));
-}
-/**
- * Get Raw Request Body Buffer
- * @decorator
- * @paramType Promise<Buffer>
- */
-function RawBody() {
-    return moost.Resolve(() => useBody().rawBody(), 'body');
+function Header(name) {
+    return moost.Resolve(() => {
+        const headers = eventHttp.useHeaders();
+        return headers[name];
+    }, 'header: ' + name);
+}
+function Cookie(name) {
+    return moost.Resolve(() => eventHttp.useCookies().getCookie(name), 'cookie: ' + name);
+}
+function Query(name) {
+    const isItem = !!name;
+    const _name = isItem ? name : 'Query';
+    return moost.getMoostMate().apply(moost.getMoostMate().decorate('paramSource', isItem ? 'QUERY_ITEM' : 'QUERY'), moost.getMoostMate().decorate('paramName', _name), moost.Resolve(() => {
+        const { jsonSearchParams, urlSearchParams } = eventHttp.useSearchParams();
+        if (isItem) {
+            const p = urlSearchParams();
+            const value = p.get(name);
+            return value === null ? undefined : value;
+        }
+        const json = jsonSearchParams();
+        return Object.keys(json).length ? json : undefined;
+    }, _name));
+}
+function Url() {
+    return moost.Resolve(() => eventHttp.useRequest().url || '', 'url');
+}
+function Method() {
+    return moost.Resolve(() => eventHttp.useRequest().method, 'http_method');
+}
+function Req() {
+    return moost.Resolve(() => eventHttp.useRequest().rawRequest, 'request');
+}
+function Res(opts) {
+    return moost.Resolve(() => eventHttp.useResponse().rawResponse(opts), 'response');
+}
+function ReqId() {
+    return moost.Resolve(() => eventHttp.useRequest().reqId(), 'reqId');
+}
+function Ip(opts) {
+    return moost.Resolve(() => eventHttp.useRequest().getIp(opts), 'ip');
+}
+function IpList() {
+    return moost.Resolve(() => eventHttp.useRequest().getIpList(), 'ipList');
+}
+function Body() {
+    return moost.getMoostMate().apply(moost.getMoostMate().decorate('paramSource', 'BODY'), moost.Resolve(() => useBody().parseBody(), 'body'));
+}
+function RawBody() {
+    return moost.Resolve(() => useBody().rawBody(), 'body');
 }
 
-const setHeaderInterceptor = (name, value, opts) => {
-    const fn = (_before, after, onError) => {
-        const h = eventHttp.useSetHeader(name);
-        const status = eventHttp.useStatus();
-        const cb = () => {
-            if ((!h.value || (opts === null || opts === void 0 ? void 0 : opts.force)) &&
-                (!(opts === null || opts === void 0 ? void 0 : opts.status) || opts.status === status.value)) {
-                h.value = value;
-            }
-        };
-        if ((opts === null || opts === void 0 ? void 0 : opts.when) !== 'error') {
-            after(cb);
-        }
-        if ((opts === null || opts === void 0 ? void 0 : opts.when) === 'always' || (opts === null || opts === void 0 ? void 0 : opts.when) === 'error') {
-            onError(cb);
-        }
-    };
-    fn.priority = moost.TInterceptorPriority.AFTER_ALL;
-    return fn;
-};
-/**
- * Set Header for Request Handler
- *
- * ```ts
- * import { Get, SetHeader } from '@moostjs/event-http';
- * import { Controller } from 'moost';
- *
- * @Controller()
- * export class ExampleController {
- *   @Get('test')
- *   // setting header for request handler
- *   @SetHeader('x-server', 'my-server')
- *   testHandler() {
- *     return '...'
- *   }
- * }
- * ```
- *
- * ```ts
- * import { Get, SetHeader } from '@moostjs/event-http';
- * import { Controller } from 'moost';
- *
- * @Controller()
- * export class ExampleController {
- *   @Get('test')
- *   // setting header only if status = 400
- *   @SetHeader('content-type', 'text/plain', { status: 400 })
- *   testHandler() {
- *     return '...'
- *   }
- * }
- * ```
- *
- * @param name  name of header
- * @param value value for header
- * @param options options { status?: number, force?: boolean }
- */
-function SetHeader(...args) {
-    return moost.Intercept(setHeaderInterceptor(...args));
-}
-const setCookieInterceptor = (name, value, attrs) => {
-    const fn = (before, after) => {
-        const { setCookie, getCookie } = eventHttp.useSetCookies();
-        after(() => {
-            if (!getCookie(name)) {
-                setCookie(name, value, attrs);
-            }
-        });
-    };
-    fn.priority = moost.TInterceptorPriority.AFTER_ALL;
-    return fn;
-};
-/**
- * Set Cookie for Request Handler
- * ```ts
- * import { Get, SetCookie } from '@moostjs/event-http';
- * import { Controller } from 'moost';
- *
- * @Controller()
- * export class ExampleController {
- *   @Get('test')
- *   // setting 'my-cookie' = 'value' with maxAge of 10 minutes
- *   @SetCookie('my-cookie', 'value', { maxAge: '10m' })
- *   testHandler() {
- *     return '...'
- *   }
- * }
- * ```
- *
- * @param name  name of cookie
- * @param value value for cookie
- * @param attrs cookie attributes
- */
-function SetCookie(...args) {
-    return moost.Intercept(setCookieInterceptor(...args));
-}
-const setStatusInterceptor = (code, opts) => {
-    return moost.defineInterceptorFn((before, after) => {
-        const status = eventHttp.useStatus();
-        after(() => {
-            if (!status.isDefined || (opts === null || opts === void 0 ? void 0 : opts.force)) {
-                status.value = code;
-            }
-        });
-    });
-};
-/**
- * Set Response Status for Request Handler
- *
- * ```ts
- * import { Get, SetStatus } from '@moostjs/event-http';
- * import { Controller } from 'moost';
- *
- * @Controller()
- * export class ExampleController {
- *   @Get('test')
- *   @SetStatus(201)
- *   testHandler() {
- *     return '...'
- *   }
- * }
- * ```
- * @param code number
- * @param opts optional { force?: boolean }
- */
-function SetStatus(...args) {
-    return moost.Intercept(setStatusInterceptor(...args));
+const setHeaderInterceptor = (name, value, opts) => {
+    const fn = (_before, after, onError) => {
+        const h = eventHttp.useSetHeader(name);
+        const status = eventHttp.useStatus();
+        const cb = () => {
+            if ((!h.value || opts?.force) &&
+                (!opts?.status || opts.status === status.value)) {
+                h.value = value;
+            }
+        };
+        if (opts?.when !== 'error') {
+            after(cb);
+        }
+        if (opts?.when === 'always' || opts?.when === 'error') {
+            onError(cb);
+        }
+    };
+    fn.priority = moost.TInterceptorPriority.AFTER_ALL;
+    return fn;
+};
+function SetHeader(...args) {
+    return moost.Intercept(setHeaderInterceptor(...args));
+}
+const setCookieInterceptor = (name, value, attrs) => {
+    const fn = (before, after) => {
+        const { setCookie, getCookie } = eventHttp.useSetCookies();
+        after(() => {
+            if (!getCookie(name)) {
+                setCookie(name, value, attrs);
+            }
+        });
+    };
+    fn.priority = moost.TInterceptorPriority.AFTER_ALL;
+    return fn;
+};
+function SetCookie(...args) {
+    return moost.Intercept(setCookieInterceptor(...args));
+}
+const setStatusInterceptor = (code, opts) => {
+    return moost.defineInterceptorFn((before, after) => {
+        const status = eventHttp.useStatus();
+        after(() => {
+            if (!status.isDefined || opts?.force) {
+                status.value = code;
+            }
+        });
+    });
+};
+function SetStatus(...args) {
+    return moost.Intercept(setStatusInterceptor(...args));
 }
 
-Object.defineProperty(exports, 'HttpError', {
+Object.defineProperty(exports, "HttpError", {
     enumerable: true,
     get: function () { return eventHttp.HttpError; }
 });
-Object.defineProperty(exports, 'useHttpContext', {
+Object.defineProperty(exports, "useHttpContext", {
     enumerable: true,
     get: function () { return eventHttp.useHttpContext; }
 });