@vytches/ddd-validation 0.26.0

package/dist/index.js

@@ -0,0 +1,803 @@
+import { Result as o } from "@vytches/ddd-utils";
+class u {
+  and(t) {
+    return new x(this, t);
+  }
+  or(t) {
+    return new A(this, t);
+  }
+  not() {
+    return new B(this);
+  }
+  static create(t) {
+    return new F(t);
+  }
+}
+let F = class extends u {
+  constructor(t) {
+    super(), this.predicate = t;
+  }
+  isSatisfiedBy(t) {
+    return this.predicate(t);
+  }
+};
+class x extends u {
+  constructor(t, e) {
+    super(), this.left = t, this.right = e;
+  }
+  isSatisfiedBy(t) {
+    return this.left.isSatisfiedBy(t) && this.right.isSatisfiedBy(t);
+  }
+}
+class A extends u {
+  constructor(t, e) {
+    super(), this.left = t, this.right = e;
+  }
+  isSatisfiedBy(t) {
+    return this.left.isSatisfiedBy(t) || this.right.isSatisfiedBy(t);
+  }
+}
+class B extends u {
+  constructor(t) {
+    super(), this.spec = t;
+  }
+  isSatisfiedBy(t) {
+    return !this.spec.isSatisfiedBy(t);
+  }
+}
+class w {
+  /**
+   * Combine with another async specification using AND logic
+   */
+  and(t) {
+    return new R(this, t);
+  }
+  /**
+   * Combine with another async specification using OR logic
+   */
+  or(t) {
+    return new $(this, t);
+  }
+  /**
+   * Negate this async specification
+   */
+  not() {
+    return new C(this);
+  }
+  /**
+   * Create a specification from an async predicate function
+   */
+  static create(t, e, i) {
+    return new E(t, e, i);
+  }
+  /**
+   * Optional method to explain why specification failed
+   */
+  async explainFailureAsync(t, e) {
+    return null;
+  }
+}
+class E extends w {
+  constructor(t, e, i) {
+    super(), this.predicate = t, this.name = e, this.description = i;
+  }
+  async isSatisfiedByAsync(t, e) {
+    return this.predicate(t, e);
+  }
+}
+class R extends w {
+  constructor(t, e) {
+    super(), this.left = t, this.right = e, this.name = `(${this.left.name || "spec"} AND ${this.right.name || "spec"})`, this.description = "Both specifications must be satisfied";
+  }
+  async isSatisfiedByAsync(t, e) {
+    const [i, s] = await Promise.all([
+      this.left.isSatisfiedByAsync(t, e),
+      this.right.isSatisfiedByAsync(t, e)
+    ]);
+    return i && s;
+  }
+  async explainFailureAsync(t, e) {
+    const [i, s] = await Promise.all([
+      this.left.isSatisfiedByAsync(t, e),
+      this.right.isSatisfiedByAsync(t, e)
+    ]), n = [];
+    if (!i && this.left.explainFailureAsync) {
+      const a = await this.left.explainFailureAsync(t, e);
+      a && n.push(a);
+    }
+    if (!s && this.right.explainFailureAsync) {
+      const a = await this.right.explainFailureAsync(t, e);
+      a && n.push(a);
+    }
+    return n.length > 0 ? n.join(" AND ") : null;
+  }
+}
+class $ extends w {
+  constructor(t, e) {
+    super(), this.left = t, this.right = e, this.name = `(${this.left.name || "spec"} OR ${this.right.name || "spec"})`, this.description = "At least one specification must be satisfied";
+  }
+  async isSatisfiedByAsync(t, e) {
+    const [i, s] = await Promise.all([
+      this.left.isSatisfiedByAsync(t, e),
+      this.right.isSatisfiedByAsync(t, e)
+    ]);
+    return i || s;
+  }
+  async explainFailureAsync(t, e) {
+    const [i, s] = await Promise.all([
+      this.left.isSatisfiedByAsync(t, e),
+      this.right.isSatisfiedByAsync(t, e)
+    ]);
+    if (!i && !s) {
+      const n = [];
+      if (this.left.explainFailureAsync) {
+        const a = await this.left.explainFailureAsync(t, e);
+        a && n.push(a);
+      }
+      if (this.right.explainFailureAsync) {
+        const a = await this.right.explainFailureAsync(t, e);
+        a && n.push(a);
+      }
+      return n.length > 0 ? `(${n.join(" OR ")})` : null;
+    }
+    return null;
+  }
+}
+class C extends w {
+  constructor(t) {
+    super(), this.spec = t, this.name = `NOT(${this.spec.name || "spec"})`, this.description = "The specification must NOT be satisfied";
+  }
+  async isSatisfiedByAsync(t, e) {
+    return !await this.spec.isSatisfiedByAsync(t, e);
+  }
+  async explainFailureAsync(t, e) {
+    return await this.spec.isSatisfiedByAsync(t, e) ? `Expected specification to fail: ${this.spec.name || "specification"}` : null;
+  }
+}
+class T extends u {
+  constructor(t) {
+    super(), this.inner = t, this.cache = /* @__PURE__ */ new WeakMap();
+  }
+  isSatisfiedBy(t) {
+    if (t === null || typeof t != "object" && typeof t != "function")
+      return this.inner.isSatisfiedBy(t);
+    const e = this.cache.get(t);
+    if (e !== void 0) return e;
+    const i = this.inner.isSatisfiedBy(t);
+    return this.cache.set(t, i), i;
+  }
+  /**
+   * Manually evict a candidate from the cache. Use when you know the
+   * candidate's relevant fields have changed and you want fresh evaluation
+   * without discarding cache entries for other candidates.
+   */
+  invalidate(t) {
+    this.cache.delete(t);
+  }
+  /**
+   * Forwarded to the inner spec, if it implements optional `explainFailure`.
+   * Skips the cache because failure explanations are typically only computed
+   * on-demand.
+   */
+  explainFailure(t) {
+    const e = this.inner;
+    return e.explainFailure ? e.explainFailure(t) ?? null : null;
+  }
+}
+class m extends u {
+  isSatisfiedBy(t) {
+    return !0;
+  }
+}
+class g extends u {
+  isSatisfiedBy(t) {
+    return !1;
+  }
+}
+class P extends u {
+  constructor(t) {
+    super(), this.predicate = t;
+  }
+  isSatisfiedBy(t) {
+    return this.predicate(t);
+  }
+}
+class N extends u {
+  constructor(t, e) {
+    super(), this.propertyName = t, this.expectedValue = e;
+  }
+  isSatisfiedBy(t) {
+    return t[this.propertyName] === this.expectedValue;
+  }
+}
+class V extends u {
+  constructor(t, e) {
+    super(), this.propertyName = t, this.possibleValues = e;
+  }
+  isSatisfiedBy(t) {
+    return this.possibleValues.includes(t[this.propertyName]);
+  }
+}
+class b extends u {
+  constructor(t, e, i) {
+    super(), this.propertyName = t, this.min = e, this.max = i;
+  }
+  isSatisfiedBy(t) {
+    const e = t[this.propertyName];
+    return e >= this.min && e <= this.max;
+  }
+}
+const j = {
+  /**
+   * Tworzy specyfikację zawsze prawdziwą
+   */
+  alwaysTrue() {
+    return new m();
+  },
+  /**
+   * Tworzy specyfikację zawsze fałszywą
+   */
+  alwaysFalse() {
+    return new g();
+  },
+  /**
+   * Tworzy specyfikację opartą o predykat
+   */
+  create(r) {
+    return new P(r);
+  },
+  /**
+   * Tworzy specyfikację sprawdzającą równość właściwości
+   */
+  propertyEquals(r, t) {
+    return new N(r, t);
+  },
+  /**
+   * Tworzy specyfikację sprawdzającą zawieranie się właściwości w zbiorze
+   */
+  propertyIn(r, t) {
+    return new V(r, t);
+  },
+  /**
+   * Tworzy specyfikację sprawdzającą zakres wartości
+   */
+  propertyBetween(r, t, e) {
+    return new b(r, t, e);
+  },
+  /**
+   * Łączy specyfikacje operatorem AND
+   */
+  and(...r) {
+    if (r.length === 0) return new m();
+    let t = r[0];
+    for (let e = 1; e < r.length; e++)
+      t = new x(t, r[e]);
+    return t;
+  },
+  /**
+   * Łączy specyfikacje operatorem OR
+   */
+  or(...r) {
+    if (r.length === 0) return new g();
+    let t = r[0];
+    for (let e = 1; e < r.length; e++)
+      t = new A(t, r[e]);
+    return t;
+  },
+  /**
+   * Neguje specyfikację
+   */
+  not(r) {
+    return new B(r);
+  }
+};
+class h {
+  constructor(t, e, i) {
+    this.property = t, this.message = e, this.context = i;
+  }
+  toString() {
+    return `${this.property}: ${this.message}`;
+  }
+}
+class d extends Error {
+  constructor(t) {
+    super(
+      `Validation failed with ${t.length} error(s): ${t.map((e) => e.toString()).join("; ")}`
+    ), this.name = "ValidationErrors", this.errors = t;
+  }
+  get length() {
+    return this.errors.length;
+  }
+}
+class p {
+  constructor() {
+    this.validationRules = [];
+  }
+  /**
+   * Adds a validation rule based on a specification
+   */
+  addRule(t, e, i, s) {
+    const n = {
+      specification: t,
+      message: e,
+      property: i || ""
+    };
+    return s !== void 0 && (n.context = s), this.validationRules.push(n), this;
+  }
+  /**
+   * Adds a rule for a specific object property
+   */
+  addPropertyRule(t, e, i, s, n) {
+    const a = {
+      isSatisfiedBy: (c) => e.isSatisfiedBy(s(c)),
+      // The following methods are not used in this context but must be implemented
+      and: () => {
+        throw new Error("Operation not supported");
+      },
+      or: () => {
+        throw new Error("Operation not supported");
+      },
+      not: () => {
+        throw new Error("Operation not supported");
+      }
+    };
+    return this.addRule(a, i, t, n);
+  }
+  /**
+   * Performs validation based on all specifications
+   */
+  validate(t) {
+    const e = [];
+    for (const i of this.validationRules)
+      i.specification.isSatisfiedBy(t) || e.push(new h(i.property || "", i.message, i.context));
+    return e.length > 0 ? o.fail(new d(e)) : o.ok(t);
+  }
+  /**
+   * Creates a validator with a single rule
+   */
+  static fromSpecification(t, e, i, s) {
+    return new p().addRule(t, e, i, s);
+  }
+  /**
+   * Creates an empty validator
+   */
+  static create() {
+    return new p();
+  }
+}
+class f {
+  constructor() {
+    this.rules = [], this.stopOnFirstFailure = !1, this.lastCondition = null;
+  }
+  addRule(t, e, i, s) {
+    return this.rules.push({
+      property: t,
+      validate: (n) => e(n) ? o.ok(!0) : o.fail(new h(t, i, s))
+    }), this;
+  }
+  addSpecification(t, e, i, s) {
+    return this.addRule(t, (n) => e.isSatisfiedBy(n), i, s);
+  }
+  /**
+   * Dodaje globalną specyfikację, która dotyczy całego obiektu
+   */
+  mustSatisfy(t, e, i) {
+    return this.addSpecification("", t, e, i);
+  }
+  /**
+   * Dodaje walidację dla konkretnej właściwości z użyciem specyfikacji
+   */
+  propertyMustSatisfy(t, e, i, s, n) {
+    return this.addRule(
+      t,
+      (a) => e.isSatisfiedBy(s(a)),
+      i,
+      n
+    );
+  }
+  /**
+   * Dodaje walidację dla zagnieżdżonego obiektu
+   */
+  addNested(t, e, i) {
+    return this.rules.push({
+      property: t,
+      validate: (s) => {
+        const n = i(s);
+        if (n == null)
+          return o.fail(
+            new h(t, "Cannot validate undefined or null nested object", {
+              path: t
+            })
+          );
+        const a = e.validate(n);
+        if (a.isFailure) {
+          const c = a.error.errors.map((l) => {
+            const S = {
+              ...l.context || {},
+              path: t + (l.property ? `.${l.property}` : ""),
+              originalPath: l.property || "",
+              parentPath: t
+            };
+            return new h(
+              `${t}${l.property ? `.${l.property}` : ""}`,
+              l.message,
+              S
+            );
+          });
+          return o.fail(
+            new h(t, "Nested validation failed", {
+              errors: c,
+              path: t,
+              errorCount: c.length
+            })
+          );
+        }
+        return o.ok(!0);
+      }
+    }), this;
+  }
+  /**
+   * Dodaje walidację warunkową
+   */
+  when(t, e) {
+    if (typeof t != "function")
+      throw new Error("Condition must be a function");
+    this.lastCondition = t;
+    const i = new f();
+    e(i);
+    for (const s of i.rules)
+      this.rules.push({
+        ...s,
+        condition: t
+      });
+    return this;
+  }
+  /**
+   * Dodaje walidację warunkową
+   */
+  otherwise(t) {
+    if (this.lastCondition === null || this.lastCondition === void 0)
+      throw new Error(
+        "Cannot call otherwise() without a preceding when() - lastCondition is null/undefined"
+      );
+    if (typeof this.lastCondition != "function")
+      throw new Error(
+        `Cannot call otherwise() - lastCondition is not a function but a ${typeof this.lastCondition}`
+      );
+    const e = this.lastCondition, i = (n) => !e(n), s = new f();
+    t(s);
+    for (const n of s.rules)
+      this.rules.push({
+        ...n,
+        condition: i
+      });
+    return this.lastCondition = null, this;
+  }
+  /**
+   * Dodaje walidację warunkową opartą na specyfikacji
+   */
+  whenSatisfies(t, e) {
+    return this.when((i) => t.isSatisfiedBy(i), e);
+  }
+  /**
+   * Konfiguruje walidator do zatrzymania po pierwszym błędzie
+   */
+  setStopOnFirstFailure() {
+    return this.stopOnFirstFailure = !0, this;
+  }
+  /**
+   * Przeprowadza walidację
+   */
+  validate(t) {
+    const e = [];
+    for (const i of this.rules) {
+      if (i.condition && !i.condition(t))
+        continue;
+      const s = i.validate(t);
+      if (s.isFailure && (e.push(s.error), this.stopOnFirstFailure))
+        break;
+    }
+    return e.length > 0 ? o.fail(new d(e)) : o.ok(t);
+  }
+  /**
+   * Łączy ten walidator z innym
+   */
+  and(t) {
+    const e = new f();
+    return e.rules = [...this.rules], e.addRule("", (i) => t.validate(i).isSuccess, "Failed combined validation"), e;
+  }
+  /**
+   * Tworzy nowy walidator ze specyfikacji
+   */
+  static fromSpecification(t, e, i) {
+    return new f().mustSatisfy(t, e, i);
+  }
+  static create() {
+    return new f();
+  }
+}
+const q = {
+  /**
+   * Tworzy nowy walidator reguł biznesowych
+   */
+  create() {
+    return f.create();
+  },
+  /**
+   * Tworzy walidator oparty na specyfikacji
+   */
+  fromSpecification(r, t, e) {
+    return p.fromSpecification(r, t, e);
+  },
+  /**
+   * Tworzy walidator łączący wiele walidatorów
+   */
+  combine(...r) {
+    return {
+      validate: (t) => {
+        const e = [];
+        for (const i of r) {
+          const s = i.validate(t);
+          s.isFailure && e.push(s.error);
+        }
+        if (e.length > 0) {
+          const i = e.flatMap((s) => s.errors);
+          return o.fail(new d(i));
+        }
+        return o.ok(t);
+      }
+    };
+  },
+  /**
+   * Waliduje obiekt bezpośrednio za pomocą specyfikacji
+   */
+  validateWithSpecification(r, t, e) {
+    return this.fromSpecification(t, e).validate(r);
+  },
+  /**
+   * Waliduje za pomocą wielu specyfikacji z własnymi komunikatami błędów
+   */
+  validateWithRules(r, t) {
+    const e = p.create();
+    for (const i of t)
+      e.addRule(i.specification, i.message, i.property);
+    return e.validate(r);
+  },
+  // Narzędzia konwersji
+  /**
+   * Konwertuje specyfikację na walidator
+   */
+  specificationToValidator(r, t, e) {
+    return this.fromSpecification(r, t, e);
+  },
+  /**
+   * Konwertuje walidator na specyfikację
+   */
+  validatorToSpecification(r) {
+    return u.create((t) => r.validate(t).isSuccess);
+  },
+  /**
+   * Tworzy walidator dla głęboko zagnieżdżonej struktury obiektów
+   */
+  forNestedPath(r, t) {
+    if (r.length === 0)
+      return t;
+    let e = t;
+    for (let i = r.length - 1; i >= 0; i--) {
+      const s = r[i], n = f.create();
+      n.addNested(s, e, (a) => a ? a[s] : void 0), e = n;
+    }
+    return e;
+  },
+  /**
+   * Waliduje głęboko zagnieżdżoną właściwość
+   */
+  validatePath(r, t, e) {
+    const s = ((a, c) => {
+      let l = a;
+      for (const S of c) {
+        if (l == null)
+          return;
+        if (typeof l == "object" && l !== null)
+          l = l[S];
+        else
+          return;
+      }
+      return l;
+    })(r, t);
+    if (s === void 0)
+      return o.fail(
+        new d([new h(t.join("."), "Path does not exist", { path: t })])
+      );
+    const n = e.validate(s);
+    if (n.isFailure) {
+      const a = n.error.errors.map((c) => {
+        const l = [...t];
+        return c.property && l.push(c.property), new h(l.join("."), c.message, {
+          ...c.context,
+          fullPath: l
+        });
+      });
+      return o.fail(new d(a));
+    }
+    return o.ok(r);
+  },
+  /**
+   * Używa zewnętrznego walidatora implementującego IValidator<T>
+   * Pozwala na integrację z bibliotekami takimi jak zod, class-validator, itp.
+   */
+  useExternal(r) {
+    return r;
+  }
+};
+class O {
+  constructor() {
+    this.name = "core", this.required = (t, e = "Field is required") => (i) => i.addRule(
+      t,
+      (s) => s[t] !== void 0 && s[t] !== null,
+      e
+    ), this.minLength = (t, e, i) => (s) => s.addRule(
+      t,
+      (n) => String(n[t]).length >= e,
+      i || `Minimum length is ${e}`
+    ), this.maxLength = (t, e, i) => (s) => s.addRule(
+      t,
+      (n) => String(n[t]).length <= e,
+      i || `Maximum length is ${e}`
+    ), this.pattern = (t, e, i = "Invalid format") => (s) => s.addRule(t, (n) => e.test(String(n[t])), i), this.range = (t, e, i, s) => (n) => n.addRule(
+      t,
+      (a) => {
+        const c = Number(a[t]);
+        return !isNaN(c) && c >= e && c <= i;
+      },
+      s || `Value must be between ${e} and ${i}`
+    ), this.email = (t, e = "Invalid email address") => (i) => i.addRule(
+      t,
+      (s) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(s[t])),
+      e
+    ), this.satisfies = (t, e) => (i) => i.mustSatisfy(t, e), this.propertySatisfies = (t, e, i, s) => (n) => n.propertyMustSatisfy(t, e, i, s), this.whenSatisfies = (t, e) => (i) => i.whenSatisfies(t, e), this.otherwise = (t) => (e) => e.otherwise(t), this.when = (t, e) => (i) => i.when(t, e);
+  }
+}
+const y = class y {
+  /**
+   * Register a domain-specific rule provider
+   */
+  static register(t) {
+    if (this.providers.has(t.name))
+      throw new Error(`Rule provider with name "${t.name}" is already registered`);
+    this.providers.set(t.name, t);
+  }
+  /**
+   * Get a specific rule provider by name
+   */
+  static getProvider(t) {
+    const e = this.providers.get(t);
+    if (!e)
+      throw new Error(`Rule provider "${t}" not found`);
+    return e;
+  }
+  /**
+   * Get core rules
+   */
+  static get Rules() {
+    return this.core;
+  }
+  /**
+   * Access domain-specific rules
+   */
+  static forDomain(t) {
+    return this.getProvider(t);
+  }
+};
+y.providers = /* @__PURE__ */ new Map(), y.core = new O();
+let v = y;
+class I {
+  constructor(t) {
+    this.schema = t;
+  }
+  /**
+   * Helper method do tworzenia ValidationError z kontekstem
+   */
+  createValidationError(t, e, i) {
+    return new h(t, e, i);
+  }
+  /**
+   * Helper method do tworzenia ValidationErrors z tablicy błędów
+   */
+  createValidationErrors(t) {
+    return new d(t);
+  }
+  /**
+   * Helper method do konwersji ścieżki na string
+   */
+  pathToString(t) {
+    return t.join(".");
+  }
+  /**
+   * Helper method do tworzenia Result.fail z błędami
+   */
+  failWithErrors(t) {
+    return o.fail(this.createValidationErrors(t));
+  }
+  /**
+   * Helper method do tworzenia Result.ok
+   */
+  success(t) {
+    return o.ok(t);
+  }
+}
+class W {
+  /**
+   * Tworzy prosty adapter z funkcji walidacyjnej
+   */
+  static create(t, e = "") {
+    return {
+      validate: (i) => {
+        const s = t(i);
+        if (!s.success && s.errors) {
+          const n = s.errors.map(
+            (a) => new h(e, a)
+          );
+          return o.fail(new d(n));
+        }
+        return o.ok(i);
+      }
+    };
+  }
+  /**
+   * Łączy wiele adapterów w jeden
+   */
+  static combine(...t) {
+    return {
+      validate: (e) => {
+        const i = [];
+        for (const s of t) {
+          const n = s.validate(e);
+          n.isFailure && i.push(...n.error.errors);
+        }
+        return i.length > 0 ? o.fail(new d(i)) : o.ok(e);
+      }
+    };
+  }
+  /**
+   * Tworzy adapter z custom error mapping
+   */
+  static withErrorMapping(t, e) {
+    return {
+      validate: (i) => {
+        const s = t(i);
+        if (!s.success && s.errors) {
+          const n = s.errors.map(e);
+          return o.fail(new d(n));
+        }
+        return o.ok(i);
+      }
+    };
+  }
+}
+export {
+  W as AdapterUtils,
+  g as AlwaysFalseSpecification,
+  m as AlwaysTrueSpecification,
+  R as AndAsyncSpecification,
+  x as AndSpecification,
+  w as AsyncCompositeSpecification,
+  I as BaseValidationAdapter,
+  f as BusinessRuleValidator,
+  u as CompositeSpecification,
+  T as MemoizedSpecification,
+  C as NotAsyncSpecification,
+  B as NotSpecification,
+  $ as OrAsyncSpecification,
+  A as OrSpecification,
+  P as PredicateSpecification,
+  b as PropertyBetweenSpecification,
+  N as PropertyEqualsSpecification,
+  V as PropertyInSpecification,
+  v as RulesRegistry,
+  j as Specification,
+  p as SpecificationValidator,
+  h as ValidationError,
+  d as ValidationErrors,
+  q as ValidationFacade
+};