@innet/server 1.7.1 → 2.0.0-alpha.0

package/utils/rules/minLength/minLength.js

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

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

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

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

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

package/utils/rules/nullable/index.js

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

package/utils/rules/nullable/nullable.d.ts

@@ -0,0 +1 @@
+export declare function nullable(value: any, data?: object): null;

package/utils/rules/nullable/nullable.es6.js

@@ -0,0 +1,10 @@
+import { RulesError } from '../helpers.es6.js';
+
+function nullable(value, data) {
+    if (value !== null) {
+        throw new RulesError('null', data);
+    }
+    return null;
+}
+
+export { nullable };

package/utils/rules/nullable/nullable.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function nullable(value, data) {
+    if (value !== null) {
+        throw new helpers.RulesError('null', data);
+    }
+    return null;
+}
+
+exports.nullable = nullable;

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

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

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

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

package/utils/rules/num/index.js

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

package/utils/rules/num/num.d.ts

@@ -0,0 +1 @@
+export declare function num(value: any, data?: object): number;

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

@@ -0,0 +1,11 @@
+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));
+    }
+    return result;
+}
+
+export { num };

package/utils/rules/num/num.js

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

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

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

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

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

package/utils/rules/objectOf/index.js

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

package/utils/rules/objectOf/objectOf.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from '../types';
+export type ObjectOf = Record<string, Rule>;
+export declare function objectOf(map: ObjectOf): (value: any, data?: Record<string, any>) => any;

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

@@ -0,0 +1,16 @@
+import { RulesError, addKey } from '../helpers.es6.js';
+
+function objectOf(map) {
+    return (value, data) => {
+        if (value === null || typeof value !== 'object') {
+            throw new RulesError('object', Object.assign({ value }, data));
+        }
+        const result = {};
+        for (const key in map) {
+            result[key] = map[key](value[key], Object.assign(Object.assign({}, data), { key: addKey(key, data) }));
+        }
+        return result;
+    };
+}
+
+export { objectOf };

package/utils/rules/objectOf/objectOf.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function objectOf(map) {
+    return (value, data) => {
+        if (value === null || typeof value !== 'object') {
+            throw new helpers.RulesError('object', Object.assign({ value }, data));
+        }
+        const result = {};
+        for (const key in map) {
+            result[key] = map[key](value[key], Object.assign(Object.assign({}, data), { key: helpers.addKey(key, data) }));
+        }
+        return result;
+    };
+}
+
+exports.objectOf = objectOf;

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

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

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

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

package/utils/rules/oneOf/index.js

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

package/utils/rules/oneOf/oneOf.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function oneOf(formatters: Rule[]): (value: any, data?: object) => any;

package/utils/rules/oneOf/oneOf.es6.js

@@ -0,0 +1,18 @@
+import { RulesError } from '../helpers.es6.js';
+
+function oneOf(formatters) {
+    return (value, data) => {
+        const errors = [];
+        for (const formatter of formatters) {
+            try {
+                return formatter(value, data);
+            }
+            catch (e) {
+                errors.push(e.data);
+            }
+        }
+        throw new RulesError('oneOf', { errors });
+    };
+}
+
+export { oneOf };

package/utils/rules/oneOf/oneOf.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function oneOf(formatters) {
+    return (value, data) => {
+        const errors = [];
+        for (const formatter of formatters) {
+            try {
+                return formatter(value, data);
+            }
+            catch (e) {
+                errors.push(e.data);
+            }
+        }
+        throw new helpers.RulesError('oneOf', { errors });
+    };
+}
+
+exports.oneOf = oneOf;

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

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

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

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

package/utils/rules/optional/index.js

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

package/utils/rules/optional/optional.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function optional(rule: Rule): (value: any, data?: object) => any;

package/utils/rules/optional/optional.es6.js

@@ -0,0 +1,9 @@
+function optional(rule) {
+    return (value, data) => {
+        if (value === undefined)
+            return;
+        return rule(value, data);
+    };
+}
+
+export { optional };

package/utils/rules/optional/optional.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function optional(rule) {
+    return (value, data) => {
+        if (value === undefined)
+            return;
+        return rule(value, data);
+    };
+}
+
+exports.optional = optional;

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

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

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

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

package/utils/rules/pattern/index.js

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

package/utils/rules/pattern/pattern.d.ts

@@ -0,0 +1 @@
+export declare function pattern(pattern: string | RegExp, patternId?: string): (value: any, data?: object) => any;

package/utils/rules/pattern/pattern.es6.js

@@ -0,0 +1,13 @@
+import { RulesError } from '../helpers.es6.js';
+
+function pattern(pattern, patternId = String(pattern)) {
+    const normPattern = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    return (value, data) => {
+        if (!normPattern.test(value)) {
+            throw new RulesError('pattern', Object.assign({ value, pattern: String(normPattern), patternId }, data));
+        }
+        return value;
+    };
+}
+
+export { pattern };

package/utils/rules/pattern/pattern.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function pattern(pattern, patternId = String(pattern)) {
+    const normPattern = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    return (value, data) => {
+        if (!normPattern.test(value)) {
+            throw new helpers.RulesError('pattern', Object.assign({ value, pattern: String(normPattern), patternId }, data));
+        }
+        return value;
+    };
+}
+
+exports.pattern = pattern;

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

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

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

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

package/utils/rules/pipe/index.js

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

package/utils/rules/pipe/pipe.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function pipe(...rules: Rule[]): Rule;

package/utils/rules/pipe/pipe.es6.js

@@ -0,0 +1,7 @@
+function pipe(...rules) {
+    return (value, data) => {
+        return rules.reduce((value, rule) => rule(value, data), value);
+    };
+}
+
+export { pipe };

package/utils/rules/pipe/pipe.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function pipe(...rules) {
+    return (value, data) => {
+        return rules.reduce((value, rule) => rule(value, data), value);
+    };
+}
+
+exports.pipe = pipe;

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

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

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

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

package/utils/rules/required/index.js

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

package/utils/rules/required/required.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function required(rule?: Rule): (value: any, data?: object) => any;

package/utils/rules/required/required.es6.js

@@ -0,0 +1,12 @@
+import { RulesError } from '../helpers.es6.js';
+
+function required(rule) {
+    return (value, data) => {
+        if (value === undefined) {
+            throw new RulesError('required', data);
+        }
+        return rule === null || rule === void 0 ? void 0 : rule(value, data);
+    };
+}
+
+export { required };

package/utils/rules/required/required.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function required(rule) {
+    return (value, data) => {
+        if (value === undefined) {
+            throw new helpers.RulesError('required', data);
+        }
+        return rule === null || rule === void 0 ? void 0 : rule(value, data);
+    };
+}
+
+exports.required = required;

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

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

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

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

package/utils/rules/tupleOf/index.js

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

package/utils/rules/tupleOf/tupleOf.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../types';
+export declare function tupleOf(rules: Rule[]): (value: any, data?: object) => any[];

package/utils/rules/tupleOf/tupleOf.es6.js

@@ -0,0 +1,19 @@
+import { RulesError, addKey } from '../helpers.es6.js';
+
+function tupleOf(rules) {
+    return (value, data) => {
+        if (value === undefined) {
+            throw new RulesError('tuple', data);
+        }
+        else if (!Array.isArray(value)) {
+            value = [value];
+        }
+        const result = [];
+        for (let index = 0; index < rules.length; index++) {
+            result.push(rules[index](value[index], Object.assign(Object.assign({}, data), { key: addKey(index, data) })));
+        }
+        return result;
+    };
+}
+
+export { tupleOf };

package/utils/rules/tupleOf/tupleOf.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+function tupleOf(rules) {
+    return (value, data) => {
+        if (value === undefined) {
+            throw new helpers.RulesError('tuple', data);
+        }
+        else if (!Array.isArray(value)) {
+            value = [value];
+        }
+        const result = [];
+        for (let index = 0; index < rules.length; index++) {
+            result.push(rules[index](value[index], Object.assign(Object.assign({}, data), { key: helpers.addKey(index, data) })));
+        }
+        return result;
+    };
+}
+
+exports.tupleOf = tupleOf;

package/utils/rules/types.d.ts

@@ -0,0 +1,4 @@
+import { type rulesErrors } from './constants';
+export type Rule = (value: any, data?: object) => any;
+export type SetRule = (rule: Rule) => Rule;
+export type RulesErrors = typeof rulesErrors[number];

package/utils/rules/types.es6.js

@@ -0,0 +1 @@
+

package/utils/rules/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

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

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

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

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

package/utils/rules/uuidTo/index.js

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

package/utils/rules/uuidTo/uuidTo.d.ts

@@ -0,0 +1 @@
+export declare function uuidTo(value: any, data?: object): any;

package/utils/rules/uuidTo/uuidTo.es6.js

@@ -0,0 +1,11 @@
+import { RulesError } from '../helpers.es6.js';
+
+const UUID_REG = /^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/;
+function uuidTo(value, data) {
+    if (!UUID_REG.test(value)) {
+        throw new RulesError('uuid', data);
+    }
+    return value;
+}
+
+export { uuidTo };

package/utils/rules/uuidTo/uuidTo.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('../helpers.js');
+
+const UUID_REG = /^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/;
+function uuidTo(value, data) {
+    if (!UUID_REG.test(value)) {
+        throw new helpers.RulesError('uuid', data);
+    }
+    return value;
+}
+
+exports.uuidTo = uuidTo;

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

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

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

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

package/utils/rules/values/index.js

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

package/utils/rules/values/values.d.ts

@@ -0,0 +1 @@
+export declare function values(values: any[]): (value: any, data?: object) => any;

package/utils/rules/values/values.es6.js

@@ -0,0 +1,13 @@
+import { RulesError } from '../helpers.es6.js';
+
+function values(values) {
+    return (value, data) => {
+        if (!values.includes(value)) {
+            throw new RulesError('values', Object.assign(Object.assign({}, data), { value,
+                values }));
+        }
+        return value;
+    };
+}
+
+export { values };

package/utils/rules/values/values.js

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

package/utils/stringifySearch/index.d.ts

@@ -1 +1 @@
-export * from './stringifySearch';
+export * from './stringifySearch';

package/utils/stringifySearch/stringifySearch.d.ts

@@ -1,2 +1,2 @@
-import { IStringifyOptions, ParsedQs } from 'qs';
-export declare function stringifySearch(search: ParsedQs, options?: IStringifyOptions): string;
+import { type IStringifyOptions, type ParsedQs } from 'qs';
+export declare function stringifySearch(search: ParsedQs, options?: IStringifyOptions): string;