@innet/server 2.0.0-alpha.9 → 2.0.0-beta.10

package/utils/parseFormBody/parseFormBody.es6.js

@@ -1,54 +1,54 @@
-import { __awaiter, __rest } from 'tslib';
 import { Form } from 'multiparty';
 import '../FileData/index.es6.js';
 import '../parseSearch/index.es6.js';
 import { Bin } from '../FileData/Bin.es6.js';
 import { parseSearch } from '../parseSearch/parseSearch.es6.js';
 
-function parseFormBody(req) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield new Promise((resolve, reject) => {
-            const form = new Form();
-            form.parse(req, (error, fields, files) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                let query = '';
-                const queryFiles = [];
-                for (const key in fields) {
-                    for (const value of fields[key]) {
-                        if (query) {
-                            query += '&';
-                        }
-                        query += `${key}=${value.replaceAll('=', '%26')}`;
+async function parseFormBody(req) {
+    return await new Promise((resolve, reject) => {
+        const form = new Form();
+        form.parse(req, (error, fields, files) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            let query = '';
+            const queryFiles = [];
+            for (const key in fields) {
+                for (const value of fields[key]) {
+                    if (query) {
+                        query += '&';
                     }
+                    query += `${key}=${value.replaceAll('=', '%26')}`;
                 }
-                for (const key in files) {
-                    const values = files[key];
-                    for (const value of values) {
-                        if (query) {
-                            query += '&';
-                        }
-                        query += `${key}==${queryFiles.length}`;
-                        const { headers } = value, options = __rest(value, ["headers"]);
-                        options.type = headers['content-type'];
-                        options.disposition = headers['content-disposition'];
-                        queryFiles.push(new Bin(options));
+            }
+            for (const key in files) {
+                const values = files[key];
+                for (const value of values) {
+                    if (query) {
+                        query += '&';
                     }
+                    query += `${key}==${queryFiles.length}`;
+                    const { headers, ...options } = value;
+                    const binOptions = {
+                        ...options,
+                        disposition: headers['content-disposition'],
+                        type: headers['content-type'],
+                    };
+                    queryFiles.push(new Bin(binOptions));
                 }
-                resolve(parseSearch(query, {
-                    decoder(value, decoder, charset, type) {
-                        if (type === 'key') {
-                            return decoder(value, decoder, charset);
-                        }
-                        if (value.startsWith('=')) {
-                            return queryFiles[Number(value.slice(1))];
-                        }
-                        return value.replaceAll('%26', '=');
-                    },
-                }));
-            });
+            }
+            resolve(parseSearch(query, {
+                decoder(value, decoder, charset, type) {
+                    if (type === 'key') {
+                        return decoder(value, decoder, charset);
+                    }
+                    if (value.startsWith('=')) {
+                        return queryFiles[Number(value.slice(1))];
+                    }
+                    return value.replaceAll('%26', '=');
+                },
+            }));
         });
     });
 }

package/utils/parseFormBody/parseFormBody.js

@@ -2,57 +2,57 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var multiparty = require('multiparty');
 require('../FileData/index.js');
 require('../parseSearch/index.js');
 var Bin = require('../FileData/Bin.js');
 var parseSearch = require('../parseSearch/parseSearch.js');
 
-function parseFormBody(req) {
-    return tslib.__awaiter(this, void 0, void 0, function* () {
-        return yield new Promise((resolve, reject) => {
-            const form = new multiparty.Form();
-            form.parse(req, (error, fields, files) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                let query = '';
-                const queryFiles = [];
-                for (const key in fields) {
-                    for (const value of fields[key]) {
-                        if (query) {
-                            query += '&';
-                        }
-                        query += `${key}=${value.replaceAll('=', '%26')}`;
+async function parseFormBody(req) {
+    return await new Promise((resolve, reject) => {
+        const form = new multiparty.Form();
+        form.parse(req, (error, fields, files) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            let query = '';
+            const queryFiles = [];
+            for (const key in fields) {
+                for (const value of fields[key]) {
+                    if (query) {
+                        query += '&';
                     }
+                    query += `${key}=${value.replaceAll('=', '%26')}`;
                 }
-                for (const key in files) {
-                    const values = files[key];
-                    for (const value of values) {
-                        if (query) {
-                            query += '&';
-                        }
-                        query += `${key}==${queryFiles.length}`;
-                        const { headers } = value, options = tslib.__rest(value, ["headers"]);
-                        options.type = headers['content-type'];
-                        options.disposition = headers['content-disposition'];
-                        queryFiles.push(new Bin.Bin(options));
+            }
+            for (const key in files) {
+                const values = files[key];
+                for (const value of values) {
+                    if (query) {
+                        query += '&';
                     }
+                    query += `${key}==${queryFiles.length}`;
+                    const { headers, ...options } = value;
+                    const binOptions = {
+                        ...options,
+                        disposition: headers['content-disposition'],
+                        type: headers['content-type'],
+                    };
+                    queryFiles.push(new Bin.Bin(binOptions));
                 }
-                resolve(parseSearch.parseSearch(query, {
-                    decoder(value, decoder, charset, type) {
-                        if (type === 'key') {
-                            return decoder(value, decoder, charset);
-                        }
-                        if (value.startsWith('=')) {
-                            return queryFiles[Number(value.slice(1))];
-                        }
-                        return value.replaceAll('%26', '=');
-                    },
-                }));
-            });
+            }
+            resolve(parseSearch.parseSearch(query, {
+                decoder(value, decoder, charset, type) {
+                    if (type === 'key') {
+                        return decoder(value, decoder, charset);
+                    }
+                    if (value.startsWith('=')) {
+                        return queryFiles[Number(value.slice(1))];
+                    }
+                    return value.replaceAll('%26', '=');
+                },
+            }));
         });
     });
 }

package/utils/parseSearch/parseSearch.es6.js

@@ -4,7 +4,10 @@ const EMPTY_SEARCH = {};
 function parseSearch(search, options) {
     if (!search)
         return EMPTY_SEARCH;
-    return qs.parse(search, Object.assign({ ignoreQueryPrefix: true }, options));
+    return qs.parse(search, {
+        ignoreQueryPrefix: true,
+        ...options,
+    });
 }
 
 export { EMPTY_SEARCH, parseSearch };

package/utils/parseSearch/parseSearch.js

@@ -12,7 +12,10 @@ const EMPTY_SEARCH = {};
 function parseSearch(search, options) {
     if (!search)
         return EMPTY_SEARCH;
-    return qs__default["default"].parse(search, Object.assign({ ignoreQueryPrefix: true }, options));
+    return qs__default["default"].parse(search, {
+        ignoreQueryPrefix: true,
+        ...options,
+    });
 }
 
 exports.EMPTY_SEARCH = EMPTY_SEARCH;

package/utils/rules/arrayOf/arrayOf.es6.js

@@ -8,7 +8,7 @@ function arrayOf(formatter) {
         else if (!Array.isArray(value)) {
             value = [value];
         }
-        return value.map((val, index) => formatter(val, Object.assign(Object.assign({}, data), { key: addKey(index, data) })));
+        return value.map((val, index) => formatter(val, { ...data, key: addKey(index, data) }));
     };
 }
 

package/utils/rules/arrayOf/arrayOf.js

@@ -12,7 +12,7 @@ function arrayOf(formatter) {
         else if (!Array.isArray(value)) {
             value = [value];
         }
-        return value.map((val, index) => formatter(val, Object.assign(Object.assign({}, data), { key: helpers.addKey(index, data) })));
+        return value.map((val, index) => formatter(val, { ...data, key: helpers.addKey(index, data) }));
     };
 }
 

package/utils/rules/bin/bin.es6.js

@@ -4,7 +4,10 @@ import { Bin } from '../../FileData/Bin.es6.js';
 
 function bin(value, data) {
     if (!(value instanceof Bin)) {
-        throw new RulesError('binary', Object.assign({ value }, data));
+        throw new RulesError('binary', {
+            value,
+            ...data,
+        });
     }
     return value;
 }

package/utils/rules/bin/bin.js

@@ -8,7 +8,10 @@ var Bin = require('../../FileData/Bin.js');
 
 function bin(value, data) {
     if (!(value instanceof Bin.Bin)) {
-        throw new helpers.RulesError('binary', Object.assign({ value }, data));
+        throw new helpers.RulesError('binary', {
+            value,
+            ...data,
+        });
     }
     return value;
 }

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

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

package/utils/rules/binaryAccept/binaryAccept.js

@@ -28,8 +28,11 @@ function binaryAccept(accept) {
                 continue;
             return value;
         }
-        throw new helpers.RulesError('binaryAccept', Object.assign({ value,
-            accept }, data));
+        throw new helpers.RulesError('binaryAccept', {
+            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/dateTo/dateTo.es6.js

@@ -3,7 +3,10 @@ import { RulesError } from '../helpers.es6.js';
 function dateTo(value, data) {
     const result = new Date(value);
     if (isNaN(result)) {
-        throw new RulesError('date', Object.assign({ value }, data));
+        throw new RulesError('date', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

package/utils/rules/dateTo/dateTo.js

@@ -7,7 +7,10 @@ var helpers = require('../helpers.js');
 function dateTo(value, data) {
     const result = new Date(value);
     if (isNaN(result)) {
-        throw new helpers.RulesError('date', Object.assign({ value }, data));
+        throw new helpers.RulesError('date', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

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/helpers.es6.js

@@ -1,7 +1,10 @@
 class RulesError extends Error {
     constructor(error, data) {
         super(`Validation Error: ${error}`);
-        this.data = Object.assign({ error }, data);
+        this.data = {
+            error,
+            ...data,
+        };
     }
 }
 function addKey(key, data) {

package/utils/rules/helpers.js

@@ -5,7 +5,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 class RulesError extends Error {
     constructor(error, data) {
         super(`Validation Error: ${error}`);
-        this.data = Object.assign({ error }, data);
+        this.data = {
+            error,
+            ...data,
+        };
     }
 }
 function addKey(key, data) {

package/utils/rules/index.d.ts

@@ -1,29 +1,28 @@
-export * from './helpers';
-export * from './constants';
-export * from './types';
-export * from './num';
 export * from './arrayOf';
-export * from './oneOf';
+export * from './bin';
+export * from './binaryAccept';
+export * from './constants';
 export * from './dateTo';
+export * from './defaultTo';
+export * from './helpers';
 export * from './int';
+export * from './max';
+export * from './maxBin';
+export * from './maxDate';
+export * from './maxLength';
+export * from './min';
+export * from './minBin';
+export * from './minDate';
+export * from './minLength';
 export * from './nullable';
+export * from './num';
 export * from './objectOf';
+export * from './oneOf';
 export * from './optional';
 export * from './pattern';
+export * from './pipe';
 export * from './required';
 export * from './tupleOf';
+export * from './types';
 export * from './uuidTo';
 export * from './values';
-export * from './pipe';
-export * from './maxDate';
-export * from './minDate';
-export * from './maxLength';
-export * from './minLength';
-export * from './max';
-export * from './min';
-export * from './defaultTo';
-export * from './any';
-export * from './bin';
-export * from './minBin';
-export * from './maxBin';
-export * from './binaryAccept';

package/utils/rules/index.es6.js

@@ -1,29 +1,28 @@
-export { RulesError, addKey } from './helpers.es6.js';
-export { rulesErrors } from './constants.es6.js';
-import './types.es6.js';
-import './num/index.es6.js';
 import './arrayOf/index.es6.js';
-import './oneOf/index.es6.js';
+import './bin/index.es6.js';
+import './binaryAccept/index.es6.js';
+export { rulesErrors } from './constants.es6.js';
 import './dateTo/index.es6.js';
+import './defaultTo/index.es6.js';
+export { RulesError, addKey } from './helpers.es6.js';
 import './int/index.es6.js';
+import './max/index.es6.js';
+import './maxBin/index.es6.js';
+import './maxDate/index.es6.js';
+import './maxLength/index.es6.js';
+import './min/index.es6.js';
+import './minBin/index.es6.js';
+import './minDate/index.es6.js';
+import './minLength/index.es6.js';
 import './nullable/index.es6.js';
+import './num/index.es6.js';
 import './objectOf/index.es6.js';
+import './oneOf/index.es6.js';
 import './optional/index.es6.js';
 import './pattern/index.es6.js';
+import './pipe/index.es6.js';
 import './required/index.es6.js';
 import './tupleOf/index.es6.js';
+import './types.es6.js';
 import './uuidTo/index.es6.js';
 import './values/index.es6.js';
-import './pipe/index.es6.js';
-import './maxDate/index.es6.js';
-import './minDate/index.es6.js';
-import './maxLength/index.es6.js';
-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';
-import './binaryAccept/index.es6.js';

package/utils/rules/index.js

@@ -2,38 +2,37 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var helpers = require('./helpers.js');
-var constants = require('./constants.js');
-require('./types.js');
-require('./num/index.js');
 require('./arrayOf/index.js');
-require('./oneOf/index.js');
+require('./bin/index.js');
+require('./binaryAccept/index.js');
+var constants = require('./constants.js');
 require('./dateTo/index.js');
+require('./defaultTo/index.js');
+var helpers = require('./helpers.js');
 require('./int/index.js');
+require('./max/index.js');
+require('./maxBin/index.js');
+require('./maxDate/index.js');
+require('./maxLength/index.js');
+require('./min/index.js');
+require('./minBin/index.js');
+require('./minDate/index.js');
+require('./minLength/index.js');
 require('./nullable/index.js');
+require('./num/index.js');
 require('./objectOf/index.js');
+require('./oneOf/index.js');
 require('./optional/index.js');
 require('./pattern/index.js');
+require('./pipe/index.js');
 require('./required/index.js');
 require('./tupleOf/index.js');
+require('./types.js');
 require('./uuidTo/index.js');
 require('./values/index.js');
-require('./pipe/index.js');
-require('./maxDate/index.js');
-require('./minDate/index.js');
-require('./maxLength/index.js');
-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');
-require('./binaryAccept/index.js');
 
 
 
+exports.rulesErrors = constants.rulesErrors;
 exports.RulesError = helpers.RulesError;
 exports.addKey = helpers.addKey;
-exports.rulesErrors = constants.rulesErrors;

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

@@ -20,14 +20,27 @@ function int(format) {
             }
         }
         if (validator(result)) {
-            throw new RulesError('integer', Object.assign({ format,
-                value }, data));
+            throw new RulesError('integer', {
+                format,
+                value,
+                ...data,
+            });
         }
         if (result > sizes[format]) {
-            throw new RulesError('integer', Object.assign({ format, value: result, max: sizes[format] }, data));
+            throw new RulesError('integer', {
+                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', {
+                format,
+                min: -sizes[format],
+                value: result,
+                ...data,
+            });
         }
         return result;
     };

package/utils/rules/int/int.js

@@ -24,14 +24,27 @@ function int(format) {
             }
         }
         if (validator(result)) {
-            throw new helpers.RulesError('integer', Object.assign({ format,
-                value }, data));
+            throw new helpers.RulesError('integer', {
+                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', {
+                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', {
+                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,18 @@ import { RulesError } from '../helpers.es6.js';
 
 function max(max) {
     return (value, data) => {
-        if (!['number', 'bigint'].includes(typeof value)) {
-            throw new RulesError('number', Object.assign(Object.assign({}, data), { value }));
+        if (!['bigint', 'number'].includes(typeof value)) {
+            throw new RulesError('number', {
+                ...data,
+                value,
+            });
         }
         if (value > max) {
-            throw new RulesError('maximum', Object.assign(Object.assign({}, data), { value,
-                max }));
+            throw new RulesError('maximum', {
+                ...data,
+                max,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/max/max.js

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

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

@@ -3,8 +3,11 @@ 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', {
+                max,
+                value,
+                ...data,
+            });
         }
         return value;
     };