@structuralists/scaffolding 0.4.1 → 0.5.0

package/src/forms/validators/validators.ts

@@ -0,0 +1,95 @@
+import type { Refinement, Validator } from '../validations/types';
+
+// Standard-library validators. Each one declares its refinement explicitly —
+// `Validator<Input, Excluded>` — even when it narrows nothing (`never`).
+// The marker is attached with `Object.assign(fn, {} as Refinement<X>)`: a
+// pure type-level tag, never read at runtime.
+
+// Rules out null, undefined, and the empty string. The only refining
+// validator in the baseline set: submit-time type becomes
+// `Exclude<FieldType, null | undefined | ''>`.
+export const notEmpty = (
+  fieldName: string,
+): Validator<unknown, null | undefined | ''> =>
+  Object.assign(
+    (val: unknown) =>
+      val == null || val === '' ? `'${fieldName}' cannot be empty` : null,
+    {} as Refinement<null | undefined | ''>,
+  );
+
+// Minimum string length. Nullish and empty values pass — requiredness is
+// notEmpty's job; compose via allOf. Narrows nothing: TypeScript has no type
+// for "string of at least n characters".
+export const minLength = (
+  fieldName: string,
+  min: number,
+): Validator<string | null | undefined> =>
+  Object.assign(
+    (val: string | null | undefined) =>
+      val != null && val !== '' && val.length < min
+        ? `'${fieldName}' must be at least ${min} characters`
+        : null,
+    {} as Refinement,
+  );
+
+// Regex test. Nullish and empty values pass (compose with notEmpty for
+// requiredness). Narrows nothing.
+export const matches = (
+  fieldName: string,
+  pattern: RegExp,
+  description: string,
+): Validator<string | null | undefined> =>
+  Object.assign(
+    (val: string | null | undefined) =>
+      val != null && val !== '' && !pattern.test(val)
+        ? `'${fieldName}' must be ${description}`
+        : null,
+    {} as Refinement,
+  );
+
+// Minimum numeric value. Nullish passes. Narrows nothing.
+export const min = (
+  fieldName: string,
+  minimum: number,
+): Validator<number | null | undefined> =>
+  Object.assign(
+    (val: number | null | undefined) =>
+      val != null && val < minimum
+        ? `'${fieldName}' must be at least ${minimum}`
+        : null,
+    {} as Refinement,
+  );
+
+type ExcludedOf<V> = V extends Refinement<infer Excluded> ? Excluded : never;
+
+// The composed input is the *intersection* of the parts' inputs: a value the
+// composite accepts must be acceptable to every part. Inferring `I` from the
+// union of function types puts it in contravariant position, which is what
+// makes TS produce the intersection. Computing it this way — rather than as
+// a standalone `Input` type parameter inferred from the arguments — matters:
+// a separate parameter resolves from whichever argument TS visits first
+// (e.g. `unknown` from notEmpty) and then rejects narrower siblings when the
+// call has no outer contextual type, as inside an inline constraints object.
+type InputOf<Validators extends readonly ((val: never) => string | null)[]> =
+  Validators[number] extends (val: infer I) => string | null ? I : never;
+
+// Composes validators on one field: first error wins. The refinement is the
+// union of the parts' refinements — running all of them earns all of their
+// narrowings. `const Validators` keeps each member's precise type so
+// `ExcludedOf` can extract markers; bare functions contribute `never`.
+export const allOf = <
+  const Validators extends readonly ((val: never) => string | null)[],
+>(
+  ...validators: Validators
+): Validator<InputOf<Validators>, ExcludedOf<Validators[number]>> =>
+  Object.assign(
+    (val: InputOf<Validators>) => {
+      for (const validator of validators) {
+        // Safe: each part's declared input is a supertype of the intersection.
+        const error = (validator as (v: unknown) => string | null)(val);
+        if (error != null) return error;
+      }
+      return null;
+    },
+    {} as Refinement<ExcludedOf<Validators[number]>>,
+  );