@modulify/validator 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -1,326 +1,119 @@
-'use strict';
-
-/******************************************************************************
-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) {
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assertions = require("./assertions.cjs");
+const runners = require("./runners.cjs");
+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);
-    }
-}
-
-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);
-};
-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);
-    }
+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 createValidator = (provider = null) => new V(provider);
-
-exports.Collection = Collection;
-exports.Each = Each;
-exports.Exists = Exists;
-exports.Length = Length;
-exports.OneOf = OneOf;
-exports.ProviderChain = ProviderChain;
-exports.createValidator = createValidator;
+exports.Assert = assertions.Assert;
+exports.HasLength = assertions.HasLength;
+exports.IsBoolean = assertions.IsBoolean;
+exports.IsDate = assertions.IsDate;
+exports.IsDefined = assertions.IsDefined;
+exports.IsEmail = assertions.IsEmail;
+exports.IsNull = assertions.IsNull;
+exports.IsNumber = assertions.IsNumber;
+exports.IsString = assertions.IsString;
+exports.IsSymbol = assertions.IsSymbol;
+exports.OneOf = assertions.OneOf;
+exports.Each = runners.Each;
+exports.HasProperties = runners.HasProperties;
 exports.validate = validate;
-//# sourceMappingURL=index.cjs.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Constraint, MaybeMany, Violation } from '../types';
+export * from './assertions';
+export * from './runners';
+export declare const validate: (<T>(value: T, constraints: MaybeMany<Constraint>, path?: PropertyKey[]) => Promise<Violation[]>) & {
+    sync: <T>(value: T, constraints: MaybeMany<Constraint>, path?: PropertyKey[]) => Violation[];
+};