@innet/server 2.0.0-alpha.3 → 2.0.0-alpha.30

package/utils/action/Action.js

@@ -3,65 +3,91 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var cookie = require('cookie');
+var cookieLib = require('cookie');
+var requestIp = require('request-ip');
 require('../decorators/index.js');
 require('../parseBody/index.js');
 require('../parseFormBody/index.js');
 require('../parseSearch/index.js');
 var constants = require('../../constants.js');
-var parseSearch = require('../parseSearch/parseSearch.js');
 var parseFormBody = require('../parseFormBody/parseFormBody.js');
+var parseSearch = require('../parseSearch/parseSearch.js');
 var parseBody = require('../parseBody/parseBody.js');
 var once = require('../decorators/once/once.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var cookie__default = /*#__PURE__*/_interopDefaultLegacy(cookie);
+var cookieLib__default = /*#__PURE__*/_interopDefaultLegacy(cookieLib);
 
 const URL_PARSER = /^(?<path>[^?]+)(\?(?<search>.*))?/;
 let Action = (() => {
-    var _a, _Action_search, _Action_headers, _Action_cookie;
+    var _a, _Action_cookie, _Action_headers, _Action_search;
     let _instanceExtraInitializers = [];
-    let _get_parsedUrl_decorators;
-    let _get_originSearch_decorators;
-    let _get_originCookies_decorators;
-    let _get_bodyType_decorators;
     let _parseBody_decorators;
+    let _get_bodyType_decorators;
+    let _get_clientIp_decorators;
+    let _get_originCookies_decorators;
+    let _get_originSearch_decorators;
+    let _get_parsedUrl_decorators;
     return _a = class Action {
-            constructor(req) {
+            constructor(req, res) {
                 this.req = (tslib.__runInitializers(this, _instanceExtraInitializers), req);
-                _Action_search.set(this, void 0);
-                _Action_headers.set(this, {});
+                this.res = res;
                 _Action_cookie.set(this, {});
+                _Action_headers.set(this, {});
+                _Action_search.set(this, void 0);
             }
-            get parsedUrl() {
-                var _a;
-                const match = (_a = this.req.url) === null || _a === void 0 ? void 0 : _a.match(URL_PARSER);
-                if (!match)
-                    throw Error('cannot parse url');
-                const result = match.groups;
-                result.path = result.path
-                    .replaceAll(/\/\.\.\//g, '/')
-                    .replaceAll(/\/+/g, '/');
-                return result;
+            parseBody() {
+                return tslib.__awaiter(this, void 0, void 0, function* () {
+                    if (!this.bodyType) {
+                        return;
+                    }
+                    if (this.bodyType === 'multipart/form-data') {
+                        this.body = yield parseFormBody.parseFormBody(this.req);
+                    }
+                    if (this.bodyType === 'application/x-www-form-urlencoded') {
+                        this.body = parseSearch.parseSearch(yield parseBody.parseBody(this.req));
+                    }
+                    if (this.bodyType === 'application/json') {
+                        this.body = JSON.parse(yield parseBody.parseBody(this.req));
+                    }
+                });
             }
-            get path() {
-                return this.parsedUrl.path;
+            setCookie(name, value, options) {
+                let cookies = this.res.getHeader('Set-Cookie');
+                if (typeof cookies === 'string') {
+                    cookies = [cookies];
+                }
+                const normValue = typeof value === 'string' ? cookieLib__default["default"].serialize(name, value, options) : `${name}=; max-age=0`;
+                if (cookies) {
+                    cookies.push(normValue);
+                }
+                else {
+                    cookies = normValue;
+                }
+                this.res.setHeader('Set-Cookie', cookies);
             }
-            get originSearch() {
-                return parseSearch.parseSearch(this.parsedUrl.search);
+            get bodyType() {
+                const headerType = this.req.headers['content-type'];
+                if (!headerType)
+                    return;
+                for (const bodyType of constants.allBodyTypes) {
+                    if (headerType.startsWith(bodyType)) {
+                        return bodyType;
+                    }
+                }
             }
-            get search() {
-                if (tslib.__classPrivateFieldGet(this, _Action_search, "f"))
-                    return tslib.__classPrivateFieldGet(this, _Action_search, "f");
-                tslib.__classPrivateFieldSet(this, _Action_search, this.originSearch, "f");
-                return tslib.__classPrivateFieldGet(this, _Action_search, "f");
+            get clientIp() {
+                return requestIp.getClientIp(this.req);
             }
-            set search(value) {
-                tslib.__classPrivateFieldSet(this, _Action_search, value, "f");
+            get cookies() {
+                if (tslib.__classPrivateFieldGet(this, _Action_cookie, "f"))
+                    return tslib.__classPrivateFieldGet(this, _Action_cookie, "f");
+                tslib.__classPrivateFieldSet(this, _Action_cookie, this.originCookies, "f");
+                return tslib.__classPrivateFieldGet(this, _Action_cookie, "f");
             }
-            get originHeaders() {
-                return this.req.headers;
+            set cookies(value) {
+                tslib.__classPrivateFieldSet(this, _Action_cookie, value, "f");
             }
             get headers() {
                 if (tslib.__classPrivateFieldGet(this, _Action_headers, "f"))
@@ -73,59 +99,57 @@ let Action = (() => {
                 tslib.__classPrivateFieldSet(this, _Action_headers, value, "f");
             }
             get originCookies() {
-                var _a;
-                return cookie__default["default"].parse((_a = this.req.headers.cookie) !== null && _a !== void 0 ? _a : '');
+                var _b;
+                return cookieLib__default["default"].parse((_b = this.req.headers.cookie) !== null && _b !== void 0 ? _b : '');
             }
-            get cookies() {
-                if (tslib.__classPrivateFieldGet(this, _Action_cookie, "f"))
-                    return tslib.__classPrivateFieldGet(this, _Action_cookie, "f");
-                tslib.__classPrivateFieldSet(this, _Action_cookie, this.originCookies, "f");
-                return tslib.__classPrivateFieldGet(this, _Action_cookie, "f");
+            get originHeaders() {
+                return this.req.headers;
             }
-            set cookies(value) {
-                tslib.__classPrivateFieldSet(this, _Action_cookie, value, "f");
+            get originSearch() {
+                return parseSearch.parseSearch(this.parsedUrl.search);
             }
-            get bodyType() {
-                const headerType = this.req.headers['content-type'];
-                if (!headerType)
-                    return;
-                for (const bodyType of constants.allBodyTypes) {
-                    if (headerType.startsWith(bodyType)) {
-                        return bodyType;
-                    }
-                }
+            get parsedUrl() {
+                var _b;
+                const match = (_b = this.req.url) === null || _b === void 0 ? void 0 : _b.match(URL_PARSER);
+                if (!match)
+                    throw Error('cannot parse url');
+                const result = match.groups;
+                result.path = result.path
+                    .replaceAll(/\/\.\.\//g, '/')
+                    .replaceAll(/\/+/g, '/');
+                return result;
             }
-            parseBody() {
-                return tslib.__awaiter(this, void 0, void 0, function* () {
-                    if (!this.bodyType) {
-                        return;
-                    }
-                    if (this.bodyType === 'multipart/form-data') {
-                        this.body = yield parseFormBody.parseFormBody(this.req);
-                    }
-                    if (this.bodyType === 'application/x-www-form-urlencoded') {
-                        this.body = parseSearch.parseSearch(yield parseBody.parseBody(this.req));
-                    }
-                    if (this.bodyType === 'application/json') {
-                        this.body = JSON.parse(yield parseBody.parseBody(this.req));
-                    }
-                });
+            get path() {
+                return this.parsedUrl.path;
+            }
+            get search() {
+                if (tslib.__classPrivateFieldGet(this, _Action_search, "f"))
+                    return tslib.__classPrivateFieldGet(this, _Action_search, "f");
+                tslib.__classPrivateFieldSet(this, _Action_search, this.originSearch, "f");
+                return tslib.__classPrivateFieldGet(this, _Action_search, "f");
+            }
+            set search(value) {
+                tslib.__classPrivateFieldSet(this, _Action_search, value, "f");
             }
         },
-        _Action_search = new WeakMap(),
-        _Action_headers = new WeakMap(),
         _Action_cookie = new WeakMap(),
+        _Action_headers = new WeakMap(),
+        _Action_search = new WeakMap(),
         (() => {
-            _get_parsedUrl_decorators = [once.once];
-            _get_originSearch_decorators = [once.once];
-            _get_originCookies_decorators = [once.once];
-            _get_bodyType_decorators = [once.once];
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
             _parseBody_decorators = [once.once];
-            tslib.__esDecorate(_a, null, _get_parsedUrl_decorators, { kind: "getter", name: "parsedUrl", static: false, private: false, access: { has: obj => "parsedUrl" in obj, get: obj => obj.parsedUrl } }, null, _instanceExtraInitializers);
-            tslib.__esDecorate(_a, null, _get_originSearch_decorators, { kind: "getter", name: "originSearch", static: false, private: false, access: { has: obj => "originSearch" in obj, get: obj => obj.originSearch } }, null, _instanceExtraInitializers);
-            tslib.__esDecorate(_a, null, _get_originCookies_decorators, { kind: "getter", name: "originCookies", static: false, private: false, access: { has: obj => "originCookies" in obj, get: obj => obj.originCookies } }, null, _instanceExtraInitializers);
-            tslib.__esDecorate(_a, null, _get_bodyType_decorators, { kind: "getter", name: "bodyType", static: false, private: false, access: { has: obj => "bodyType" in obj, get: obj => obj.bodyType } }, null, _instanceExtraInitializers);
-            tslib.__esDecorate(_a, null, _parseBody_decorators, { kind: "method", name: "parseBody", static: false, private: false, access: { has: obj => "parseBody" in obj, get: obj => obj.parseBody } }, null, _instanceExtraInitializers);
+            _get_bodyType_decorators = [once.once];
+            _get_clientIp_decorators = [once.once];
+            _get_originCookies_decorators = [once.once];
+            _get_originSearch_decorators = [once.once];
+            _get_parsedUrl_decorators = [once.once];
+            tslib.__esDecorate(_a, null, _parseBody_decorators, { kind: "method", name: "parseBody", static: false, private: false, access: { has: obj => "parseBody" in obj, get: obj => obj.parseBody }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib.__esDecorate(_a, null, _get_bodyType_decorators, { kind: "getter", name: "bodyType", static: false, private: false, access: { has: obj => "bodyType" in obj, get: obj => obj.bodyType }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib.__esDecorate(_a, null, _get_clientIp_decorators, { kind: "getter", name: "clientIp", static: false, private: false, access: { has: obj => "clientIp" in obj, get: obj => obj.clientIp }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib.__esDecorate(_a, null, _get_originCookies_decorators, { kind: "getter", name: "originCookies", static: false, private: false, access: { has: obj => "originCookies" in obj, get: obj => obj.originCookies }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib.__esDecorate(_a, null, _get_originSearch_decorators, { kind: "getter", name: "originSearch", static: false, private: false, access: { has: obj => "originSearch" in obj, get: obj => obj.originSearch }, metadata: _metadata }, null, _instanceExtraInitializers);
+            tslib.__esDecorate(_a, null, _get_parsedUrl_decorators, { kind: "getter", name: "parsedUrl", static: false, private: false, access: { has: obj => "parsedUrl" in obj, get: obj => obj.parsedUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         })(),
         _a;
 })();

package/utils/dateFormat/dateFormat.d.ts

@@ -1,2 +1,2 @@
-export type DateFormat = 'now' | string | number | Date;
+export type DateFormat = 'now' | Date | number | string;
 export declare function dateFormat(date?: DateFormat): Date | undefined;

package/utils/dateFormat/dateFormat.es6.js

@@ -3,7 +3,7 @@ function dateFormat(date) {
         return;
     if (date === 'now')
         return new Date();
-    if (['string', 'number'].includes(typeof date))
+    if (['number', 'string'].includes(typeof date))
         return new Date(date);
     return date;
 }

package/utils/dateFormat/dateFormat.js

@@ -7,7 +7,7 @@ function dateFormat(date) {
         return;
     if (date === 'now')
         return new Date();
-    if (['string', 'number'].includes(typeof date))
+    if (['number', 'string'].includes(typeof date))
         return new Date(date);
     return date;
 }

package/utils/generateTypes/generateTypes.d.ts

@@ -0,0 +1,3 @@
+import { type Document, type SchemaObject } from '../../types';
+export declare function generateSchemaTypes(schema: SchemaObject, spaces?: number, lastChar?: string): string;
+export declare function generateTypes(docs: Document, namespace?: string): string;

package/utils/generateTypes/generateTypes.es6.js

@@ -0,0 +1,157 @@
+function hasDefault(target) {
+    return Boolean(target && ('default' in target || 'x-default' in target));
+}
+function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
+    const space = [...new Array(spaces)].map(() => ' ').join('');
+    if ('$ref' in schema) {
+        return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
+    }
+    if (schema.type === 'integer') {
+        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
+    }
+    if (schema.type === 'string') {
+        if (schema.format === 'date-time') {
+            return `Date${lastChar}`;
+        }
+        if (schema.format === 'binary') {
+            return `Bin${lastChar}`;
+        }
+        return `string${lastChar}`;
+    }
+    if (['boolean', 'null', 'number'].includes(schema.type)) {
+        return `${schema.type}${lastChar}`;
+    }
+    if (schema.oneOf) {
+        let result = '';
+        for (const item of schema.oneOf) {
+            if (result) {
+                result += ' | ';
+            }
+            result += generateSchemaTypes(item, spaces + 2, '');
+        }
+        return result + lastChar;
+    }
+    if (schema.type === 'array') {
+        if (!schema.items)
+            return `any[]${lastChar}`;
+        return `Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>${lastChar}`;
+    }
+    if (!schema.type) {
+        return `any${lastChar}`;
+    }
+    if (schema.type !== 'object') {
+        console.error('unknown type', schema);
+        return `any${lastChar}`;
+    }
+    let result = '{\n';
+    const required = schema.required || [];
+    const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
+    const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
+        Object.keys(schema.additionalProperties).length);
+    if (hasProps) {
+        for (const key in schema.properties) {
+            const prop = schema.properties[key];
+            const splitter = required.includes(key) || hasDefault(prop)
+                ? ':'
+                : '?:';
+            if ('deprecated' in prop && prop.deprecated) {
+                result += `${space}/** @deprecated */\n`;
+            }
+            result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+        }
+    }
+    if (hasRestProps) {
+        const value = hasProps
+            ? 'any\n'
+            : generateSchemaTypes(schema.additionalProperties, spaces + 2);
+        result += `${space}[key: string]: ${value}`;
+    }
+    return `${result}${space.slice(0, -2)}}${lastChar}`;
+}
+function generateTypes(docs, namespace = 'Api') {
+    var _a;
+    let result = `declare namespace ${namespace} {
+  export interface Bin {
+    filename: string
+    fieldName: string
+    originalFilename: string
+    path: string
+    type: string
+    disposition: string
+    size: number
+    extension?: string
+  }
+`;
+    const schemas = (_a = docs.components) === null || _a === void 0 ? void 0 : _a.schemas;
+    const paths = docs.paths;
+    if (schemas) {
+        result += '  namespace Schemas {\n';
+        for (const name in schemas) {
+            result += `    export type ${name} = ${generateSchemaTypes(schemas[name], 6)}`;
+        }
+        result += '  }\n';
+    }
+    result += '  export interface Endpoints {\n';
+    for (const path in paths) {
+        const pathObject = paths[path];
+        for (const method in pathObject) {
+            // @ts-expect-error: FIXME
+            const endpoint = pathObject[method];
+            const parameters = endpoint.parameters;
+            const requestBody = endpoint.requestBody;
+            const responses = endpoint.responses;
+            if (endpoint.deprecated) {
+                result += '    /** @deprecated */\n';
+            }
+            result += `    ['${method.toUpperCase()}:${path}']: {\n`;
+            if (parameters) {
+                const params = {
+                    cookie: '',
+                    header: '',
+                    path: '',
+                    query: '',
+                };
+                for (const param of parameters) {
+                    const splitter = param.in === 'path' || hasDefault(param.schema) || param.required ? ':' : '?:';
+                    params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
+                }
+                if (params.path) {
+                    result += `      Params: {\n${params.path}      }\n`;
+                }
+                if (params.query) {
+                    result += `      Search: {\n${params.query}      }\n`;
+                }
+                if (params.header) {
+                    result += `      Headers: {\n${params.header}      }\n`;
+                }
+                if (params.cookie) {
+                    result += `      Cookies: {\n${params.cookie}      }\n`;
+                }
+            }
+            if (requestBody) {
+                result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
+            }
+            if (responses) {
+                result += '      Response: {\n';
+                for (const key in responses) {
+                    let multiple = false;
+                    const response = responses[key];
+                    result += `        ['${key}']: `;
+                    for (const type in response.content) {
+                        if (multiple) {
+                            result += ' | ';
+                        }
+                        result += generateSchemaTypes(response.content[type].schema, 10, '');
+                        multiple = true;
+                    }
+                    result += '\n';
+                }
+                result += '     }\n';
+            }
+            result += '    }\n';
+        }
+    }
+    return result + '  }\n}';
+}
+
+export { generateSchemaTypes, generateTypes };

package/utils/generateTypes/generateTypes.js

@@ -0,0 +1,162 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function hasDefault(target) {
+    return Boolean(target && ('default' in target || 'x-default' in target));
+}
+function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
+    const space = [...new Array(spaces)].map(() => ' ').join('');
+    if ('$ref' in schema) {
+        return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
+    }
+    if (schema.type === 'integer') {
+        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
+    }
+    if (schema.type === 'string') {
+        if (schema.format === 'date-time') {
+            return `Date${lastChar}`;
+        }
+        if (schema.format === 'binary') {
+            return `Bin${lastChar}`;
+        }
+        return `string${lastChar}`;
+    }
+    if (['boolean', 'null', 'number'].includes(schema.type)) {
+        return `${schema.type}${lastChar}`;
+    }
+    if (schema.oneOf) {
+        let result = '';
+        for (const item of schema.oneOf) {
+            if (result) {
+                result += ' | ';
+            }
+            result += generateSchemaTypes(item, spaces + 2, '');
+        }
+        return result + lastChar;
+    }
+    if (schema.type === 'array') {
+        if (!schema.items)
+            return `any[]${lastChar}`;
+        return `Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>${lastChar}`;
+    }
+    if (!schema.type) {
+        return `any${lastChar}`;
+    }
+    if (schema.type !== 'object') {
+        console.error('unknown type', schema);
+        return `any${lastChar}`;
+    }
+    let result = '{\n';
+    const required = schema.required || [];
+    const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
+    const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
+        Object.keys(schema.additionalProperties).length);
+    if (hasProps) {
+        for (const key in schema.properties) {
+            const prop = schema.properties[key];
+            const splitter = required.includes(key) || hasDefault(prop)
+                ? ':'
+                : '?:';
+            if ('deprecated' in prop && prop.deprecated) {
+                result += `${space}/** @deprecated */\n`;
+            }
+            result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+        }
+    }
+    if (hasRestProps) {
+        const value = hasProps
+            ? 'any\n'
+            : generateSchemaTypes(schema.additionalProperties, spaces + 2);
+        result += `${space}[key: string]: ${value}`;
+    }
+    return `${result}${space.slice(0, -2)}}${lastChar}`;
+}
+function generateTypes(docs, namespace = 'Api') {
+    var _a;
+    let result = `declare namespace ${namespace} {
+  export interface Bin {
+    filename: string
+    fieldName: string
+    originalFilename: string
+    path: string
+    type: string
+    disposition: string
+    size: number
+    extension?: string
+  }
+`;
+    const schemas = (_a = docs.components) === null || _a === void 0 ? void 0 : _a.schemas;
+    const paths = docs.paths;
+    if (schemas) {
+        result += '  namespace Schemas {\n';
+        for (const name in schemas) {
+            result += `    export type ${name} = ${generateSchemaTypes(schemas[name], 6)}`;
+        }
+        result += '  }\n';
+    }
+    result += '  export interface Endpoints {\n';
+    for (const path in paths) {
+        const pathObject = paths[path];
+        for (const method in pathObject) {
+            // @ts-expect-error: FIXME
+            const endpoint = pathObject[method];
+            const parameters = endpoint.parameters;
+            const requestBody = endpoint.requestBody;
+            const responses = endpoint.responses;
+            if (endpoint.deprecated) {
+                result += '    /** @deprecated */\n';
+            }
+            result += `    ['${method.toUpperCase()}:${path}']: {\n`;
+            if (parameters) {
+                const params = {
+                    cookie: '',
+                    header: '',
+                    path: '',
+                    query: '',
+                };
+                for (const param of parameters) {
+                    const splitter = param.in === 'path' || hasDefault(param.schema) || param.required ? ':' : '?:';
+                    params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
+                }
+                if (params.path) {
+                    result += `      Params: {\n${params.path}      }\n`;
+                }
+                if (params.query) {
+                    result += `      Search: {\n${params.query}      }\n`;
+                }
+                if (params.header) {
+                    result += `      Headers: {\n${params.header}      }\n`;
+                }
+                if (params.cookie) {
+                    result += `      Cookies: {\n${params.cookie}      }\n`;
+                }
+            }
+            if (requestBody) {
+                result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
+            }
+            if (responses) {
+                result += '      Response: {\n';
+                for (const key in responses) {
+                    let multiple = false;
+                    const response = responses[key];
+                    result += `        ['${key}']: `;
+                    for (const type in response.content) {
+                        if (multiple) {
+                            result += ' | ';
+                        }
+                        result += generateSchemaTypes(response.content[type].schema, 10, '');
+                        multiple = true;
+                    }
+                    result += '\n';
+                }
+                result += '     }\n';
+            }
+            result += '    }\n';
+        }
+    }
+    return result + '  }\n}';
+}
+
+exports.generateSchemaTypes = generateSchemaTypes;
+exports.generateTypes = generateTypes;

package/utils/generateTypes/index.d.ts

@@ -0,0 +1 @@
+export * from './generateTypes';

package/utils/generateTypes/index.es6.js

@@ -0,0 +1 @@
+export { generateSchemaTypes, generateTypes } from './generateTypes.es6.js';

package/utils/generateTypes/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var generateTypes = require('./generateTypes.js');
+
+
+
+exports.generateSchemaTypes = generateTypes.generateSchemaTypes;
+exports.generateTypes = generateTypes.generateTypes;

package/utils/getEndpoint/getEndpoint.es6.js

@@ -8,7 +8,7 @@ function getEndpoint(path, parentEndpoint) {
                 parentEndpoint.static = {};
             }
             if (!parentEndpoint.static[key]) {
-                parentEndpoint.static[key] = { key };
+                parentEndpoint.static[key] = { key, plugins: new Set() };
             }
             parentEndpoint = parentEndpoint.static[key];
             if (deep + 1 === splitPath.length) {
@@ -19,7 +19,7 @@ function getEndpoint(path, parentEndpoint) {
         if (!parentEndpoint.dynamic) {
             parentEndpoint.dynamic = [];
         }
-        const newEndpoint = { key };
+        const newEndpoint = { key, plugins: new Set() };
         parentEndpoint.dynamic.push(newEndpoint);
         parentEndpoint = newEndpoint;
         if (deep + 1 === splitPath.length) {

package/utils/getEndpoint/getEndpoint.js

@@ -12,7 +12,7 @@ function getEndpoint(path, parentEndpoint) {
                 parentEndpoint.static = {};
             }
             if (!parentEndpoint.static[key]) {
-                parentEndpoint.static[key] = { key };
+                parentEndpoint.static[key] = { key, plugins: new Set() };
             }
             parentEndpoint = parentEndpoint.static[key];
             if (deep + 1 === splitPath.length) {
@@ -23,7 +23,7 @@ function getEndpoint(path, parentEndpoint) {
         if (!parentEndpoint.dynamic) {
             parentEndpoint.dynamic = [];
         }
-        const newEndpoint = { key };
+        const newEndpoint = { key, plugins: new Set() };
         parentEndpoint.dynamic.push(newEndpoint);
         parentEndpoint = newEndpoint;
         if (deep + 1 === splitPath.length) {

package/utils/getOrAdd/getOrAdd.d.ts

@@ -1 +1 @@
-export declare function getOrAdd<R = any>(target: object, path: string | number, defaultValues: any[]): R;
+export declare function getOrAdd<R = any>(target: object, path: number | string, defaultValues: any[]): R;

package/utils/httpOnStart/httpOnStart.d.ts

@@ -1,2 +1,2 @@
 import { type ServerStartParams } from '../../types';
-export declare function httpOnStart({ port, https }: ServerStartParams): void;
+export declare function httpOnStart({ https, port, }: ServerStartParams): void;

package/utils/httpOnStart/httpOnStart.es6.js

@@ -1,4 +1,4 @@
-function httpOnStart({ port, https }) {
+function httpOnStart({ https, port, }) {
     console.log(`http${https ? 's' : ''}://localhost:${port}`);
 }