@modulify/validator 0.1.0 → 0.2.1

package/dist/extractors.d.ts

@@ -0,0 +1,2 @@
+export declare const length: <T extends unknown[] | string>(value: T) => number;
+export declare const size: <T extends Map<unknown, unknown> | Set<unknown>>(value: T) => number;

package/dist/index.cjs

@@ -1,51 +1,119 @@
 "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 {
-          ...violation,
-          violates: assert.fqn
-        };
-      }
-    }
-    return null;
+const combinators = require("./combinators.cjs");
+const metadata = require("./metadata.cjs.js");
+const assert = require("./assert.cjs");
+const ROOT_PATH = Object.freeze([]);
+const normalizePath = (path) => path ?? ROOT_PATH;
+const isSamePath = (left, right = ROOT_PATH) => {
+  const normalizedLeft = normalizePath(left);
+  if (normalizedLeft.length !== right.length) {
+    return false;
   }
-  return {
-    value,
-    path,
-    violates: assert.fqn,
-    ..."reason" in assert ? { reason: assert.reason } : {},
-    ..."meta" in assert ? { meta: assert.meta } : {}
-  };
+  return normalizedLeft.every((part, index) => Object.is(part, right[index]));
 };
-const isBatch = (c) => {
-  return "run" in c;
+const isPathPrefix = (path, prefix) => {
+  if (prefix.length > path.length) {
+    return false;
+  }
+  return prefix.every((part, index) => Object.is(part, path[index]));
 };
-const _validate = async (value, constraints, path = []) => {
+const createTreeState = (path) => ({
+  path: Object.freeze([...path]),
+  self: [],
+  subtree: [],
+  children: /* @__PURE__ */ new Map()
+});
+class TreeNode {
+  constructor(state) {
+    this.path = state.path;
+    this.self = new ViolationCollection(state.self);
+    this.subtree = new ViolationCollection(state.subtree);
+    this.children = new Map(
+      [...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)])
+    );
+  }
+  at(path) {
+    if (!isPathPrefix(path, this.path)) {
+      return void 0;
+    }
+    if (path.length === this.path.length) {
+      return this;
+    }
+    const child = this.children.get(path[this.path.length]);
+    return child?.at(path);
+  }
+}
+const buildTree = (violations) => {
+  const root = createTreeState(ROOT_PATH);
+  violations.forEach((violation) => {
+    const path = normalizePath(violation.path);
+    root.subtree.push(violation);
+    if (path.length === 0) {
+      root.self.push(violation);
+      return;
+    }
+    let current = root;
+    const currentPath = [];
+    path.forEach((segment, index) => {
+      currentPath.push(segment);
+      let child = current.children.get(segment);
+      if (!child) {
+        child = createTreeState(currentPath);
+        current.children.set(segment, child);
+      }
+      child.subtree.push(violation);
+      if (index === path.length - 1) {
+        child.self.push(violation);
+      }
+      current = child;
+    });
+  });
+  return new TreeNode(root);
+};
+class ViolationCollection {
+  constructor(violations) {
+    this.violations = [...violations];
+    this.size = this.violations.length;
+  }
+  [Symbol.iterator]() {
+    return this.violations[Symbol.iterator]();
+  }
+  forEach(callback) {
+    this.violations.forEach((violation, index) => callback(violation, index, this));
+  }
+  map(callback) {
+    return this.violations.map((violation, index) => callback(violation, index, this));
+  }
+  at(path) {
+    return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
+  }
+  tree() {
+    return buildTree(this.violations);
+  }
+}
+const collection = (violations) => new ViolationCollection(violations);
+const collectViolations = 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)));
+  for (const c of metadata.arrayify(constraints)) {
+    if (metadata.isValidator(c)) {
+      validations.push(...c.run(collectViolations, value, path).map((v2) => v2 instanceof Promise ? v2 : Promise.resolve(v2)));
       continue;
     }
-    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    const v = c(value);
     if (v instanceof Promise) {
       if (c.bail) {
         const awaited = await v;
         if (awaited) {
-          validations.push(Promise.resolve([awaited]));
+          validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
           break;
         }
       } else {
-        validations.push(v.then((v2) => v2 ? [v2] : []));
+        validations.push(v.then((v2) => v2 ? [Object.assign(v2, { path: [...path] })] : []));
       }
     } else if (v) {
-      validations.push(Promise.resolve([v]));
+      validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
       if (c.bail) {
         break;
       }
@@ -53,30 +121,25 @@ const _validate = async (value, constraints, path = []) => {
   }
   return settle(value, path, validations);
 };
-const _sync = (value, constraints, path = []) => {
+const collectViolationsSync = (value, constraints, path = []) => {
   const violations = [];
-  for (const c of arraify(constraints)) {
-    if (isBatch(c)) {
-      violations.push(...c.run(_sync, value, path));
+  for (const c of metadata.arrayify(constraints)) {
+    if (metadata.isValidator(c)) {
+      violations.push(...c.run(collectViolationsSync, value, path));
       continue;
     }
-    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    const v = c(value);
     if (v instanceof Promise) {
-      throw new Error("Found asynchronous constraint validator " + String(c.fqn));
+      throw new Error("Found asynchronous validator " + String(c.name));
     } else if (v) {
-      violations.push(v);
-      if (c.bail) {
-        break;
-      }
+      violations.push(Object.assign(v, { path: [...path] }));
+      if (c.bail) break;
     }
   }
   return flatten(violations);
 };
-const validate = Object.assign(_validate, {
-  sync: _sync
-});
-function arraify(value) {
-  return Array.isArray(value) ? [...value] : [value];
+function toResult(value, violations) {
+  return violations.length === 0 ? [true, value, []] : [false, value, violations];
 }
 function flatten(recursive) {
   const flattened = [];
@@ -95,25 +158,73 @@ async function settle(value, path, validations) {
       violations.push({
         value,
         path,
-        violates: "@modulify/validator",
-        reason: "reject",
-        meta: result.reason
+        violates: { kind: "runtime", name: "validate", code: "runtime.rejection", args: [result.reason] }
       });
     }
   });
   return violations;
 }
-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;
+const matches = {
+  sync(value, constraints) {
+    return collectViolationsSync(value, constraints).length === 0;
+  }
+};
+const validate = Object.assign(
+  async (value, constraints) => {
+    const violations = await collectViolations(value, constraints);
+    return toResult(
+      value,
+      violations
+    );
+  },
+  {
+    sync(value, constraints) {
+      const violations = collectViolationsSync(value, constraints);
+      return toResult(
+        value,
+        violations
+      );
+    }
+  }
+);
+exports.endsWith = assertions.endsWith;
+exports.hasLength = assertions.hasLength;
+exports.hasPattern = assertions.hasPattern;
+exports.hasSize = assertions.hasSize;
+exports.hasValue = assertions.hasValue;
+exports.isBigInt = assertions.isBigInt;
+exports.isBlob = assertions.isBlob;
+exports.isBoolean = assertions.isBoolean;
+exports.isDate = assertions.isDate;
+exports.isDefined = assertions.isDefined;
+exports.isEmail = assertions.isEmail;
+exports.isFile = assertions.isFile;
+exports.isFunction = assertions.isFunction;
+exports.isMap = assertions.isMap;
+exports.isNaN = assertions.isNaN;
+exports.isNull = assertions.isNull;
+exports.isNumber = assertions.isNumber;
+exports.isSet = assertions.isSet;
+exports.isString = assertions.isString;
+exports.isSymbol = assertions.isSymbol;
+exports.multipleOf = assertions.multipleOf;
+exports.oneOf = assertions.oneOf;
+exports.startsWith = assertions.startsWith;
+exports.discriminatedUnion = combinators.discriminatedUnion;
+exports.each = combinators.each;
+exports.exact = combinators.exact;
+exports.nullable = combinators.nullable;
+exports.nullish = combinators.nullish;
+exports.optional = combinators.optional;
+exports.record = combinators.record;
+exports.shape = combinators.shape;
+exports.tuple = combinators.tuple;
+exports.union = combinators.union;
+exports.custom = metadata.custom;
+exports.describe = metadata.describe;
+exports.meta = metadata.meta;
+exports.assert = assert.assert;
+exports.ViolationCollection = ViolationCollection;
+exports.collection = collection;
+exports.matches = matches;
 exports.validate = validate;

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-import { Constraint, MaybeMany, Violation } from '../types';
+import { Constraint, InferConstraints, InferMaybeManyViolations, MaybeMany, ValidationTuple } 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[];
+export * from './combinators';
+export { collection, ViolationCollection, } from './violations';
+export { custom, describe, meta, } from './metadata';
+export type { AllOfConstraintDescriptor, AssertionDescriptor, AssertionDescriptorConstraint, Constraint, ConstraintDescriptor, ConstraintDescriptorBase, ConstraintMetadata, CustomConstraintDescriptor, DescribeAssertionConstraint, DescribeAssertionConstraintTuple, DescribeConstraint, DescribeConstraintTuple, DescribeMaybeMany, DescribeObjectDescriptor, DescribedValidator, DiscriminatedUnionValidator, EachValidator, FieldsMatchObjectShapeRuleDescriptor, GenericObjectShapeRuleDescriptor, InferConstraint, InferConstraints, InferConstraintViolations, InferMaybeManyViolations, DiscriminatedUnionConstraintDescriptor, EachConstraintDescriptor, NullableValidator, NullishValidator, KnownViolationCode, KnownViolationSubject, ObjectShapeFieldSelector, ObjectShapeRefinement, ObjectShapeRefinementIssue, ObjectShapeRuleDescriptor, ObjectShapeRuleDescriptorBase, OptionalValidator, RecordValidator, RecordConstraintDescriptor, ShapeConstraintDescriptor, TupleValidator, TupleConstraintDescriptor, UnionValidator, ValidationFailure, ValidationSuccess, ViolationArgs, ViolationCode, ViolationCodeEntry, ViolationCodeRegistry, ViolationEntry, ViolationKind, ViolationKindOf, ViolationNameOf, ViolationSubject, ViolationTreeNode, UnionConstraintDescriptor, ValidationTuple, ValidationResult, Validator, ValidatorDescriptor, Violation, WrapperConstraintDescriptor, } from '../types';
+export declare const matches: {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C): value is InferConstraints<C>;
+};
+export declare const validate: (<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C) => Promise<ValidationTuple<InferConstraints<C>, InferMaybeManyViolations<C>>>) & {
+    sync<const C extends MaybeMany<Constraint>>(value: unknown, constraints: C): ValidationTuple<InferConstraints<C>, InferMaybeManyViolations<C>>;
 };

package/dist/index.mjs

@@ -1,80 +1,144 @@
-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 {
-          ...violation,
-          violates: assert.fqn
-        };
-      }
-    }
-    return null;
+import { endsWith, hasLength, hasPattern, hasSize, hasValue, isBigInt, isBlob, isBoolean, isDate, isDefined, isEmail, isFile, isFunction, isMap, isNaN, isNull, isNumber, isSet, isString, isSymbol, multipleOf, oneOf, startsWith } from "./assertions.mjs";
+import { discriminatedUnion, each, exact, nullable, nullish, optional, record, shape, tuple, union } from "./combinators.mjs";
+import { a as arrayify, i as isValidator } from "./metadata.es.js";
+import { c, b, m } from "./metadata.es.js";
+import { assert } from "./assert.mjs";
+const ROOT_PATH = Object.freeze([]);
+const normalizePath = (path) => path ?? ROOT_PATH;
+const isSamePath = (left, right = ROOT_PATH) => {
+  const normalizedLeft = normalizePath(left);
+  if (normalizedLeft.length !== right.length) {
+    return false;
   }
-  return {
-    value,
-    path,
-    violates: assert.fqn,
-    ..."reason" in assert ? { reason: assert.reason } : {},
-    ..."meta" in assert ? { meta: assert.meta } : {}
-  };
+  return normalizedLeft.every((part, index) => Object.is(part, right[index]));
 };
-const isBatch = (c) => {
-  return "run" in c;
+const isPathPrefix = (path, prefix) => {
+  if (prefix.length > path.length) {
+    return false;
+  }
+  return prefix.every((part, index) => Object.is(part, path[index]));
 };
-const _validate = async (value, constraints, path = []) => {
+const createTreeState = (path) => ({
+  path: Object.freeze([...path]),
+  self: [],
+  subtree: [],
+  children: /* @__PURE__ */ new Map()
+});
+class TreeNode {
+  constructor(state) {
+    this.path = state.path;
+    this.self = new ViolationCollection(state.self);
+    this.subtree = new ViolationCollection(state.subtree);
+    this.children = new Map(
+      [...state.children.entries()].map(([key, child]) => [key, new TreeNode(child)])
+    );
+  }
+  at(path) {
+    if (!isPathPrefix(path, this.path)) {
+      return void 0;
+    }
+    if (path.length === this.path.length) {
+      return this;
+    }
+    const child = this.children.get(path[this.path.length]);
+    return child?.at(path);
+  }
+}
+const buildTree = (violations) => {
+  const root = createTreeState(ROOT_PATH);
+  violations.forEach((violation) => {
+    const path = normalizePath(violation.path);
+    root.subtree.push(violation);
+    if (path.length === 0) {
+      root.self.push(violation);
+      return;
+    }
+    let current = root;
+    const currentPath = [];
+    path.forEach((segment, index) => {
+      currentPath.push(segment);
+      let child = current.children.get(segment);
+      if (!child) {
+        child = createTreeState(currentPath);
+        current.children.set(segment, child);
+      }
+      child.subtree.push(violation);
+      if (index === path.length - 1) {
+        child.self.push(violation);
+      }
+      current = child;
+    });
+  });
+  return new TreeNode(root);
+};
+class ViolationCollection {
+  constructor(violations) {
+    this.violations = [...violations];
+    this.size = this.violations.length;
+  }
+  [Symbol.iterator]() {
+    return this.violations[Symbol.iterator]();
+  }
+  forEach(callback) {
+    this.violations.forEach((violation, index) => callback(violation, index, this));
+  }
+  map(callback) {
+    return this.violations.map((violation, index) => callback(violation, index, this));
+  }
+  at(path) {
+    return new ViolationCollection(this.violations.filter((violation) => isSamePath(violation.path, path)));
+  }
+  tree() {
+    return buildTree(this.violations);
+  }
+}
+const collection = (violations) => new ViolationCollection(violations);
+const collectViolations = 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)));
+  for (const c2 of arrayify(constraints)) {
+    if (isValidator(c2)) {
+      validations.push(...c2.run(collectViolations, value, path).map((v2) => v2 instanceof Promise ? v2 : Promise.resolve(v2)));
       continue;
     }
-    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    const v = c2(value);
     if (v instanceof Promise) {
-      if (c.bail) {
+      if (c2.bail) {
         const awaited = await v;
         if (awaited) {
-          validations.push(Promise.resolve([awaited]));
+          validations.push(Promise.resolve([Object.assign(awaited, { path: [...path] })]));
           break;
         }
       } else {
-        validations.push(v.then((v2) => v2 ? [v2] : []));
+        validations.push(v.then((v2) => v2 ? [Object.assign(v2, { path: [...path] })] : []));
       }
     } else if (v) {
-      validations.push(Promise.resolve([v]));
-      if (c.bail) {
+      validations.push(Promise.resolve([Object.assign(v, { path: [...path] })]));
+      if (c2.bail) {
         break;
       }
     }
   }
   return settle(value, path, validations);
 };
-const _sync = (value, constraints, path = []) => {
+const collectViolationsSync = (value, constraints, path = []) => {
   const violations = [];
-  for (const c of arraify(constraints)) {
-    if (isBatch(c)) {
-      violations.push(...c.run(_sync, value, path));
+  for (const c2 of arrayify(constraints)) {
+    if (isValidator(c2)) {
+      violations.push(...c2.run(collectViolationsSync, value, path));
       continue;
     }
-    const v = "That" in c ? check(c, value, [...path]) : c(value, [...path]);
+    const v = c2(value);
     if (v instanceof Promise) {
-      throw new Error("Found asynchronous constraint validator " + String(c.fqn));
+      throw new Error("Found asynchronous validator " + String(c2.name));
     } else if (v) {
-      violations.push(v);
-      if (c.bail) {
-        break;
-      }
+      violations.push(Object.assign(v, { path: [...path] }));
+      if (c2.bail) break;
     }
   }
   return flatten(violations);
 };
-const validate = Object.assign(_validate, {
-  sync: _sync
-});
-function arraify(value) {
-  return Array.isArray(value) ? [...value] : [value];
+function toResult(value, violations) {
+  return violations.length === 0 ? [true, value, []] : [false, value, violations];
 }
 function flatten(recursive) {
   const flattened = [];
@@ -93,27 +157,75 @@ async function settle(value, path, validations) {
       violations.push({
         value,
         path,
-        violates: "@modulify/validator",
-        reason: "reject",
-        meta: result.reason
+        violates: { kind: "runtime", name: "validate", code: "runtime.rejection", args: [result.reason] }
       });
     }
   });
   return violations;
 }
+const matches = {
+  sync(value, constraints) {
+    return collectViolationsSync(value, constraints).length === 0;
+  }
+};
+const validate = Object.assign(
+  async (value, constraints) => {
+    const violations = await collectViolations(value, constraints);
+    return toResult(
+      value,
+      violations
+    );
+  },
+  {
+    sync(value, constraints) {
+      const violations = collectViolationsSync(value, constraints);
+      return toResult(
+        value,
+        violations
+      );
+    }
+  }
+);
 export {
-  Assert,
-  Each,
-  HasLength,
-  HasProperties,
-  IsBoolean,
-  IsDate,
-  IsDefined,
-  IsEmail,
-  IsNull,
-  IsNumber,
-  IsString,
-  IsSymbol,
-  OneOf,
+  ViolationCollection,
+  assert,
+  collection,
+  c as custom,
+  b as describe,
+  discriminatedUnion,
+  each,
+  endsWith,
+  exact,
+  hasLength,
+  hasPattern,
+  hasSize,
+  hasValue,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDate,
+  isDefined,
+  isEmail,
+  isFile,
+  isFunction,
+  isMap,
+  isNaN,
+  isNull,
+  isNumber,
+  isSet,
+  isString,
+  isSymbol,
+  matches,
+  m as meta,
+  multipleOf,
+  nullable,
+  nullish,
+  oneOf,
+  optional,
+  record,
+  shape,
+  startsWith,
+  tuple,
+  union,
   validate
 };