@innet/server 2.0.0-alpha.8 → 2.0.0-beta.1

package/utils/generateTypes/generateTypes.es6.js

@@ -1,49 +1,87 @@
 function hasDefault(target) {
     return Boolean(target && ('default' in target || 'x-default' in target));
 }
-function generateSchemaTypes(schema, spaces = 2) {
+function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
     const space = [...new Array(spaces)].map(() => ' ').join('');
     if ('$ref' in schema) {
-        return `Schemas.${schema.$ref.slice(21)}\n`;
+        return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
     }
     if (schema.type === 'integer') {
-        return `${schema.format === 'int64' ? 'bigint' : 'number'}\n`;
+        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
     }
     if (schema.type === 'string') {
         if (schema.format === 'date-time') {
-            return 'Date\n';
+            return `Date${lastChar}`;
         }
         if (schema.format === 'binary') {
-            return 'Bin\n';
+            return `Bin${lastChar}`;
         }
-        return 'string\n';
+        return `string${lastChar}`;
     }
-    if (['boolean', 'number', 'null'].includes(schema.type)) {
-        return `${schema.type}\n`;
+    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[]\n';
-        return `(${generateSchemaTypes(schema.items, spaces + 2).slice(0, -1)})[]\n`;
+            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\n';
+        return `any${lastChar}`;
     }
     let result = '{\n';
     const required = schema.required || [];
-    for (const key in schema.properties) {
-        const prop = schema.properties[key];
-        const splitter = required.includes(key) || hasDefault(prop)
-            ? ':'
-            : '?:';
-        result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+    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)}}\n`;
+    return `${result}${space.slice(0, -2)}}${lastChar}`;
 }
-function generateTypes(docs) {
+function generateTypes(docs, namespace = 'Api') {
     var _a;
-    let result = 'declare namespace Api {\n  export interface Bin {\n    filename: string\n    fieldName: string\n    originalFilename: string\n    path: string\n    type: string\n    disposition: string\n    size: number\n    extension?: string\n  }\n';
+    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) {
@@ -62,16 +100,19 @@ function generateTypes(docs) {
             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 = {
-                    query: '',
+                    cookie: '',
                     header: '',
                     path: '',
-                    cookie: '',
+                    query: '',
                 };
                 for (const param of parameters) {
-                    const splitter = param.in === 'path' || hasDefault(param.schema) ? ':' : '?:';
+                    const splitter = param.in === 'path' || hasDefault(param.schema) || param.required ? ':' : '?:';
                     params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
                 }
                 if (params.path) {
@@ -90,8 +131,27 @@ function generateTypes(docs) {
             if (requestBody) {
                 result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
             }
-            if (responses === null || responses === void 0 ? void 0 : responses.default) {
-                result += `      Response: ${generateSchemaTypes(responses.default.content['application/json'].schema, 8)}`;
+            if (responses) {
+                result += '      Response: {\n';
+                for (const key in responses) {
+                    let multiple = false;
+                    const response = responses[key];
+                    result += `        ['${key}']: `;
+                    if (!response.content) {
+                        result += 'void';
+                    }
+                    else {
+                        for (const type in response.content) {
+                            if (multiple) {
+                                result += ' | ';
+                            }
+                            result += generateSchemaTypes(response.content[type].schema, 10, '');
+                            multiple = true;
+                        }
+                    }
+                    result += '\n';
+                }
+                result += '     }\n';
             }
             result += '    }\n';
         }

package/utils/generateTypes/generateTypes.js

@@ -5,49 +5,87 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function hasDefault(target) {
     return Boolean(target && ('default' in target || 'x-default' in target));
 }
-function generateSchemaTypes(schema, spaces = 2) {
+function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
     const space = [...new Array(spaces)].map(() => ' ').join('');
     if ('$ref' in schema) {
-        return `Schemas.${schema.$ref.slice(21)}\n`;
+        return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
     }
     if (schema.type === 'integer') {
-        return `${schema.format === 'int64' ? 'bigint' : 'number'}\n`;
+        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
     }
     if (schema.type === 'string') {
         if (schema.format === 'date-time') {
-            return 'Date\n';
+            return `Date${lastChar}`;
         }
         if (schema.format === 'binary') {
-            return 'Bin\n';
+            return `Bin${lastChar}`;
         }
-        return 'string\n';
+        return `string${lastChar}`;
     }
-    if (['boolean', 'number', 'null'].includes(schema.type)) {
-        return `${schema.type}\n`;
+    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[]\n';
-        return `(${generateSchemaTypes(schema.items, spaces + 2).slice(0, -1)})[]\n`;
+            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\n';
+        return `any${lastChar}`;
     }
     let result = '{\n';
     const required = schema.required || [];
-    for (const key in schema.properties) {
-        const prop = schema.properties[key];
-        const splitter = required.includes(key) || hasDefault(prop)
-            ? ':'
-            : '?:';
-        result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+    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)}}\n`;
+    return `${result}${space.slice(0, -2)}}${lastChar}`;
 }
-function generateTypes(docs) {
+function generateTypes(docs, namespace = 'Api') {
     var _a;
-    let result = 'declare namespace Api {\n  export interface Bin {\n    filename: string\n    fieldName: string\n    originalFilename: string\n    path: string\n    type: string\n    disposition: string\n    size: number\n    extension?: string\n  }\n';
+    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) {
@@ -66,16 +104,19 @@ function generateTypes(docs) {
             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 = {
-                    query: '',
+                    cookie: '',
                     header: '',
                     path: '',
-                    cookie: '',
+                    query: '',
                 };
                 for (const param of parameters) {
-                    const splitter = param.in === 'path' || hasDefault(param.schema) ? ':' : '?:';
+                    const splitter = param.in === 'path' || hasDefault(param.schema) || param.required ? ':' : '?:';
                     params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
                 }
                 if (params.path) {
@@ -94,8 +135,27 @@ function generateTypes(docs) {
             if (requestBody) {
                 result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
             }
-            if (responses === null || responses === void 0 ? void 0 : responses.default) {
-                result += `      Response: ${generateSchemaTypes(responses.default.content['application/json'].schema, 8)}`;
+            if (responses) {
+                result += '      Response: {\n';
+                for (const key in responses) {
+                    let multiple = false;
+                    const response = responses[key];
+                    result += `        ['${key}']: `;
+                    if (!response.content) {
+                        result += 'void';
+                    }
+                    else {
+                        for (const type in response.content) {
+                            if (multiple) {
+                                result += ' | ';
+                            }
+                            result += generateSchemaTypes(response.content[type].schema, 10, '');
+                            multiple = true;
+                        }
+                    }
+                    result += '\n';
+                }
+                result += '     }\n';
             }
             result += '    }\n';
         }

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}`);
 }
 

package/utils/httpOnStart/httpOnStart.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function httpOnStart({ port, https }) {
+function httpOnStart({ https, port, }) {
     console.log(`http${https ? 's' : ''}://localhost:${port}`);
 }
 

package/utils/rules/binaryAccept/binaryAccept.es6.js

@@ -24,8 +24,8 @@ function binaryAccept(accept) {
                 continue;
             return value;
         }
-        throw new RulesError('binaryAccept', Object.assign({ value,
-            accept }, data));
+        throw new RulesError('binaryAccept', Object.assign({ accept,
+            value }, data));
     };
 }
 

package/utils/rules/binaryAccept/binaryAccept.js

@@ -28,8 +28,8 @@ function binaryAccept(accept) {
                 continue;
             return value;
         }
-        throw new helpers.RulesError('binaryAccept', Object.assign({ value,
-            accept }, data));
+        throw new helpers.RulesError('binaryAccept', Object.assign({ accept,
+            value }, data));
     };
 }
 

package/utils/rules/dateTo/dateTo.d.ts

@@ -1,2 +1,2 @@
-export type DateFormat = 'now' | string | number | Date;
+export type DateFormat = 'now' | Date | number | string;
 export declare function dateTo(value: any, data?: object): Date;

package/utils/rules/helpers.d.ts

@@ -5,4 +5,4 @@ export declare class RulesError extends Error {
     } & object;
     constructor(error: RulesErrors, data?: object);
 }
-export declare function addKey(key: string | number, data?: any): string | number;
+export declare function addKey(key: number | string, data?: any): string | number;

package/utils/rules/index.d.ts

@@ -22,7 +22,6 @@ export * from './minLength';
 export * from './max';
 export * from './min';
 export * from './defaultTo';
-export * from './any';
 export * from './bin';
 export * from './minBin';
 export * from './maxBin';

package/utils/rules/index.es6.js

@@ -22,7 +22,6 @@ import './minLength/index.es6.js';
 import './max/index.es6.js';
 import './min/index.es6.js';
 import './defaultTo/index.es6.js';
-import './any/index.es6.js';
 import './bin/index.es6.js';
 import './minBin/index.es6.js';
 import './maxBin/index.es6.js';

package/utils/rules/index.js

@@ -26,7 +26,6 @@ require('./minLength/index.js');
 require('./max/index.js');
 require('./min/index.js');
 require('./defaultTo/index.js');
-require('./any/index.js');
 require('./bin/index.js');
 require('./minBin/index.js');
 require('./maxBin/index.js');

package/utils/rules/int/int.es6.js

@@ -24,10 +24,10 @@ function int(format) {
                 value }, data));
         }
         if (result > sizes[format]) {
-            throw new RulesError('integer', Object.assign({ format, value: result, max: sizes[format] }, data));
+            throw new RulesError('integer', Object.assign({ format, max: sizes[format], value: result }, data));
         }
         if (result < -sizes[format]) {
-            throw new RulesError('integer', Object.assign({ format, value: result, min: -sizes[format] }, data));
+            throw new RulesError('integer', Object.assign({ format, min: -sizes[format], value: result }, data));
         }
         return result;
     };

package/utils/rules/int/int.js

@@ -28,10 +28,10 @@ function int(format) {
                 value }, data));
         }
         if (result > sizes[format]) {
-            throw new helpers.RulesError('integer', Object.assign({ format, value: result, max: sizes[format] }, data));
+            throw new helpers.RulesError('integer', Object.assign({ format, max: sizes[format], value: result }, data));
         }
         if (result < -sizes[format]) {
-            throw new helpers.RulesError('integer', Object.assign({ format, value: result, min: -sizes[format] }, data));
+            throw new helpers.RulesError('integer', Object.assign({ format, min: -sizes[format], value: result }, data));
         }
         return result;
     };

package/utils/rules/max/max.d.ts

@@ -1 +1 @@
-export declare function max(max: number | bigint): (value: any, data?: object) => any;
+export declare function max(max: bigint | number): (value: any, data?: object) => any;

package/utils/rules/max/max.es6.js

@@ -2,12 +2,12 @@ import { RulesError } from '../helpers.es6.js';
 
 function max(max) {
     return (value, data) => {
-        if (!['number', 'bigint'].includes(typeof value)) {
+        if (!['bigint', 'number'].includes(typeof value)) {
             throw new RulesError('number', Object.assign(Object.assign({}, data), { value }));
         }
         if (value > max) {
-            throw new RulesError('maximum', Object.assign(Object.assign({}, data), { value,
-                max }));
+            throw new RulesError('maximum', Object.assign(Object.assign({}, data), { max,
+                value }));
         }
         return value;
     };

package/utils/rules/max/max.js

@@ -6,12 +6,12 @@ var helpers = require('../helpers.js');
 
 function max(max) {
     return (value, data) => {
-        if (!['number', 'bigint'].includes(typeof value)) {
+        if (!['bigint', 'number'].includes(typeof value)) {
             throw new helpers.RulesError('number', Object.assign(Object.assign({}, data), { value }));
         }
         if (value > max) {
-            throw new helpers.RulesError('maximum', Object.assign(Object.assign({}, data), { value,
-                max }));
+            throw new helpers.RulesError('maximum', Object.assign(Object.assign({}, data), { max,
+                value }));
         }
         return value;
     };

package/utils/rules/maxBin/maxBin.es6.js

@@ -3,8 +3,8 @@ import { RulesError } from '../helpers.es6.js';
 function maxBin(max) {
     return (value, data) => {
         if (value.size > max) {
-            throw new RulesError('maxBin', Object.assign({ value,
-                max }, data));
+            throw new RulesError('maxBin', Object.assign({ max,
+                value }, data));
         }
         return value;
     };

package/utils/rules/maxBin/maxBin.js

@@ -7,8 +7,8 @@ var helpers = require('../helpers.js');
 function maxBin(max) {
     return (value, data) => {
         if (value.size > max) {
-            throw new helpers.RulesError('maxBin', Object.assign({ value,
-                max }, data));
+            throw new helpers.RulesError('maxBin', Object.assign({ max,
+                value }, data));
         }
         return value;
     };

package/utils/rules/maxDate/maxDate.es6.js

@@ -6,7 +6,7 @@ function maxDate(max) {
             throw new RulesError('date', data);
         }
         if (value > max) {
-            throw new RulesError('maxDate', Object.assign(Object.assign({}, data), { value, max: max.toISOString() }));
+            throw new RulesError('maxDate', Object.assign(Object.assign({}, data), { max: max.toISOString(), value }));
         }
         return value;
     };

package/utils/rules/maxDate/maxDate.js

@@ -10,7 +10,7 @@ function maxDate(max) {
             throw new helpers.RulesError('date', data);
         }
         if (value > max) {
-            throw new helpers.RulesError('maxDate', Object.assign(Object.assign({}, data), { value, max: max.toISOString() }));
+            throw new helpers.RulesError('maxDate', Object.assign(Object.assign({}, data), { max: max.toISOString(), value }));
         }
         return value;
     };

package/utils/rules/maxLength/maxLength.es6.js

@@ -6,8 +6,8 @@ function maxLength(max) {
             throw new RulesError('string', data);
         }
         if (value.length > max) {
-            throw new RulesError('maxLength', Object.assign(Object.assign({}, data), { value,
-                max }));
+            throw new RulesError('maxLength', Object.assign(Object.assign({}, data), { max,
+                value }));
         }
         return value;
     };

package/utils/rules/maxLength/maxLength.js

@@ -10,8 +10,8 @@ function maxLength(max) {
             throw new helpers.RulesError('string', data);
         }
         if (value.length > max) {
-            throw new helpers.RulesError('maxLength', Object.assign(Object.assign({}, data), { value,
-                max }));
+            throw new helpers.RulesError('maxLength', Object.assign(Object.assign({}, data), { max,
+                value }));
         }
         return value;
     };

package/utils/rules/min/min.d.ts

@@ -1 +1 @@
-export declare function min(min: number | bigint): (value: any, data?: object) => any;
+export declare function min(min: bigint | number): (value: any, data?: object) => any;

package/utils/rules/min/min.es6.js

@@ -2,12 +2,12 @@ import { RulesError } from '../helpers.es6.js';
 
 function min(min) {
     return (value, data) => {
-        if (!['number', 'bigint'].includes(typeof value)) {
+        if (!['bigint', 'number'].includes(typeof value)) {
             throw new RulesError('number', Object.assign(Object.assign({}, data), { value }));
         }
         if (value < min) {
-            throw new RulesError('minimum', Object.assign(Object.assign({}, data), { value,
-                min }));
+            throw new RulesError('minimum', Object.assign(Object.assign({}, data), { min,
+                value }));
         }
         return value;
     };

package/utils/rules/min/min.js

@@ -6,12 +6,12 @@ var helpers = require('../helpers.js');
 
 function min(min) {
     return (value, data) => {
-        if (!['number', 'bigint'].includes(typeof value)) {
+        if (!['bigint', 'number'].includes(typeof value)) {
             throw new helpers.RulesError('number', Object.assign(Object.assign({}, data), { value }));
         }
         if (value < min) {
-            throw new helpers.RulesError('minimum', Object.assign(Object.assign({}, data), { value,
-                min }));
+            throw new helpers.RulesError('minimum', Object.assign(Object.assign({}, data), { min,
+                value }));
         }
         return value;
     };

package/utils/rules/minBin/minBin.es6.js

@@ -3,8 +3,8 @@ import { RulesError } from '../helpers.es6.js';
 function minBin(min) {
     return (value, data) => {
         if (value.size < min) {
-            throw new RulesError('minBin', Object.assign({ value,
-                min }, data));
+            throw new RulesError('minBin', Object.assign({ min,
+                value }, data));
         }
         return value;
     };