valgen 3.2.1 → 4.0.0-alpha.3

package/esm/rules/range.js

@@ -0,0 +1,81 @@
+import { validator } from '../core/index.js';
+export function isGt(minValue, options) {
+    return validator('isGt', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input > minValue)
+            return input;
+        if (minValue instanceof Date && input instanceof Date && input > minValue)
+            return input;
+        if (typeof minValue === 'string' && typeof input === 'string' &&
+            (input > minValue ||
+                (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+    }, options);
+}
+export function isGte(minValue, options) {
+    return validator('isGte', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue)
+            return input;
+        if (minValue instanceof Date && input instanceof Date && input >= minValue)
+            return input;
+        if (typeof minValue === 'string' && typeof input === 'string' &&
+            (input >= minValue ||
+                (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+    }, options);
+}
+export function isLt(maxValue, options) {
+    return validator('isLt', function (input, context) {
+        if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input < maxValue)
+            return input;
+        if (maxValue instanceof Date && input instanceof Date && input < maxValue)
+            return input;
+        if (typeof maxValue === 'string' && typeof input === 'string' &&
+            (input < maxValue ||
+                (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+    }, options);
+}
+export function isLte(maxValue, options) {
+    return validator('isLt', function (input, context) {
+        if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input <= maxValue)
+            return input;
+        if (maxValue instanceof Date && input instanceof Date && input <= maxValue)
+            return input;
+        if (typeof maxValue === 'string' && typeof input === 'string' &&
+            (input <= maxValue ||
+                (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+    }, options);
+}
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+export function range(minValue, maxValue, options) {
+    return validator('range', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue && input <= maxValue)
+            return input;
+        if (minValue instanceof Date && maxValue instanceof Date &&
+            input instanceof Date && input >= minValue && input <= maxValue)
+            return input;
+        if (typeof minValue === 'string' && typeof maxValue === 'string' &&
+            typeof input === 'string' && input >= minValue && input <= maxValue)
+            return input;
+        context.failure(`{{label}} must be between ${minValue} and ${maxValue}`);
+    }, options);
+}

package/esm/rules/string-formats.js

@@ -0,0 +1,266 @@
+import validatorJS from 'validator';
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is an "UUID".
+ * @validator isUUID
+ */
+export function isUUID(version, options) {
+    return validator('isUUID', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isUUID(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid UUID${version ? ' v' + version : ''}`);
+    }, options);
+}
+/**
+ * Validates if value is a valid Email
+ * @validator isEmail
+ */
+export function isEmail(options) {
+    return validator('isEmail', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isEmail(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid a EMail`);
+    }, options);
+}
+/**
+ * Validates if value is a valid Email
+ * @validator isMobilePhone
+ */
+export function isMobilePhone(options) {
+    return validator('isMobilePhone', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isMobilePhone(input, options?.locale, options))
+            return input;
+        context.failure(`{{label}} is not a valid a Mobile Phone Number`);
+    }, options);
+}
+/**
+ * Validates if value is an IP
+ * @validator isIP
+ */
+export function isIP(version, options) {
+    return validator('isIP', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isIP(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid IP${version ? ' v' + version : ''}`);
+    }, options);
+}
+/**
+ * Validates if value is an IP
+ * @validator isUUID
+ */
+export function isIPRange(version, options) {
+    return validator('isIPRange', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isIPRange(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid IP${version ? ' v' + version : ''} range`);
+    }, options);
+}
+/**
+ * Validates if value is an MACAddress
+ * @validator isMACAddress
+ */
+export function isMACAddress(options) {
+    return validator('isMACAddress', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isMACAddress(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid MAC address`);
+    }, options);
+}
+/**
+ * Validates if value is a port number
+ * @validator isPort
+ */
+export function isPort(options) {
+    return validator('isPort', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isPort(input))
+            return input;
+        context.failure(`{{label}} is not a valid port number`);
+    }, options);
+}
+/**
+ * Validates if value is an MACAddress
+ * @validator isURL
+ */
+export function isURL(options) {
+    return validator('isURL', function (input, context) {
+        if (input != null && typeof input === 'string' && validatorJS.isURL(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid URL`);
+    }, options);
+}
+/**
+ * Validates if value is a "Base64" string.
+ * @validator isBase64
+ */
+export function isBase64(options) {
+    return validator('isBase64', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isBase64(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid a Base64 string`);
+    }, options);
+}
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isBIC
+ */
+export function isBIC(options) {
+    return validator('isBIC', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isBIC(input))
+            return input;
+        context.failure(`{{label}}is not a valid a BIC (Bank Identification Code) or SWIFT code`);
+    }, options);
+}
+/**
+ * Validates if value is a "Base64" formatted string.
+ * @validator isCreditCard
+ */
+export function isCreditCard(options) {
+    return validator('isCreditCard', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isCreditCard(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid Credit Card number`);
+    }, options);
+}
+/**
+ * Validates if value is an IBAN (International Bank Account Number)
+ * @validator isEAN
+ */
+export function isIBAN(options) {
+    return validator('isIBAN', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isIBAN(input))
+            return input;
+        context.failure(`{{label}} is not a valid IBAN (International Bank Account Number)`);
+    }, options);
+}
+/**
+ * Validates if value is an passport number
+ * @validator isPassportNumber
+ */
+export function isPassportNumber(countryCode, options) {
+    return validator('isPassportNumber', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isPassportNumber(input, countryCode))
+            return input;
+        context.failure(`{{label}} is not a valid ${countryCode} PassportNumber)`);
+    }, options);
+}
+/**
+ * Validates if value is an EAN (European Article Number)
+ * @validator isEAN
+ */
+export function isEAN(options) {
+    return validator('isEAN', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isEAN(input))
+            return input;
+        context.failure(`{{label}} is not a valid EAN (European Article Number)`);
+    }, options);
+}
+/**
+ * Validates if value is an FQDN
+ * @validator isFQDN
+ */
+export function isFQDN(options) {
+    return validator('isFQDN', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isFQDN(input, options))
+            return input;
+        context.failure(`{{label}} is not valid FQDN`);
+    }, options);
+}
+/**
+ * Validates if value is an ISSN
+ * @validator isISSN
+ */
+export function isISSN(options) {
+    return validator('isISSN', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isISSN(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid ISSN`);
+    }, options);
+}
+/**
+ * Validates if value is an VAT number
+ * @validator isVAT
+ */
+export function isVAT(countryCode, options) {
+    return validator('isVAT', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isVAT(input, countryCode))
+            return input;
+        context.failure(`{{label}} is not a valid VAT number`);
+    }, options);
+}
+/**
+ * Validates if value is a BTC address.
+ * @validator isBtcAddress
+ */
+export function isBtcAddress(options) {
+    return validator('isBtcAddress', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isBtcAddress(input))
+            return input;
+        context.failure(`{{label}} is not a valid a BTC address`);
+    }, options);
+}
+/**
+ * Validates if value is a ETH (Ethereum) address.
+ * @validator isBtcAddress
+ */
+export function isETHAddress(options) {
+    return validator('isETHAddress', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isEthereumAddress(input))
+            return input;
+        context.failure(`{{label}} is not a valid a ETH (Ethereum) address`);
+    }, options);
+}
+/**
+ * Validates if value a hash of type algorithm
+ * @validator isHash
+ */
+export function isHash(algorithm, options) {
+    return validator('isHash', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isHash(input, algorithm))
+            return input;
+        context.failure(`{{label}} is not a valid ${algorithm} hash`);
+    }, options);
+}
+/**
+ * Validates if value is a Hex Color
+ * @validator isHexColor
+ */
+export function isHexColor(options) {
+    return validator('isHexColor', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isHexColor(input))
+            return input;
+        context.failure(`{{label}} is not a valid Hex Color`);
+    }, options);
+}
+/**
+ * Validates if value a valid JWT token
+ * @validator isHash
+ */
+export function isJWT(options) {
+    return validator('isJWT', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isJWT(input))
+            return input;
+        context.failure(`{{label}} is not a valid JWT token`);
+    }, options);
+}
+/**
+ * Validates if value a Lowercase string
+ * @validator isLowercase
+ */
+export function isLowercase(options) {
+    return validator('isLowercase', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isLowercase(input))
+            return input;
+        context.failure(`{{label}} is not a lowercase string`);
+    }, options);
+}
+/**
+ * Validates if value a Uppercase string
+ * @validator isUppercase
+ */
+export function isUppercase(options) {
+    return validator('isLowercase', function (input, context) {
+        if (typeof input === 'string' && validatorJS.isUppercase(input))
+            return input;
+        context.failure(`{{label}} is not an uppercase string`);
+    }, options);
+}

package/esm/rules/union.js

@@ -0,0 +1,27 @@
+import { validator } from '../core/index.js';
+/**
+ *
+ */
+export function union(codecs) {
+    const l = codecs.length;
+    return validator('union', function (input, context) {
+        let i;
+        let c;
+        let v;
+        let passed = false;
+        for (i = 0; i < l; i++) {
+            c = codecs[i];
+            try {
+                v = c(input, context);
+                passed = true;
+                break;
+            }
+            catch (e) {
+                //
+            }
+        }
+        if (passed)
+            return v;
+        context.failure(`{{location}} didn't match any of required format`);
+    });
+}

package/esm/rules/utilities.js

@@ -0,0 +1,26 @@
+import { isValidator, kValidatorFn, validator } from '../core/index.js';
+/**
+ * Forwards codec process to a sub codec. Useful for circular checks
+ * @validator forwardRef
+ */
+export function forwardRef(fn) {
+    return validator('forwardRef', function (input, context) {
+        const nested = fn(context);
+        return nested[kValidatorFn](input, context, nested);
+    });
+}
+export function iif(check, _then, _else) {
+    return validator('iif', function (input, context) {
+        let c = _else;
+        try {
+            if (check(input) !== undefined)
+                c = _then;
+        }
+        catch {
+            // ignored
+        }
+        if (isValidator(c))
+            return c[kValidatorFn](input, context, c);
+        return c;
+    });
+}

package/package.json

@@ -1,56 +1,52 @@
 {
   "name": "valgen",
-  "description": "Fast type validation generator for JavaScript",
-  "version": "3.2.1",
+  "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
+  "version": "4.0.0-alpha.3",
   "author": "Panates",
   "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>",
-    "Arhun Hınçalan <ahincalan@hotmail.com>"
+    "Eray Hanoglu <e.hanoglu@panates.com>"
   ],
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/panates/valgen.git"
   },
-  "keywords": [
-    "javascript",
-    "validate",
-    "validation",
-    "validator",
-    "type",
-    "raml",
-    "swagger",
-    "generator"
-  ],
   "dependencies": {
-    "object-hash": "^2.0.3",
-    "putil-merge": "^3.6.0",
-    "putil-promisify": "^1.7.1",
-    "putil-varhelpers": "^1.6.1"
+    "dayjs": "^1.11.8",
+    "validator": "^13.9.0"
   },
-  "devDependencies": {
-    "eslint": "^7.28.0",
-    "eslint-config-google": "^0.14.0",
-    "mocha": "^9.0.0",
-    "nyc": "^15.0.1"
+  "type": "module",
+  "types": "typings/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
   },
-  "peerDependencies": {},
   "engines": {
-    "node": ">= 10.0"
+    "node": ">= 16.0"
   },
   "files": [
+    "cjs/",
+    "esm/",
+    "typings/",
     "LICENSE",
     "README.md",
-    "lib/"
+    "CHANGELOG.md"
   ],
-  "nyc": {
-    "temp-directory": "./coverage/.nyc_output"
-  },
-  "scripts": {
-    "test": "mocha --require ./test/support/env --reporter spec --bail --check-leaks test/",
-    "cover": "nyc --reporter html --reporter text npm run test",
-    "travis-cover": "nyc --reporter lcovonly npm run test"
-  }
-}
+  "keywords": [
+    "validate",
+    "validation",
+    "validator",
+    "check",
+    "encoding",
+    "decoding",
+    "coerce",
+    "convert",
+    "converter",
+    "transform",
+    "type"
+  ]
+}

package/typings/core/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const kValidatorFn: unique symbol;
+export declare const kOptions: unique symbol;

package/typings/core/context.d.ts

@@ -0,0 +1,26 @@
+import type { ErrorIssue, ExecutionOptions, OnFailFunction } from './types';
+import type { Validator } from './validator';
+export declare namespace Context {
+    interface InputDetails {
+        context?: string;
+        root?: string;
+        value?: any;
+        label?: string;
+        location?: string;
+        property?: string | number;
+        [key: string]: any;
+    }
+}
+export declare class Context implements ExecutionOptions {
+    rule: Validator<any>;
+    errors: ErrorIssue[];
+    maxErrors?: number;
+    onFail?: OnFailFunction;
+    coerce?: boolean;
+    input: Context.InputDetails;
+    parent?: Context;
+    root?: Context;
+    constructor(rule: Validator<any>, options?: ExecutionOptions);
+    failure(message: Partial<ErrorIssue> | string | Error): void;
+    extend(rule: Validator<any, any>, options?: ExecutionOptions): Context;
+}

package/typings/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './context.js';
+export * from './constants.js';
+export * from './types.js';
+export * from './validation-error.js';
+export * from './validator.js';
+export { Nullish, Type, Maybe } from 'ts-gems';

package/typings/core/types.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from './context';
+export interface ErrorIssue {
+    rule: string;
+    message: string;
+    value: any;
+    root?: string;
+    context?: string;
+    property?: string;
+    [key: string]: any;
+}
+export type OnFailFunction = (issue: ErrorIssue, context: Context, _super?: OnFailFunction) => string | Omit<ErrorIssue, 'id' | 'input'>;
+export interface ValidationOptions {
+    onFail?: OnFailFunction;
+}
+export interface ExecutionOptions extends ValidationOptions {
+    coerce?: boolean;
+    maxErrors?: number;
+}

package/typings/core/validation-error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorIssue } from './types.js';
+export declare class ValidationError extends Error {
+    issues: ErrorIssue[];
+    constructor(issues: ErrorIssue[]);
+}

package/typings/core/validator.d.ts

@@ -0,0 +1,18 @@
+import { Nullish } from 'ts-gems';
+import { kValidatorFn } from './constants.js';
+import { Context } from './context.js';
+import { ErrorIssue, ExecutionOptions, ValidationOptions } from './types.js';
+export type ValidateFunction<T, I = T, R extends Validator<T, I> = Validator<T, I>> = (input: I, context: Context, _this: R) => Nullish<T>;
+export interface Validator<T, I = unknown, O extends ExecutionOptions = ExecutionOptions> {
+    (input: I, options?: O, context?: Context): T;
+    silent(input: I, options?: O, context?: Context): {
+        value?: T;
+        errors?: ErrorIssue[];
+    };
+    id: string;
+    args?: Record<string, any>;
+    [kValidatorFn]: ValidateFunction<T, I>;
+}
+export declare function validator<T, I = T, O extends ExecutionOptions = ExecutionOptions>(fn: ValidateFunction<T, I>, validatorOptions?: ValidationOptions): Validator<T, I, O>;
+export declare function validator<T, I = T, O extends ExecutionOptions = ExecutionOptions>(id: string, fn: ValidateFunction<T, I>, validatorOptions?: ValidationOptions): Validator<T, I, O>;
+export declare function isValidator(x: any): x is Validator<any, any>;

package/typings/helpers/object.utils.d.ts

@@ -0,0 +1,2 @@
+export declare function omitKeys<T extends object, K extends keyof T>(o: T, keys: K[]): Omit<T, K>;
+export declare function pickKeys<T extends object, K extends keyof T>(o: T, keys: K[]): Pick<T, K>;

package/typings/helpers/string.utils.d.ts

@@ -0,0 +1 @@
+export declare function camelCase(v: string): string;

package/typings/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+export * from './rules/index.js';

package/typings/rules/index.d.ts

@@ -0,0 +1,23 @@
+export * from './is-any.js';
+export * from './is-array.js';
+export * from './is-bigint.js';
+export * from './is-boolean.js';
+export * from './is-date.js';
+export * from './is-empty.js';
+export * from './is-enum.js';
+export * from './is-integer.js';
+export * from './is-null.js';
+export * from './is-matches.js';
+export * from './is-number.js';
+export * from './is-object.js';
+export * from './is-object-id.js';
+export * from './is-record.js';
+export * from './is-string.js';
+export * from './is-tuple.js';
+export * from './length.js';
+export * from './optional.js';
+export * from './pipe.js';
+export * from './range.js';
+export * from './string-formats.js';
+export * from './union.js';
+export * from './utilities.js';

package/typings/rules/is-any.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Does nothing, just returns original input value.
+ * @validator isAny
+ */
+export declare const isAny: () => import("../core/validator.js").Validator<any, any, import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-array.d.ts

@@ -0,0 +1,7 @@
+import { ValidationOptions, Validator } from '../core/index.js';
+/**
+ * Validates if value is "array" and applies validation for each item.
+ * Converts input value to array if coerce option is set to 'true'.
+ * @validator isArray
+ */
+export declare function isArray<T, I>(itemValidator?: Validator<T, I>, options?: ValidationOptions): Validator<T[], I | I[], import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-bigint.d.ts

@@ -0,0 +1,7 @@
+import { ValidationOptions } from '../core/index.js';
+/**
+ * Validates if value is "BigInt".
+ * Converts input value to number if coerce option is set to 'true'.
+ * @validator isNumber
+ */
+export declare function isBigint(options?: ValidationOptions): import("../core/validator.js").Validator<bigint, unknown, import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-boolean.d.ts

@@ -0,0 +1,7 @@
+import { ValidationOptions } from '../core/index.js';
+/**
+ * Validates if value is "boolean".
+ * Converts input value to boolean if coerce option is set to 'true'.
+ * @validator isBoolean
+ */
+export declare function isBoolean(options?: ValidationOptions): import("../core/validator.js").Validator<boolean | undefined, unknown, import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-date.d.ts

@@ -0,0 +1,19 @@
+import { ValidationOptions } from '../core/index.js';
+export interface IsDateOptions extends ValidationOptions {
+    format?: string | string[];
+}
+/**
+ * Validates if value is instance of "Date".
+ * Converts input value to Date if coerce option is set to 'true'.
+ * @validator isDate
+ */
+export declare function isDate(options?: IsDateOptions): import("../core/validator.js").Validator<Date, string | number | Date, import("../core/types.js").ExecutionOptions>;
+export interface IsDateStringOptions extends ValidationOptions {
+    format?: string | string[];
+}
+/**
+ * Validates if value is DFS (date formatted string).
+ * Converts input value to DFS if coerce option is set to 'true'.
+ * @validator isDateString
+ */
+export declare function isDateString(options?: IsDateStringOptions): import("../core/validator.js").Validator<string, string | number | Date, import("../core/types.js").ExecutionOptions>;