@strictly/define 0.0.12 → 0.0.14

package/types/validating_definitions.ts

@@ -1,3 +1,4 @@
+import { type FunctionalValidator } from 'validation/validator'
 import {
   type ObjectFieldKey,
   type RecordKeyType,
@@ -11,18 +12,21 @@ export type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
   readonly definition: T,
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Rule<E = any, V = any> = (v: V) => E | null
-
 export type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never
 
+export type ContextOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer _E, infer C> ? C
+  : never
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Rule<E, C, V = any> = FunctionalValidator<V, E, string, C>
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ValidatingTypeDef<E = any> =
-  | ValidatingLiteralTypeDef<E>
-  | ValidatingListTypeDef<E>
-  | ValidatingRecordTypeDef<E>
-  | ValidatingObjectTypeDef<E>
-  | ValidatingUnionTypeDef<E>
+export type ValidatingTypeDef<E = any, C = any> =
+  | ValidatingLiteralTypeDef<E, C>
+  | ValidatingListTypeDef<E, C>
+  | ValidatingRecordTypeDef<E, C>
+  | ValidatingObjectTypeDef<E, C>
+  | ValidatingUnionTypeDef<E, C>
 
 // used to avoid TS complaining about circular references
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -30,10 +34,10 @@ type AnyTypeDef = any
 
 // literal
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ValidatingLiteralTypeDef<E = any, V = any> = {
+export type ValidatingLiteralTypeDef<E = any, C = any, V = any> = {
   readonly type: TypeDefType.Literal,
   readonly valuePrototype: [V],
-  readonly rule: Rule<E>,
+  readonly rule: Rule<E, C>,
   readonly required: boolean,
   readonly readonly: boolean,
 }
@@ -42,12 +46,14 @@ export type ValidatingLiteralTypeDef<E = any, V = any> = {
 export type ValidatingListTypeDef<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C = any,
   Ele extends ValidatingTypeDef = AnyTypeDef,
 > = {
   readonly type: TypeDefType.List,
   // readonly is inherited by the output
   readonly elements: Ele,
-  readonly rule: Rule<E>,
+  readonly rule: Rule<E, C>,
   readonly required: boolean,
   readonly readonly: boolean,
 }
@@ -56,6 +62,8 @@ export type ValidatingListTypeDef<
 export type ValidatingRecordTypeDef<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C = any,
   K extends RecordKeyType = RecordKeyType,
   // if `V` includes `undefined` the map is partial
   V extends ValidatingTypeDef | undefined = AnyTypeDef,
@@ -65,7 +73,7 @@ export type ValidatingRecordTypeDef<
   readonly keyPrototype: K,
   // readonly is inherited by the output
   readonly valueTypeDef: V,
-  readonly rule: Rule<E>,
+  readonly rule: Rule<E, C>,
   readonly required: boolean,
   readonly readonly: boolean,
 }
@@ -85,11 +93,13 @@ export type ValidatingObjectTypeDefFields = {
 export type ValidatingObjectTypeDef<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C = any,
   Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields,
 > = {
   readonly type: TypeDefType.Object,
   readonly fields: Fields,
-  readonly rule: Rule<E>,
+  readonly rule: Rule<E, C>,
   readonly required: boolean,
   readonly readonly: boolean,
 }
@@ -97,13 +107,15 @@ export type ValidatingObjectTypeDef<
 export type ValidatingUnionTypeDef<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C = any,
   D extends string | null = string | null,
   U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>,
 > = {
   readonly discriminator: D,
   readonly type: TypeDefType.Union,
   readonly unions: U,
-  readonly rule: Rule<E>,
+  readonly rule: Rule<E, C>,
   readonly required: boolean,
   readonly readonly: boolean,
 }

package/types/validating_type_def_with_error.ts

@@ -17,47 +17,47 @@ import {
 //   ? T & { rule: Rule<E1 | E2> }
 //   : never
 
-export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E> = T extends ValidatingLiteralTypeDef
-  ? ValidatingLiteralTypeDefWithError<T, E>
-  : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E>
-  : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E>
-  : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E>
-  : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E>
+export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E, C> = T extends ValidatingLiteralTypeDef
+  ? ValidatingLiteralTypeDefWithError<T, E, C>
+  : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E, C>
+  : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E, C>
+  : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E, C>
+  : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E, C>
   : never
 
-type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2> = T extends
-  ValidatingLiteralTypeDef<infer E1, infer V> ? {
+type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2, C2> = T extends
+  ValidatingLiteralTypeDef<infer E1, infer C1, infer V> ? {
     readonly type: TypeDefType.Literal,
     readonly valuePrototype: [V],
-    readonly rule: Rule<E1 | E2>,
+    readonly rule: Rule<E1 | E2, C1 & C2>,
     readonly required: boolean,
     readonly readonly: boolean,
   }
   : never
 
-type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2> = T extends
-  ValidatingListTypeDef<infer E1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2, C2> = T extends
+  ValidatingListTypeDef<infer E1, infer C1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
       readonly type: TypeDefType.List,
       readonly elements: E,
-      readonly rule: Rule<E1 | E2>,
+      readonly rule: Rule<E1 | E2, C1 & C2>,
       readonly required: boolean,
       readonly readonly: boolean,
     }
   : {
     readonly type: TypeDefType.List,
     elements: E,
-    readonly rule: Rule<E1 | E2>,
+    readonly rule: Rule<E1 | E2, C1 & C2>,
     readonly required: boolean,
     readonly readonly: boolean,
   }
   : never
 
-type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T extends
-  ValidatingRecordTypeDef<infer E1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2, C2> = T extends
+  ValidatingRecordTypeDef<infer E1, infer C1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
       readonly type: TypeDefType.Record,
       readonly keyPrototype: K,
       readonly valueTypeDef: V,
-      readonly rule: Rule<E1 | E2>,
+      readonly rule: Rule<E1 | E2, C1 & C2>,
       readonly required: boolean,
       readonly readonly: boolean,
     }
@@ -65,28 +65,28 @@ type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T
     readonly type: TypeDefType.Record,
     readonly keyPrototype: K,
     valueTypeDef: V,
-    readonly rule: Rule<E1 | E2>,
+    readonly rule: Rule<E1 | E2, C1 & C2>,
     readonly required: boolean,
     readonly readonly: boolean,
   }
   : never
 
-type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends
-  ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2, C2> = T extends
+  ValidatingObjectTypeDef<infer E1, infer C1, infer Fields> ? {
     readonly type: TypeDefType.Object,
     readonly fields: Fields,
-    readonly rule: Rule<E1 | E2>,
+    readonly rule: Rule<E1 | E2, C1 & C2>,
     readonly required: boolean,
     readonly readonly: boolean,
   }
   : never
 
-type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends
-  ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2, C2> = T extends
+  ValidatingUnionTypeDef<infer E1, infer C1, infer D, infer U> ? {
     readonly type: TypeDefType.Union,
     readonly discriminator: D,
     readonly unions: U,
-    readonly rule: Rule<E1 | E2>,
+    readonly rule: Rule<E1 | E2, C1 & C2>,
     readonly required: boolean,
     readonly readonly: boolean,
   }

package/validation/validator.ts

@@ -1,4 +1,5 @@
 import { type Simplify } from 'type-fest'
+import { CompositeValidator } from './validators/composite_validator'
 
 export type Annotations = {
   readonly required: boolean,
@@ -89,6 +90,26 @@ export function validate<
   }
 }
 
+export function mergeValidators<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E1 = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E2 = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C1 = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  C2 = any,
+>(
+  v1: Validator<V, E1, ValuePath, C1>,
+  v2: Validator<V, E2, ValuePath, C2>,
+): Validator<V, E1 | E2, ValuePath, C1 & C2> {
+  return new CompositeValidator<V, E1 | E2, ValuePath, C1 & C2>(v1, v2)
+}
+
 export function annotations<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   V = any,

package/validation/validators/composite_validator.ts

@@ -0,0 +1,42 @@
+import {
+  type AnnotatedValidator,
+  type Annotations,
+  annotations,
+  validate,
+  type Validator,
+} from 'validation/validator'
+
+export class CompositeValidator<V, E, ValuePath extends string, C> implements AnnotatedValidator<V, E, ValuePath, C> {
+  private readonly validators: readonly Validator<V, E, ValuePath, C>[]
+  constructor(...validators: readonly Validator<V, E, ValuePath, C>[]) {
+    this.validators = validators
+  }
+
+  validate(v: V, valuePath: ValuePath, context: C) {
+    return this.validators.reduce<E | null>((error, validator) => {
+      if (error != null) {
+        return error
+      }
+      return validate(validator, v, valuePath, context)
+    }, null)
+  }
+
+  annotations(valuePath: ValuePath, context: C): Annotations {
+    return this.validators.reduce<Annotations>(({
+      required,
+      readonly,
+    }, validator) => {
+      const {
+        readonly: validatorReadonly,
+        required: validatorRequired,
+      } = annotations(validator, valuePath, context)
+      return {
+        required: required || validatorRequired,
+        readonly: readonly || validatorReadonly,
+      }
+    }, {
+      required: false,
+      readonly: false,
+    })
+  }
+}