@innet/server 1.7.0 → 2.0.0-alpha.0

package/utils/rules/index.d.ts

@@ -0,0 +1,29 @@
+export * from './helpers';
+export * from './constants';
+export * from './types';
+export * from './num';
+export * from './arrayOf';
+export * from './oneOf';
+export * from './dateTo';
+export * from './int';
+export * from './nullable';
+export * from './objectOf';
+export * from './optional';
+export * from './pattern';
+export * from './required';
+export * from './tupleOf';
+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

@@ -0,0 +1,29 @@
+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 './dateTo/index.es6.js';
+import './int/index.es6.js';
+import './nullable/index.es6.js';
+import './objectOf/index.es6.js';
+import './optional/index.es6.js';
+import './pattern/index.es6.js';
+import './required/index.es6.js';
+import './tupleOf/index.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

@@ -0,0 +1,39 @@
+'use strict';
+
+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('./dateTo/index.js');
+require('./int/index.js');
+require('./nullable/index.js');
+require('./objectOf/index.js');
+require('./optional/index.js');
+require('./pattern/index.js');
+require('./required/index.js');
+require('./tupleOf/index.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.RulesError = helpers.RulesError;
+exports.addKey = helpers.addKey;
+exports.rulesErrors = constants.rulesErrors;

package/utils/rules/int/index.d.ts

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

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

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

package/utils/rules/int/index.js

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

package/utils/rules/int/int.d.ts

@@ -0,0 +1,2 @@
+import { type IntegerFormats } from '../../../types';
+export declare function int(format: IntegerFormats): (value: any, data?: object) => number | bigint;

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

@@ -0,0 +1,36 @@
+import { RulesError } from '../helpers.es6.js';
+
+const sizes = {
+    int32: 2147483647,
+    int64: BigInt('9223372036854775807'),
+};
+function int(format) {
+    const validator = format === 'int32' ? isNaN : (value) => isNaN(parseInt(value));
+    return (value, data) => {
+        let result;
+        if (format === 'int32') {
+            result = Number(value);
+        }
+        else {
+            try {
+                result = BigInt(value);
+            }
+            catch (e) {
+                result = NaN;
+            }
+        }
+        if (validator(result)) {
+            throw new RulesError('integer', Object.assign({ format,
+                value }, data));
+        }
+        if (result > sizes[format]) {
+            throw new RulesError('integer', Object.assign({ format, value: result, max: sizes[format] }, data));
+        }
+        if (result < -sizes[format]) {
+            throw new RulesError('integer', Object.assign({ format, value: result, min: -sizes[format] }, data));
+        }
+        return result;
+    };
+}
+
+export { int };

package/utils/rules/int/int.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+const sizes = {
+    int32: 2147483647,
+    int64: BigInt('9223372036854775807'),
+};
+function int(format) {
+    const validator = format === 'int32' ? isNaN : (value) => isNaN(parseInt(value));
+    return (value, data) => {
+        let result;
+        if (format === 'int32') {
+            result = Number(value);
+        }
+        else {
+            try {
+                result = BigInt(value);
+            }
+            catch (e) {
+                result = NaN;
+            }
+        }
+        if (validator(result)) {
+            throw new helpers.RulesError('integer', Object.assign({ format,
+                value }, data));
+        }
+        if (result > sizes[format]) {
+            throw new helpers.RulesError('integer', Object.assign({ format, value: result, max: sizes[format] }, data));
+        }
+        if (result < -sizes[format]) {
+            throw new helpers.RulesError('integer', Object.assign({ format, value: result, min: -sizes[format] }, data));
+        }
+        return result;
+    };
+}
+
+exports.int = int;

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

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

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

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

package/utils/rules/max/index.js

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

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

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

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

@@ -0,0 +1,16 @@
+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 (value > max) {
+            throw new RulesError('maximum', Object.assign(Object.assign({}, data), { value,
+                max }));
+        }
+        return value;
+    };
+}
+
+export { max };

package/utils/rules/max/max.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 (value > max) {
+            throw new helpers.RulesError('maximum', Object.assign(Object.assign({}, data), { value,
+                max }));
+        }
+        return value;
+    };
+}
+
+exports.max = max;

package/utils/rules/maxBin/index.d.ts

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

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

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

package/utils/rules/maxBin/index.js

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

package/utils/rules/maxBin/maxBin.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function maxBin(max: number): Rule;

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

@@ -0,0 +1,13 @@
+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));
+        }
+        return value;
+    };
+}
+
+export { maxBin };

package/utils/rules/maxBin/maxBin.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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));
+        }
+        return value;
+    };
+}
+
+exports.maxBin = maxBin;

package/utils/rules/maxDate/index.d.ts

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

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

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

package/utils/rules/maxDate/index.js

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

package/utils/rules/maxDate/maxDate.d.ts

@@ -0,0 +1 @@
+export declare function maxDate(max: Date): (value: any, data?: object) => Date;

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

@@ -0,0 +1,15 @@
+import { RulesError } from '../helpers.es6.js';
+
+function maxDate(max) {
+    return (value, data) => {
+        if (!(value instanceof Date)) {
+            throw new RulesError('date', data);
+        }
+        if (value > max) {
+            throw new RulesError('maxDate', Object.assign(Object.assign({}, data), { value, max: max.toISOString() }));
+        }
+        return value;
+    };
+}
+
+export { maxDate };

package/utils/rules/maxDate/maxDate.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function maxDate(max) {
+    return (value, data) => {
+        if (!(value instanceof Date)) {
+            throw new helpers.RulesError('date', data);
+        }
+        if (value > max) {
+            throw new helpers.RulesError('maxDate', Object.assign(Object.assign({}, data), { value, max: max.toISOString() }));
+        }
+        return value;
+    };
+}
+
+exports.maxDate = maxDate;

package/utils/rules/maxLength/index.d.ts

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

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

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

package/utils/rules/maxLength/index.js

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

package/utils/rules/maxLength/maxLength.d.ts

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

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

@@ -0,0 +1,16 @@
+import { RulesError } from '../helpers.es6.js';
+
+function maxLength(max) {
+    return (value, data) => {
+        if (typeof value !== 'string') {
+            throw new RulesError('string', data);
+        }
+        if (value.length > max) {
+            throw new RulesError('maxLength', Object.assign(Object.assign({}, data), { value,
+                max }));
+        }
+        return value;
+    };
+}
+
+export { maxLength };

package/utils/rules/maxLength/maxLength.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function maxLength(max) {
+    return (value, data) => {
+        if (typeof value !== 'string') {
+            throw new helpers.RulesError('string', data);
+        }
+        if (value.length > max) {
+            throw new helpers.RulesError('maxLength', Object.assign(Object.assign({}, data), { value,
+                max }));
+        }
+        return value;
+    };
+}
+
+exports.maxLength = maxLength;

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

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

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

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

package/utils/rules/min/index.js

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

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

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

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

@@ -0,0 +1,16 @@
+import { RulesError } from '../helpers.es6.js';
+
+function min(min) {
+    return (value, data) => {
+        if (!['number', 'bigint'].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 }));
+        }
+        return value;
+    };
+}
+
+export { min };

package/utils/rules/min/min.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function min(min) {
+    return (value, data) => {
+        if (!['number', 'bigint'].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 }));
+        }
+        return value;
+    };
+}
+
+exports.min = min;

package/utils/rules/minBin/index.d.ts

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

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

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

package/utils/rules/minBin/index.js

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

package/utils/rules/minBin/minBin.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function minBin(min: number): Rule;

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

@@ -0,0 +1,13 @@
+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));
+        }
+        return value;
+    };
+}
+
+export { minBin };

package/utils/rules/minBin/minBin.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function minBin(min) {
+    return (value, data) => {
+        if (value.size < min) {
+            throw new helpers.RulesError('minBin', Object.assign({ value,
+                min }, data));
+        }
+        return value;
+    };
+}
+
+exports.minBin = minBin;

package/utils/rules/minDate/index.d.ts

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

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

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

package/utils/rules/minDate/index.js

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

package/utils/rules/minDate/minDate.d.ts

@@ -0,0 +1 @@
+export declare function minDate(min: Date): (value: any, data?: object) => Date;

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

@@ -0,0 +1,15 @@
+import { RulesError } from '../helpers.es6.js';
+
+function minDate(min) {
+    return (value, data) => {
+        if (!(value instanceof Date)) {
+            throw new RulesError('date', data);
+        }
+        if (value < min) {
+            throw new RulesError('minDate', Object.assign(Object.assign({}, data), { value, min: min.toISOString() }));
+        }
+        return value;
+    };
+}
+
+export { minDate };

package/utils/rules/minDate/minDate.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function minDate(min) {
+    return (value, data) => {
+        if (!(value instanceof Date)) {
+            throw new helpers.RulesError('date', data);
+        }
+        if (value < min) {
+            throw new helpers.RulesError('minDate', Object.assign(Object.assign({}, data), { value, min: min.toISOString() }));
+        }
+        return value;
+    };
+}
+
+exports.minDate = minDate;

package/utils/rules/minLength/index.d.ts

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

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

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

package/utils/rules/minLength/index.js

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

package/utils/rules/minLength/minLength.d.ts

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

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

@@ -0,0 +1,16 @@
+import { RulesError } from '../helpers.es6.js';
+
+function minLength(min) {
+    return (value, data) => {
+        if (typeof value !== 'string') {
+            throw new RulesError('string', data);
+        }
+        if (value.length < min) {
+            throw new RulesError('minLength', Object.assign(Object.assign({}, data), { value,
+                min }));
+        }
+        return value;
+    };
+}
+
+export { minLength };