@innet/server 2.0.0-beta.1 → 2.0.0-beta.2

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({ accept,
-            value }, 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({ accept,
-            value }, data));
+        throw new helpers.RulesError('binaryAccept', {
+            accept,
+            value,
+            ...data,
+        });
     };
 }
 

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.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/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, max: sizes[format], value: result }, data));
+            throw new RulesError('integer', {
+                format,
+                max: sizes[format],
+                value: result,
+                ...data,
+            });
         }
         if (result < -sizes[format]) {
-            throw new RulesError('integer', Object.assign({ format, min: -sizes[format], value: result }, 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, max: sizes[format], value: result }, 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, min: -sizes[format], value: result }, data));
+            throw new helpers.RulesError('integer', {
+                format,
+                min: -sizes[format],
+                value: result,
+                ...data,
+            });
         }
         return result;
     };

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

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

package/utils/rules/max/max.js

@@ -7,11 +7,17 @@ var helpers = require('../helpers.js');
 function max(max) {
     return (value, data) => {
         if (!['bigint', 'number'].includes(typeof value)) {
-            throw new helpers.RulesError('number', Object.assign(Object.assign({}, data), { value }));
+            throw new helpers.RulesError('number', {
+                ...data,
+                value,
+            });
         }
         if (value > max) {
-            throw new helpers.RulesError('maximum', Object.assign(Object.assign({}, data), { max,
-                value }));
+            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({ max,
-                value }, data));
+            throw new RulesError('maxBin', {
+                max,
+                value,
+                ...data,
+            });
         }
         return value;
     };

package/utils/rules/maxBin/maxBin.js

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

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

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

package/utils/rules/maxDate/maxDate.js

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

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

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

package/utils/rules/maxLength/maxLength.js

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

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

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

package/utils/rules/min/min.js

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

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

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

package/utils/rules/minBin/minBin.js

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

package/utils/rules/minDate/minDate.es6.js

@@ -6,7 +6,11 @@ function minDate(min) {
             throw new RulesError('date', data);
         }
         if (value < min) {
-            throw new RulesError('minDate', Object.assign(Object.assign({}, data), { min: min.toISOString(), value }));
+            throw new RulesError('minDate', {
+                ...data,
+                min: min.toISOString(),
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minDate/minDate.js

@@ -10,7 +10,11 @@ function minDate(min) {
             throw new helpers.RulesError('date', data);
         }
         if (value < min) {
-            throw new helpers.RulesError('minDate', Object.assign(Object.assign({}, data), { min: min.toISOString(), value }));
+            throw new helpers.RulesError('minDate', {
+                ...data,
+                min: min.toISOString(),
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minLength/minLength.es6.js

@@ -6,8 +6,11 @@ function minLength(min) {
             throw new RulesError('string', data);
         }
         if (value.length < min) {
-            throw new RulesError('minLength', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new RulesError('minLength', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/minLength/minLength.js

@@ -10,8 +10,11 @@ function minLength(min) {
             throw new helpers.RulesError('string', data);
         }
         if (value.length < min) {
-            throw new helpers.RulesError('minLength', Object.assign(Object.assign({}, data), { min,
-                value }));
+            throw new helpers.RulesError('minLength', {
+                ...data,
+                min,
+                value,
+            });
         }
         return value;
     };

package/utils/rules/num/num.es6.js

@@ -3,7 +3,10 @@ import { RulesError } from '../helpers.es6.js';
 function num(value, data) {
     const result = Number(value);
     if (isNaN(result) || result > Number.MAX_SAFE_INTEGER || result < -Number.MAX_SAFE_INTEGER) {
-        throw new RulesError('number', Object.assign({ value }, data));
+        throw new RulesError('number', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

package/utils/rules/num/num.js

@@ -7,7 +7,10 @@ var helpers = require('../helpers.js');
 function num(value, data) {
     const result = Number(value);
     if (isNaN(result) || result > Number.MAX_SAFE_INTEGER || result < -Number.MAX_SAFE_INTEGER) {
-        throw new helpers.RulesError('number', Object.assign({ value }, data));
+        throw new helpers.RulesError('number', {
+            value,
+            ...data,
+        });
     }
     return result;
 }

package/utils/rules/objectOf/objectOf.es6.js

@@ -3,11 +3,14 @@ import { RulesError, addKey } from '../helpers.es6.js';
 function objectOf(map, rest) {
     return (value, data) => {
         if (value === null || typeof value !== 'object') {
-            throw new RulesError('object', Object.assign({ value }, data));
+            throw new RulesError('object', {
+                value,
+                ...data,
+            });
         }
         const result = {};
         for (const key in map) {
-            const val = map[key](value[key], Object.assign(Object.assign({}, data), { key: addKey(key, data) }));
+            const val = map[key](value[key], { ...data, key: addKey(key, data) });
             if (val !== undefined) {
                 result[key] = val;
             }
@@ -16,7 +19,7 @@ function objectOf(map, rest) {
             for (const key in value) {
                 if (key in map)
                     continue;
-                const val = rest(value[key], Object.assign(Object.assign({}, data), { key: addKey(key, data) }));
+                const val = rest(value[key], { ...data, key: addKey(key, data) });
                 if (val !== undefined) {
                     result[key] = val;
                 }