@moostjs/event-http 0.2.0

package/README.md

@@ -0,0 +1,37 @@
+# @moostjs/event-http
+
+**!!! This is work-in-progress library, breaking changes are expected !!!**
+
+<p align="center">
+<img src="../../moost-logo.png" width="450px"><br>
+<a  href="https://github.com/moostjs/moostjs/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" />
+</a>
+</p>
+
+`event-http` is a moostjs wrapper of [@wooksjs/event-http](https://github.com/wooksjs/wooksjs/tree/main/packages/event-http) with corresponding decorators for composable functions.
+
+## Quick Start
+
+```ts
+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, () => { console.log('Up on port 3000') })
+app.init()
+// curl http://localhost:3000/test/World
+// {"message":"Hello World!"}
+```
+
+## Install
+
+`npm install moost @moostjs/event-http`

package/dist/index.cjs

@@ -0,0 +1,497 @@
+'use strict';
+
+var eventHttp = require('@wooksjs/event-http');
+var moost = require('moost');
+
+/******************************************************************************
+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$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());
+    });
+}
+
+class MoostHttp {
+    constructor(httpApp) {
+        this.pathBuilders = {};
+        if (httpApp && httpApp instanceof eventHttp.WooksHttp) {
+            this.httpApp = httpApp;
+        }
+        else if (httpApp) {
+            this.httpApp = eventHttp.createHttpApp(httpApp);
+        }
+        else {
+            this.httpApp = eventHttp.createHttpApp();
+        }
+    }
+    getHttpApp() {
+        return this.httpApp;
+    }
+    getServerCb() {
+        return this.httpApp.getServerCb();
+    }
+    listen(...args) {
+        return this.httpApp.listen(...args);
+    }
+    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, '/');
+            if (!fn) {
+                fn = () => __awaiter$1(this, void 0, void 0, function* () {
+                    const { restoreCtx } = eventHttp.useHttpContext();
+                    const { reqId, rawRequest } = eventHttp.useRequest();
+                    const scopeId = reqId();
+                    rawRequest.on('end', opts.registerEventScope(scopeId));
+                    const instance = yield opts.getInstance();
+                    restoreCtx();
+                    // setComposableControllerContext({
+                    //     controller: instance,
+                    //     method: method as string,
+                    //     pathBuilder: pathBuilder as ReturnType<Wooks['on']>,
+                    // })
+                    let response;
+                    const interceptorHandler = yield opts.getIterceptorHandler();
+                    restoreCtx();
+                    yield interceptorHandler.init();
+                    // params
+                    let args = [];
+                    try {
+                        restoreCtx();
+                        args = yield opts.resolveArgs();
+                    }
+                    catch (e) {
+                        response = e;
+                    }
+                    if (!response) {
+                        restoreCtx();
+                        // fire before interceptors
+                        response = yield interceptorHandler.fireBefore(response);
+                        // fire request handler
+                        if (!interceptorHandler.responseOverwritten) {
+                            try {
+                                restoreCtx();
+                                response = yield instance[opts.method](...args);
+                            }
+                            catch (e) {
+                                response = e;
+                            }
+                        }
+                    }
+                    // fire after interceptors
+                    response = yield interceptorHandler.fireAfter(response);
+                    return response;
+                });
+            }
+            const pathBuilder = this.httpApp.on(handler.method, targetPath, fn);
+            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}`);
+        }
+    }
+}
+
+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 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 banner = () => `[${"@wooksjs/http-body"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+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 panic(`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', () => __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.WooksError(400, e.message);
+        }
+    }
+    function textParser(v) {
+        return v;
+    }
+    function formDataParser(v) {
+        const boundary = '--' + (/boundary=([^;]+)(?:;|$)/.exec(contentType || '') || [, ''])[1];
+        if (!boundary)
+            throw new eventHttp.WooksError(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.WooksError(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.WooksError(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,
+    };
+}
+
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @paramType TStatusHook
+ */
+const StatusHook = moost.Resolve(() => eventHttp.useStatus(), 'status');
+/**
+ * Hook to the Response Header
+ * @decorator
+ * @param name - header name
+ * @paramType THeaderHook
+ */
+const HeaderHook = (name) => moost.Resolve(() => eventHttp.useSetHeader(name), name);
+/**
+ * Hook to the Response Cookie
+ * @decorator
+ * @param name - header name
+ * @paramType TCookieHook
+ */
+const CookieHook = (name) => moost.Resolve(() => eventHttp.useSetCookie(name), 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) {
+    return moost.Resolve(() => {
+        const { jsonSearchParams, urlSearchParams } = eventHttp.useSearchParams();
+        if (name) {
+            const p = urlSearchParams();
+            const value = p.get(name);
+            console.log(name + ' = ', value);
+            return value === '' && p.has(name) || value;
+        }
+        const json = jsonSearchParams();
+        return Object.keys(json).length ? json : undefined;
+    }, name || 'Query');
+}
+/**
+ * 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 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 Raw Response Object
+ * @decorator
+ * @param options - passthrough options
+ * @paramType string
+ */
+function Res(options) {
+    return moost.Resolve(() => eventHttp.useResponse().rawResponse(options), 'response');
+}
+/**
+ * Get Parsed Request Body
+ * @decorator
+ * @paramType object | string | unknown
+ */
+function Body() {
+    return moost.Resolve(() => useBody().parseBody(), 'body');
+}
+/**
+ * Get Raw Request Body Buffer
+ * @decorator
+ * @paramType Promise<Buffer>
+ */
+function RawBody() {
+    return moost.Resolve(() => useBody().rawBody(), 'body');
+}
+
+exports.All = All;
+exports.Authorization = Authorization;
+exports.Body = Body;
+exports.Cookie = Cookie;
+exports.CookieHook = CookieHook;
+exports.Delete = Delete;
+exports.Get = Get;
+exports.Header = Header;
+exports.HeaderHook = HeaderHook;
+exports.HttpMethod = HttpMethod;
+exports.Ip = Ip;
+exports.IpList = IpList;
+exports.Method = Method;
+exports.MoostHttp = MoostHttp;
+exports.Patch = Patch;
+exports.Post = Post;
+exports.Put = Put;
+exports.Query = Query;
+exports.RawBody = RawBody;
+exports.Req = Req;
+exports.ReqId = ReqId;
+exports.Res = Res;
+exports.StatusHook = StatusHook;
+exports.Url = Url;

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+/// <reference types="node" />
+
+import { IncomingMessage } from 'http';
+import { ServerResponse } from 'http';
+import { TMoostAdapter } from 'moost';
+import { TMoostAdapterOptions } from 'moost';
+import { TProstoRouterPathBuilder } from '@prostojs/router';
+import { TWooksHttpOptions } from '@wooksjs/event-http';
+import { WooksHttp } from '@wooksjs/event-http';
+
+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
+ */
+declare function Body_2(): ParameterDecorator;
+export { Body_2 as Body }
+
+/**
+ * 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;
+
+export declare const Get: (path?: string) => MethodDecorator;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * Get Requested HTTP Method
+ * @decorator
+ * @paramType string
+ */
+export declare function Method(): ParameterDecorator;
+
+export declare class MoostHttp implements TMoostAdapter<THttpHandlerMeta> {
+    protected httpApp: WooksHttp;
+    constructor(httpApp?: WooksHttp | TWooksHttpOptions);
+    getHttpApp(): WooksHttp;
+    getServerCb(): (req: IncomingMessage, res: ServerResponse<IncomingMessage>) => Promise<void>;
+    listen(...args: Parameters<WooksHttp['listen']>): Promise<unknown>;
+    readonly pathBuilders: {
+        [id: string]: {
+            GET?: TProstoRouterPathBuilder<Record<string, string | string[]>>;
+            PUT?: TProstoRouterPathBuilder<Record<string, string | string[]>>;
+            PATCH?: TProstoRouterPathBuilder<Record<string, string | string[]>>;
+            POST?: TProstoRouterPathBuilder<Record<string, string | string[]>>;
+            DELETE?: TProstoRouterPathBuilder<Record<string, string | string[]>>;
+        };
+    };
+    bindHandler<T extends object = object>(opts: TMoostAdapterOptions<THttpHandlerMeta, T>): void | Promise<void>;
+}
+
+export declare const Patch: (path?: string) => MethodDecorator;
+
+export declare const Post: (path?: string) => MethodDecorator;
+
+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;
+
+/**
+ * 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
+ * @paramType TStatusHook
+ */
+export declare const StatusHook: ParameterDecorator;
+
+export declare interface THttpHandlerMeta {
+    method: string;
+    path: string;
+}
+
+/**
+ * Get Requested URL
+ * @decorator
+ * @paramType string
+ */
+export declare function Url(): ParameterDecorator;
+
+export { }

package/dist/index.mjs

@@ -0,0 +1,472 @@
+import { WooksHttp, createHttpApp, useHttpContext, useRequest, useHeaders, WooksError, EHttpStatusCode, WooksURLSearchParams, useStatus, useSetHeader, useSetCookie, useAuthorization, useCookies, useSearchParams, useResponse } from '@wooksjs/event-http';
+import { getMoostMate, Resolve } from 'moost';
+
+/******************************************************************************
+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$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());
+    });
+}
+
+class MoostHttp {
+    constructor(httpApp) {
+        this.pathBuilders = {};
+        if (httpApp && httpApp instanceof WooksHttp) {
+            this.httpApp = httpApp;
+        }
+        else if (httpApp) {
+            this.httpApp = createHttpApp(httpApp);
+        }
+        else {
+            this.httpApp = createHttpApp();
+        }
+    }
+    getHttpApp() {
+        return this.httpApp;
+    }
+    getServerCb() {
+        return this.httpApp.getServerCb();
+    }
+    listen(...args) {
+        return this.httpApp.listen(...args);
+    }
+    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, '/');
+            if (!fn) {
+                fn = () => __awaiter$1(this, void 0, void 0, function* () {
+                    const { restoreCtx } = useHttpContext();
+                    const { reqId, rawRequest } = useRequest();
+                    const scopeId = reqId();
+                    rawRequest.on('end', opts.registerEventScope(scopeId));
+                    const instance = yield opts.getInstance();
+                    restoreCtx();
+                    // setComposableControllerContext({
+                    //     controller: instance,
+                    //     method: method as string,
+                    //     pathBuilder: pathBuilder as ReturnType<Wooks['on']>,
+                    // })
+                    let response;
+                    const interceptorHandler = yield opts.getIterceptorHandler();
+                    restoreCtx();
+                    yield interceptorHandler.init();
+                    // params
+                    let args = [];
+                    try {
+                        restoreCtx();
+                        args = yield opts.resolveArgs();
+                    }
+                    catch (e) {
+                        response = e;
+                    }
+                    if (!response) {
+                        restoreCtx();
+                        // fire before interceptors
+                        response = yield interceptorHandler.fireBefore(response);
+                        // fire request handler
+                        if (!interceptorHandler.responseOverwritten) {
+                            try {
+                                restoreCtx();
+                                response = yield instance[opts.method](...args);
+                            }
+                            catch (e) {
+                                response = e;
+                            }
+                        }
+                    }
+                    // fire after interceptors
+                    response = yield interceptorHandler.fireAfter(response);
+                    return response;
+                });
+            }
+            const pathBuilder = this.httpApp.on(handler.method, targetPath, fn);
+            const methodMeta = 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}`);
+        }
+    }
+}
+
+function HttpMethod(method, path) {
+    return 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 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 banner = () => `[${"@wooksjs/http-body"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+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 panic(`Usupported compression type "${e}".`);
+            }
+            newBody = yield compressors[e].uncompress(body);
+        }
+        return newBody;
+    });
+}
+
+function useBody() {
+    const { store } = useHttpContext();
+    const { init } = store('request');
+    const { rawBody } = useRequest();
+    const { 'content-type': contentType, 'content-encoding': contentEncoding } = 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 WooksError(400, e.message);
+        }
+    }
+    function textParser(v) {
+        return v;
+    }
+    function formDataParser(v) {
+        const boundary = '--' + (/boundary=([^;]+)(?:;|$)/.exec(contentType || '') || [, ''])[1];
+        if (!boundary)
+            throw new WooksError(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 WooksError(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 WooksError(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 WooksURLSearchParams(v.trim()).toJson();
+    }
+    return {
+        isJson,
+        isHtml,
+        isXml,
+        isText,
+        isBinary,
+        isFormData,
+        isUrlencoded,
+        isCompressed,
+        contentEncodings,
+        parseBody,
+        rawBody,
+    };
+}
+
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @paramType TStatusHook
+ */
+const StatusHook = Resolve(() => useStatus(), 'status');
+/**
+ * Hook to the Response Header
+ * @decorator
+ * @param name - header name
+ * @paramType THeaderHook
+ */
+const HeaderHook = (name) => Resolve(() => useSetHeader(name), name);
+/**
+ * Hook to the Response Cookie
+ * @decorator
+ * @param name - header name
+ * @paramType TCookieHook
+ */
+const CookieHook = (name) => Resolve(() => useSetCookie(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;
+        const auth = 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 Resolve(() => {
+        const headers = useHeaders();
+        return headers[name];
+    }, 'header: ' + name);
+}
+/**
+ * Get Request Cookie Value
+ * @decorator
+ * @param name - cookie name
+ * @paramType string
+ */
+function Cookie(name) {
+    return Resolve(() => 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) {
+    return Resolve(() => {
+        const { jsonSearchParams, urlSearchParams } = useSearchParams();
+        if (name) {
+            const p = urlSearchParams();
+            const value = p.get(name);
+            console.log(name + ' = ', value);
+            return value === '' && p.has(name) || value;
+        }
+        const json = jsonSearchParams();
+        return Object.keys(json).length ? json : undefined;
+    }, name || 'Query');
+}
+/**
+ * Get Requested URL
+ * @decorator
+ * @paramType string
+ */
+function Url() {
+    return Resolve(() => useRequest().url, 'url');
+}
+/**
+ * Get Requested HTTP Method
+ * @decorator
+ * @paramType string
+ */
+function Method() {
+    return Resolve(() => useRequest().method, 'http_method');
+}
+/**
+ * Get Raw Request Instance
+ * @decorator
+ * @paramType IncomingMessage
+ */
+function Req() {
+    return Resolve(() => useRequest().rawRequest, 'request');
+}
+/**
+ * Get Request Unique Identificator (UUID)
+ * @decorator
+ * @paramType string
+ */
+function ReqId() {
+    return Resolve(() => useRequest().reqId(), 'reqId');
+}
+/**
+ * Get Request IP Address
+ * @decorator
+ * @paramType string
+ */
+function Ip(opts) {
+    return Resolve(() => useRequest().getIp(opts), 'ip');
+}
+/**
+ * Get Request IP Address list
+ * @decorator
+ * @paramType string[]
+ */
+function IpList() {
+    return Resolve(() => useRequest().getIpList(), 'ipList');
+}
+/**
+ * Get Raw Response Object
+ * @decorator
+ * @param options - passthrough options
+ * @paramType string
+ */
+function Res(options) {
+    return Resolve(() => useResponse().rawResponse(options), 'response');
+}
+/**
+ * Get Parsed Request Body
+ * @decorator
+ * @paramType object | string | unknown
+ */
+function Body() {
+    return Resolve(() => useBody().parseBody(), 'body');
+}
+/**
+ * Get Raw Request Body Buffer
+ * @decorator
+ * @paramType Promise<Buffer>
+ */
+function RawBody() {
+    return Resolve(() => useBody().rawBody(), 'body');
+}
+
+export { All, Authorization, Body, Cookie, CookieHook, Delete, Get, Header, HeaderHook, HttpMethod, Ip, IpList, Method, MoostHttp, Patch, Post, Put, Query, RawBody, Req, ReqId, Res, StatusHook, Url };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@moostjs/event-http",
+  "version": "0.2.0",
+  "description": "@moostjs/event-http",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/moostjs.git",
+    "directory": "packages/event-http"
+  },
+  "keywords": [
+    "moost",
+    "moostjs",
+    "composables",
+    "framework",
+    "wooksjs",
+    "prostojs"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/moostjs/moostjs/issues"
+  },
+  "homepage": "https://github.com/moostjs/moostjs/tree/main/packages/event-http#readme",
+  "peerDependencies": {
+    "moost": "0.2.0"
+  },
+  "dependencies": {
+    "@wooksjs/event-http": "^0.1.0",
+    "wooks": "^0.1.0"
+  }
+}