@modulify/validator 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1,317 +1,119 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class Collection {
-    constructor(constraints) {
-        this.name = '@modulify/validator/Collection';
-        this.constraints = constraints;
-    }
-    reduce(reducer, initial) {
-        return Object.keys(this.constraints).reduce((accumulator, key) => {
-            return reducer(accumulator, this.constraints[key], key);
-        }, initial);
-    }
-    toViolation(value, path, reason) {
+import { Assert, HasLength, IsBoolean, IsDate, IsDefined, IsEmail, IsNull, IsNumber, IsString, IsSymbol, OneOf } from "./assertions.mjs";
+import { Each, HasProperties } from "./runners.mjs";
+const check = (assert, value, path = []) => {
+  if (assert(value)) {
+    for (const a of assert.also) {
+      const violation = check(a, value, path);
+      if (violation) {
         return {
-            by: this.name,
-            value,
-            path,
-            reason,
+          ...violation,
+          violates: assert.fqn
         };
-    }
-}
-
-const arraify = (value) => Array.isArray(value)
-    ? [...value]
-    : [value];
-const flatten = (recursive) => {
-    const flattened = [];
-    recursive.forEach(element => {
-        flattened.push(...(Array.isArray(element)
-            ? flatten(element)
-            : [element]));
-    });
-    return flattened;
+      }
+    }
+    return null;
+  }
+  return {
+    value,
+    path,
+    violates: assert.fqn,
+    ..."reason" in assert ? { reason: assert.reason } : {},
+    ..."meta" in assert ? { meta: assert.meta } : {}
+  };
 };
-const constructorOf = (value) => {
-    return Object.getPrototypeOf(value).constructor;
+const isBatch = (c) => {
+  return "run" in c;
 };
-const isRecord = (value) => {
-    return constructorOf(value) === Object && Object.keys(Object.getPrototypeOf(value)).length === 0;
+const _validate = async (value, constraints, path = []) => {
+  const validations = [];
+  for (const c of arraify(constraints)) {
+    if (isBatch(c)) {
+      validations.push(...c.run(_validate, value, path).map((v2) => v2 instanceof Promise ? v2 : Promise.resolve(v2)));
+      continue;
+    }
+    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    if (v instanceof Promise) {
+      if (c.bail) {
+        const awaited = await v;
+        if (awaited) {
+          validations.push(Promise.resolve([awaited]));
+          break;
+        }
+      } else {
+        validations.push(v.then((v2) => v2 ? [v2] : []));
+      }
+    } else if (v) {
+      validations.push(Promise.resolve([v]));
+      if (c.bail) {
+        break;
+      }
+    }
+  }
+  return settle(value, path, validations);
 };
-
-class Each {
-    constructor(constraints) {
-        this.name = '@modulify/validator/Each';
-        this.constraints = arraify(constraints);
-    }
-    toViolation(value, path, reason) {
-        return {
-            by: this.name,
-            value,
-            path,
-            reason,
-        };
-    }
-}
-
-class Exists {
-    constructor() {
-        this.name = '@modulify/validator/Exists';
-    }
-    toViolation(value, path) {
-        return {
-            by: this.name,
-            value,
-            path,
-            reason: 'undefined',
-        };
-    }
-}
-
-class Length {
-    constructor(options) {
-        var _a, _b, _c;
-        this.name = '@modulify/validator/Length';
-        this.exact = (_a = options.exact) !== null && _a !== void 0 ? _a : null;
-        this.max = (_b = options.max) !== null && _b !== void 0 ? _b : null;
-        this.min = (_c = options.min) !== null && _c !== void 0 ? _c : null;
-    }
-    toViolation(value, path, reason) {
-        return {
-            by: this.name,
-            value,
-            path,
-            reason,
-            meta: {
-                exact: this.exact,
-                max: this.max,
-                min: this.min,
-            }[reason],
-        };
-    }
-}
-
-class OneOf {
-    constructor(values, equalTo = (a, b) => a === b) {
-        this.name = '@modulify/validator/OneOf';
-        this.values = Array.isArray(values) ? values : Object.values(values);
-        this.equalTo = equalTo;
-    }
-    toViolation(value, path) {
-        return {
-            by: this.name,
-            value,
-            path,
-            meta: this.values,
-        };
-    }
-}
-
-class LengthValidator {
-    constructor(constraint) {
-        this.constraint = constraint;
-    }
-    validate(value, path = []) {
-        const constraint = this.constraint;
-        const { exact, max, min } = constraint;
-        if (!(typeof value === 'string' || Array.isArray(value))) {
-            return constraint.toViolation(value, path, 'unsupported');
-        }
-        if (exact !== null && exact !== value.length) {
-            return constraint.toViolation(value, path, 'exact');
-        }
-        if (max !== null && value.length > max) {
-            return constraint.toViolation(value, path, 'max');
-        }
-        if (min !== null && value.length < min) {
-            return constraint.toViolation(value, path, 'min');
-        }
-        return null;
-    }
+const _sync = (value, constraints, path = []) => {
+  const violations = [];
+  for (const c of arraify(constraints)) {
+    if (isBatch(c)) {
+      violations.push(...c.run(_sync, value, path));
+      continue;
+    }
+    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    if (v instanceof Promise) {
+      throw new Error("Found asynchronous constraint validator " + String(c.fqn));
+    } else if (v) {
+      violations.push(v);
+      if (c.bail) {
+        break;
+      }
+    }
+  }
+  return flatten(violations);
+};
+const validate = Object.assign(_validate, {
+  sync: _sync
+});
+function arraify(value) {
+  return Array.isArray(value) ? [...value] : [value];
 }
-
-class OneOfValidator {
-    constructor(constraint) {
-        this.constraint = constraint;
-    }
-    validate(value, path = []) {
-        const equalTo = this.constraint.equalTo;
-        if (!this.constraint.values.some(allowed => equalTo(allowed, value))) {
-            return this.constraint.toViolation(value, path);
-        }
-        return null;
-    }
+function flatten(recursive) {
+  const flattened = [];
+  recursive.forEach((element) => {
+    flattened.push(...Array.isArray(element) ? flatten(element) : [element]);
+  });
+  return flattened;
 }
-
-class ProviderChain {
-    constructor(current = null, previous = null) {
-        this._current = current;
-        this._previous = previous;
-    }
-    get(constraint) {
-        var _a, _b, _c, _d;
-        switch (true) {
-            case constraint instanceof Length:
-                return new LengthValidator(constraint);
-            case constraint instanceof OneOf:
-                return new OneOfValidator(constraint);
-            default:
-                return (_d = (_b = (_a = this._current) === null || _a === void 0 ? void 0 : _a.get(constraint)) !== null && _b !== void 0 ? _b : (_c = this._previous) === null || _c === void 0 ? void 0 : _c.get(constraint)) !== null && _d !== void 0 ? _d : null;
-        }
-    }
-    override(provider) {
-        return new ProviderChain(provider, this);
-    }
+async function settle(value, path, validations) {
+  const violations = [];
+  const settled = await Promise.allSettled(validations);
+  settled.forEach((result) => {
+    if (result.status === "fulfilled") {
+      violations.push(...result.value);
+    } else {
+      violations.push({
+        value,
+        path,
+        violates: "@modulify/validator",
+        reason: "reject",
+        meta: result.reason
+      });
+    }
+  });
+  return violations;
 }
-
-const validateAsynchronously = (provider, value, constraints, path = []) => __awaiter(void 0, void 0, void 0, function* () {
-    const validations = [];
-    for (const c of arraify(constraints)) {
-        if (c instanceof Collection) {
-            if (isRecord(value)) {
-                validations.push(...c.reduce((validations, constraints, key) => {
-                    return [...validations, validateAsynchronously(provider, value[key], constraints, [...path, key])];
-                }, []));
-            }
-            else {
-                validations.push(Promise.resolve([c.toViolation(value, path, 'unsupported')]));
-            }
-            continue;
-        }
-        if (c instanceof Each) {
-            if (Array.isArray(value)) {
-                value.forEach((value, index) => {
-                    validations.push(validateAsynchronously(provider, value, c.constraints, [...path, index]));
-                });
-            }
-            else {
-                validations.push(validateAsynchronously(provider, value, c.constraints, [...path]));
-            }
-            continue;
-        }
-        if (c instanceof Exists) {
-            if (typeof value === 'undefined') {
-                validations.push(Promise.resolve([c.toViolation(value, [...path])]));
-                break;
-            }
-            continue;
-        }
-        const validator = provider.get(c);
-        if (!validator) {
-            throw new Error('No validator for constraint ' + c.name);
-        }
-        const v = validator.validate(value, [...path]);
-        if (v) {
-            if (v instanceof Promise) {
-                validations.push(v.then(v => v ? [v] : []));
-            }
-            else {
-                validations.push(Promise.resolve([v]));
-            }
-        }
-    }
-    const results = yield Promise.allSettled(validations);
-    const violations = [];
-    results.forEach(result => {
-        if (result.status === 'fulfilled') {
-            violations.push(...result.value);
-        }
-    });
-    return violations;
-});
-const validateSynchronously = (provider, value, constraints, path = []) => {
-    const violations = [];
-    for (const c of arraify(constraints)) {
-        if (c instanceof Collection) {
-            if (isRecord(value)) {
-                violations.push(c.reduce((violations, constraints, key) => {
-                    return [...violations, ...validateSynchronously(provider, value[key], constraints, [...path, key])];
-                }, []));
-            }
-            else {
-                violations.push(c.toViolation(value, path, 'unsupported'));
-            }
-            continue;
-        }
-        if (c instanceof Each) {
-            if (Array.isArray(value)) {
-                value.forEach((value, index) => {
-                    violations.push(...validateSynchronously(provider, value, c.constraints, [...path, index]));
-                });
-            }
-            else {
-                violations.push(...validateSynchronously(provider, value, c.constraints, [...path]));
-            }
-            continue;
-        }
-        if (c instanceof Exists) {
-            if (typeof value === 'undefined') {
-                violations.push(c.toViolation(value, [...path]));
-                break;
-            }
-            continue;
-        }
-        const validator = provider.get(c);
-        if (!validator) {
-            throw new Error('No validator for constraint ' + c.name);
-        }
-        const v = validator.validate(value, [...path]);
-        if (v) {
-            if (v instanceof Promise) {
-                throw new Error('Found asynchronous validator for constraint ' + c.name);
-            }
-            violations.push(v);
-        }
-    }
-    return flatten(violations);
+export {
+  Assert,
+  Each,
+  HasLength,
+  HasProperties,
+  IsBoolean,
+  IsDate,
+  IsDefined,
+  IsEmail,
+  IsNull,
+  IsNumber,
+  IsString,
+  IsSymbol,
+  OneOf,
+  validate
 };
-const validate = (provider, value, constraints, path = [], asynchronously = true) => {
-    return asynchronously
-        ? validateAsynchronously(provider, value, constraints, path)
-        : validateSynchronously(provider, value, constraints, path);
-};
-class V {
-    constructor(provider = null) {
-        this._provider = provider !== null && provider !== void 0 ? provider : new ProviderChain();
-    }
-    override(provider) {
-        return new V(this._provider.override(provider));
-    }
-    validate(value, constraints, asynchronously = true) {
-        return validate(this._provider, value, constraints, [], asynchronously);
-    }
-}
-const createValidator = (provider = null) => new V(provider);
-
-export { Collection, Each, Exists, Length, OneOf, ProviderChain, createValidator, validate };
-//# sourceMappingURL=index.mjs.map

package/dist/predicates.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function hasProperty(key) {
+  return (value) => {
+    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+  };
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isEmail(value) {
+  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
+  return isString(value) && pattern.test(value);
+}
+function isExact(exact) {
+  return (value) => value === exact;
+}
+function isNull(value) {
+  return value === null;
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isObject(value) {
+  return typeof value === "object";
+}
+function isRecord(value) {
+  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+function constructorOf(value) {
+  return prototypeOf(value).constructor;
+}
+function prototypeOf(value) {
+  return Object.getPrototypeOf(value);
+}
+function And(...predicates) {
+  return (value) => {
+    return predicates.every((predicate) => predicate(value));
+  };
+}
+function Or(...predicates) {
+  return (value) => {
+    return predicates.some((predicate) => predicate(value));
+  };
+}
+function Not(predicate) {
+  return (value) => {
+    return !predicate(value);
+  };
+}
+exports.And = And;
+exports.Not = Not;
+exports.Or = Or;
+exports.hasProperty = hasProperty;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmail = isEmail;
+exports.isExact = isExact;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isRecord = isRecord;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;

package/dist/predicates.d.ts

@@ -0,0 +1,34 @@
+import { Intersect, Predicate } from '../types';
+/** Checks if a value has a property */
+export declare function hasProperty<K extends PropertyKey = PropertyKey>(key: K): (value: unknown) => value is { [k in K]: unknown; };
+/** Checks if a value is an array */
+export declare function isArray(value: unknown): value is unknown[];
+/** Checks if a value is a boolean */
+export declare function isBoolean(value: unknown): value is boolean;
+/** Checks if value is Date */
+export declare function isDate(value: unknown): value is Date;
+/** Checks if a value is an email */
+export declare function isEmail(value: unknown): value is string;
+/** Creates a predicate that checks if a value is equal to specified */
+export declare function isExact<T = unknown>(exact: T): (value: unknown) => value is T;
+/** Checks if value is null */
+export declare function isNull(value: unknown): value is null;
+/** Checks if a value is a number */
+export declare function isNumber(value: unknown): value is number;
+/** Checks if a value is an object */
+export declare function isObject(value: unknown): value is object;
+/** Check if a value is a record like Record<PropertyKey, unknown> */
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/** Checks if a value is a string */
+export declare function isString(value: unknown): value is string;
+/** Checks if a value is a symbol */
+export declare function isSymbol(value: unknown): value is symbol;
+/** Checks if value is undefined */
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function And<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<Intersect<T>>;
+export declare function Or<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<T[number]>;
+export declare function Not<T>(predicate: Predicate<T>): Predicate;

package/dist/predicates.mjs

@@ -0,0 +1,81 @@
+function hasProperty(key) {
+  return (value) => {
+    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+  };
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isEmail(value) {
+  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
+  return isString(value) && pattern.test(value);
+}
+function isExact(exact) {
+  return (value) => value === exact;
+}
+function isNull(value) {
+  return value === null;
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isObject(value) {
+  return typeof value === "object";
+}
+function isRecord(value) {
+  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+function constructorOf(value) {
+  return prototypeOf(value).constructor;
+}
+function prototypeOf(value) {
+  return Object.getPrototypeOf(value);
+}
+function And(...predicates) {
+  return (value) => {
+    return predicates.every((predicate) => predicate(value));
+  };
+}
+function Or(...predicates) {
+  return (value) => {
+    return predicates.some((predicate) => predicate(value));
+  };
+}
+function Not(predicate) {
+  return (value) => {
+    return !predicate(value);
+  };
+}
+export {
+  And,
+  Not,
+  Or,
+  hasProperty,
+  isArray,
+  isBoolean,
+  isDate,
+  isEmail,
+  isExact,
+  isNull,
+  isNumber,
+  isObject,
+  isRecord,
+  isString,
+  isSymbol,
+  isUndefined
+};

package/dist/runners/Each.d.ts

@@ -0,0 +1,3 @@
+import { Constraint, MaybeMany, ValidationRunner } from '../../types';
+declare const _default: (constraints: MaybeMany<Constraint>) => ValidationRunner;
+export default _default;

package/dist/runners/HasProperties.d.ts

@@ -0,0 +1,6 @@
+import { Constraint, MaybeMany, ValidationRunner } from '../../types';
+export type Descriptor<T extends object> = {
+    [P in keyof T]: MaybeMany<Constraint>;
+};
+declare const _default: <T extends object>(descriptor: Descriptor<T>) => ValidationRunner;
+export default _default;

package/dist/runners/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Each } from './Each';
+export { default as HasProperties } from './HasProperties';

package/dist/runners.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const predicates = require("./predicates.cjs");
+const Each = (constraints) => {
+  return {
+    run(validate, value, path) {
+      return predicates.isArray(value) ? value.map((v, i) => validate(v, constraints, [...path, i])) : [validate(value, constraints, [...path])];
+    }
+  };
+};
+const HasProperties = (descriptor) => ({
+  run(validate, value, path) {
+    if (predicates.isRecord(value)) {
+      const fields = Object.keys(descriptor);
+      return fields.reduce((accumulator, key) => [
+        ...accumulator,
+        validate(value[key], descriptor[key], [...path, key])
+      ], []);
+    } else {
+      return [
+        [{
+          value,
+          path,
+          violates: "@modulify/validator/HasProperties",
+          reason: "unsupported"
+        }]
+      ];
+    }
+  }
+});
+exports.Each = Each;
+exports.HasProperties = HasProperties;

package/dist/runners.d.ts

@@ -0,0 +1,2 @@
+export * from './runners/index'
+export {}