@strictly/define 0.0.1 → 0.0.3

package/transformers/flatteners/value_path_to_type_path.ts

@@ -13,13 +13,13 @@ import {
 } from 'types/definitions'
 
 export function valuePathToTypePath<
-  JsonPaths extends Record<string, string>,
-  ValuePath extends keyof JsonPaths,
+  ValuePathsToTypePaths extends Record<string, string>,
+  ValuePath extends keyof ValuePathsToTypePaths,
 >(
   { definition: typeDef }: Type,
   valuePath: ValuePath,
   allowMissingPaths: boolean = false,
-): JsonPaths[ValuePath] {
+): ValuePathsToTypePaths[ValuePath] {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const valueSteps = (valuePath as string).split(/\.|\[/g)
   assertEqual(valueSteps[0], '$')
@@ -33,7 +33,7 @@ export function valuePathToTypePath<
   )
   typeSteps.unshift('$')
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return typeSteps.join('.') as JsonPaths[ValuePath]
+  return typeSteps.join('.') as ValuePathsToTypePaths[ValuePath]
 }
 
 function internalJsonValuePathToTypePath(

package/types/builders.ts

@@ -2,116 +2,245 @@ import {
   type IsFieldReadonly,
 } from '@strictly/base'
 import {
-  type ListTypeDef,
-  type LiteralTypeDef,
   type ObjectFieldKey,
-  type ObjectTypeDef,
   type RecordKeyType,
-  type RecordTypeDef,
   type Type,
   type TypeDef,
   TypeDefType,
   type UnionKey,
-  type UnionTypeDef,
 } from './definitions'
+import {
+  type TypeOfType,
+  typeOfType,
+} from './type_of_type'
+import {
+  type Rule,
+  type ValidatingListTypeDef,
+  type ValidatingLiteralTypeDef,
+  type ValidatingObjectTypeDef,
+  type ValidatingRecordTypeDef,
+  type ValidatingType,
+  type ValidatingTypeDef,
+  type ValidatingUnionTypeDef,
+} from './validating_definitions'
+import { type ValidatingTypeDefWithError } from './validating_type_def_with_error'
+import {
+  type ValueOfType,
+  type ValueOfTypeDef,
+} from './value_of_type'
+
+function emptyRule() {
+  return null
+}
 
-class TypeDefBuilder<T extends TypeDef> implements Type<T> {
+class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
   constructor(readonly definition: T) {
   }
 
-  // returns just the relevant types, which can help typescript
-  // from complaining about infinitely deep data structures
-  get narrow(): Type<T> {
+  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>) {
+    return new TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        rule: (value: any) => {
+          return this.definition.rule(value) || rule(value)
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
+    )
+  }
+
+  required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>
+  required<
+    RequiredError,
+  >(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<
+    ValidatingTypeDefWithError<T, RequiredError>
+  >
+  required<RequiredError = never>(rule?: Rule<RequiredError, ValueOfType<typeof this.narrow>>) {
+    return new TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        rule: (v: any) => {
+          return this.definition.rule(v) || rule?.(v)
+        },
+        required: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
+    )
+  }
+
+  readonly(): TypeDefBuilder<T> {
+    return new TypeDefBuilder<T>(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        readonly: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
+    )
+  }
+
+  // should only be used in tests requiring Types, client code should be happy with validating types
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  get _type(): TypeOfType<Type<T>> {
+    return typeOfType<Type<T>>(this)
+  }
+
+  get narrow(): ValidatingType<T> {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return {
       definition: this.definition,
-    }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any
   }
 }
 
-class LiteralTypeDefBuilder<T> extends TypeDefBuilder<LiteralTypeDef<T>> {
-}
-
 class ListTypeDefBuilder<
-  T extends ListTypeDef,
+  T extends ValidatingListTypeDef,
 > extends TypeDefBuilder<T> {
-  readonly(): ListTypeDefBuilder<{
+  readonlyElements(): ListTypeDefBuilder<{
     readonly type: TypeDefType.List,
     readonly elements: T['elements'],
+    readonly rule: T['rule'],
+    readonly required: boolean,
+    readonly readonly: boolean,
   }> {
-    return this
+    return new ListTypeDefBuilder({
+      ...this.definition,
+      elements: {
+        ...this.definition.elements,
+        readonly: true,
+      },
+    })
   }
 }
 
-class RecordTypeDefBuilder<T extends RecordTypeDef> extends TypeDefBuilder<T> {
-  partial(): IsFieldReadonly<T, 'valueTypeDef'> extends true ? RecordTypeDefBuilder<{
+class RecordTypeDefBuilder<T extends ValidatingRecordTypeDef> extends TypeDefBuilder<T> {
+  partialKeys(): IsFieldReadonly<T, 'valueTypeDef'> extends true ? RecordTypeDefBuilder<{
       readonly type: TypeDefType.Record,
       readonly keyPrototype: T['keyPrototype'],
       readonly valueTypeDef: T['valueTypeDef'] | undefined,
+      readonly rule: T['rule'],
+      readonly required: boolean,
+      readonly readonly: boolean,
     }>
     : RecordTypeDefBuilder<{
       readonly type: TypeDefType.Record,
       readonly keyPrototype: T['keyPrototype'],
       valueTypeDef: T['valueTypeDef'] | undefined,
+      readonly rule: T['rule'],
+      readonly required: boolean,
+      readonly readonly: boolean,
     }>
   {
     return this
   }
 
-  readonly(): RecordTypeDefBuilder<{
+  readonlyKeys(): RecordTypeDefBuilder<{
     readonly type: TypeDefType.Record,
     readonly keyPrototype: T['keyPrototype'],
     readonly valueTypeDef: T['valueTypeDef'],
+    readonly rule: T['rule'],
+    readonly required: boolean,
+    readonly readonly: boolean,
   }> {
-    return this
+    return new RecordTypeDefBuilder({
+      ...this.definition,
+      valueTypeDef: {
+        ...this.definition.valueTypeDef,
+        readonly: true,
+      },
+    })
   }
 }
 
 class ObjectTypeDefBuilder<
-  Fields extends Readonly<Record<ObjectFieldKey, TypeDef>> = {},
+  E,
+  Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {},
 > extends TypeDefBuilder<
-  ObjectTypeDef<Fields>
+  ValidatingObjectTypeDef<E, Fields>
 > {
-  set<
+  field<
     Name extends string,
-    T extends TypeDef,
+    T extends ValidatingTypeDef,
   >(
     name: Name,
-    { definition: typeDef }: Type<T>,
+    { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
+    E,
     Fields & Record<Name, T>
+  >
+  field<
+    Name extends string,
+    T extends ValidatingTypeDef,
+    RequiredError,
+  >(
+    name: Name,
+    { definition }: Type<T>,
+    rule: Rule<RequiredError, ValueOfTypeDef<T>>,
+  ): ObjectTypeDefBuilder<
+    E,
+    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
+  >
+  field<
+    Name extends string,
+    T extends ValidatingTypeDef,
+    RequiredError = never,
+  >(
+    name: Name,
+    { definition }: Type<T>,
+    rule?: Rule<RequiredError, ValueOfTypeDef<T>>,
+  ): ObjectTypeDefBuilder<
+    E,
+    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
   > {
-    const newFields = {
-      [name]: typeDef,
-    }
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
-      Fields & Record<Name, T>
+      E,
+      Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
     >({
-      type: TypeDefType.Object,
+      ...this.definition,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       fields: {
         ...this.definition.fields,
-        ...newFields,
-      },
+        [name]: {
+          ...definition,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          rule: function (v: any) {
+            return definition.rule(v) || rule?.(v)
+          },
+          required: true,
+        },
+      } as Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>,
     })
   }
 
-  setReadonly<
+  readonlyField<
     Name extends string,
-    T extends TypeDef,
+    T extends ValidatingTypeDef,
   >(
     name: Name,
-    { definition: typeDef }: Type<T>,
+    { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
+    E,
     Fields & Readonly<Record<Name, T>>
   > {
     const newFields = {
-      [name]: typeDef,
+      [name]: {
+        ...definition,
+        required: true,
+        readonly: true,
+      },
     }
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
+      E,
       Fields & Readonly<Record<Name, T>>
     >({
-      type: TypeDefType.Object,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields,
@@ -119,23 +248,27 @@ class ObjectTypeDefBuilder<
     })
   }
 
-  setOptional<
+  optionalField<
     Name extends string,
-    T extends TypeDef,
+    T extends ValidatingTypeDef,
   >(
     name: Name,
-    { definition: typeDef }: Type<T>,
+    { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
+    E,
     Fields & Partial<Record<Name, T>>
   > {
     const newFields = {
-      [name]: typeDef,
+      [name]: {
+        ...definition,
+      },
     }
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
+      E,
       Fields & Partial<Record<Name, T>>
     >({
-      type: TypeDefType.Object,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields,
@@ -143,23 +276,28 @@ class ObjectTypeDefBuilder<
     })
   }
 
-  setReadonlyOptional<
+  readonlyOptionalField<
     Name extends string,
     T extends TypeDef,
   >(
     name: Name,
-    { definition: typeDef }: Type<T>,
+    { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
+    E,
     Fields & Partial<Readonly<Record<Name, T>>>
   > {
     const newFields = {
-      [name]: typeDef,
+      [name]: {
+        ...definition,
+        readonly: true,
+      },
     }
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
+      E,
       Fields & Partial<Readonly<Record<Name, T>>>
     >({
-      type: TypeDefType.Object,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields,
@@ -169,15 +307,17 @@ class ObjectTypeDefBuilder<
 }
 
 class UnionTypeDefBuilder<
+  E,
   D extends string | null,
   U extends Record<UnionKey, TypeDef>,
 > extends TypeDefBuilder<
-  UnionTypeDef<
+  ValidatingUnionTypeDef<
+    E,
     D,
     U
   >
 > {
-  add<
+  or<
     K extends Exclude<UnionKey, keyof U>,
     T extends TypeDef,
   >(
@@ -185,15 +325,13 @@ class UnionTypeDefBuilder<
     {
       definition: typeDef,
     }: Type<T>,
-  ): UnionTypeDefBuilder<D, Readonly<Record<K, T>> & U> {
+  ): UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U> {
     const {
-      discriminator,
       unions,
     } = this.definition
-    return new UnionTypeDefBuilder<D, Readonly<Record<K, T>> & U>(
+    return new UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U>(
       {
-        type: TypeDefType.Union,
-        discriminator: discriminator,
+        ...this.definition,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         unions: {
           ...unions,
@@ -204,10 +342,13 @@ class UnionTypeDefBuilder<
   }
 }
 
-export function literal<T>(value?: [T]): LiteralTypeDefBuilder<T> {
-  return new LiteralTypeDefBuilder({
+export function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>> {
+  return new TypeDefBuilder({
     type: TypeDefType.Literal,
     valuePrototype: value!,
+    rule: emptyRule,
+    readonly: false,
+    required: false,
   })
 }
 
@@ -216,10 +357,16 @@ export const numberType = literal<number>()
 export const booleanType = literal<boolean>()
 export const nullType = literal([null])
 
-export function nullable<T extends TypeDef>(nonNullable: Type<T>): UnionTypeDefBuilder<null, {
-  readonly ['0']: T,
-  readonly ['1']: LiteralTypeDef<null>,
-}> {
+export function nullable<
+  T extends ValidatingTypeDef,
+>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<
+  never,
+  null,
+  {
+    readonly ['0']: T,
+    readonly ['1']: ValidatingLiteralTypeDef<never, null>,
+  }
+> {
   return new UnionTypeDefBuilder(
     {
       type: TypeDefType.Union,
@@ -228,57 +375,78 @@ export function nullable<T extends TypeDef>(nonNullable: Type<T>): UnionTypeDefB
         ['0']: nonNullable.definition,
         ['1']: nullType.definition,
       },
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      rule: emptyRule as Rule<never>,
+      readonly: false,
+      required: false,
     },
   )
 }
 
-export function list<T extends TypeDef>(elements: Type<T>): ListTypeDefBuilder<{
+export function list<T extends ValidatingTypeDef>(elements: ValidatingType<T>): ListTypeDefBuilder<{
   readonly type: TypeDefType.List,
   elements: T,
+  readonly rule: Rule<never>,
+  readonly readonly: boolean,
+  readonly required: boolean,
 }> {
   // have to explicitly supply types as TS will infinitely recurse trying to infer them!
-  return new ListTypeDefBuilder<ListTypeDef<T>>({
+  return new ListTypeDefBuilder<ValidatingListTypeDef<never, T>>({
     type: TypeDefType.List,
     elements: elements.definition,
+    rule: emptyRule,
+    readonly: false,
+    required: false,
   })
 }
 
 export function record<
-  V extends Type,
+  V extends ValidatingType,
   // NOTE if we swap these generics and the caller forgets to supply the second one (so the Type)
   // TSC will freeze
   K extends RecordKeyType,
->({ definition: typeDef }: V) {
+>({ definition: valueTypeDef }: V) {
   return new RecordTypeDefBuilder<{
     readonly type: TypeDefType.Record,
     readonly keyPrototype: K,
     valueTypeDef: V['definition'],
+    readonly rule: Rule<never>,
+    readonly readonly: boolean,
+    readonly required: boolean,
   }>({
     type: TypeDefType.Record,
-    // eslint-disable-next-line no-undefined
     keyPrototype: undefined!,
-    valueTypeDef: typeDef,
+    valueTypeDef,
+    rule: emptyRule,
+    readonly: false,
+    required: false,
   })
 }
 
-export function object(): ObjectTypeDefBuilder<{}> {
+export function object(): ObjectTypeDefBuilder<never, {}> {
   // have to explicitly supply types as TS will infinitely recurse trying to infer them!
-  return new ObjectTypeDefBuilder<{}>({
+  return new ObjectTypeDefBuilder<never, {}>({
     type: TypeDefType.Object,
     fields: {},
+    rule: emptyRule,
+    readonly: false,
+    required: false,
   })
 }
 
-export function union<D extends null>(): UnionTypeDefBuilder<D, {}>
-export function union<D extends string>(discriminator: D): UnionTypeDefBuilder<D, {}>
-export function union<D extends string | null>(discriminator?: D): UnionTypeDefBuilder<D, {}> {
+export function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>
+export function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>
+export function union<D extends string | null>(discriminator?: D): UnionTypeDefBuilder<never, D, {}> {
   // have to explicitly supply types as TS will infinitely recurse trying to infer them!
-  return new UnionTypeDefBuilder<D, {}>(
+  return new UnionTypeDefBuilder<never, D, {}>(
     {
       type: TypeDefType.Union,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       discriminator: (discriminator ?? null) as D,
       unions: {},
+      rule: emptyRule,
+      readonly: false,
+      required: false,
     },
   )
 }

package/types/definitions.ts

@@ -73,9 +73,9 @@ export type RecordTypeDef<
   readonly valueTypeDef: V,
 }
 
-// structured type
+// object type
 // could be replaced with a map and an intersection
-export type ObjectFieldKey = string | number
+export type ObjectFieldKey = string
 
 // NOTE we use the `readonly` and `?` (partial) status of these field definitions
 // to describe the same attributes of the fields

package/types/{flattened_accessors_of.ts → flattened_accessors_of_type.ts}

@@ -1,5 +1,5 @@
 import { type Type } from './definitions'
-import { type FlattenedValueTypesOf } from './flattened_value_types_of'
+import { type FlattenedValuesOfType } from './flattened_values_of_type'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Accessor<T = any> = {
@@ -7,9 +7,9 @@ export type Accessor<T = any> = {
   set(v: T): void,
 }
 
-export type FlattenedAccessorsOf<
+export type FlattenedAccessorsOfType<
   T extends Type,
-  Flattened extends Readonly<Record<string, Accessor>> = FlattenedValueTypesOf<T>,
+  Flattened extends Readonly<Record<string, Accessor>> = FlattenedValuesOfType<T>,
 > = {
   readonly [K in keyof Flattened]: Accessor<Flattened[K]>
 }

package/types/{flattened_type_defs_of.ts → flattened_types_of_type.ts}

@@ -14,11 +14,11 @@ import {
   type Depths,
   type StartingDepth,
 } from './flattened'
-import { type JsonPathOf } from './json_path_of'
+import { type PathOf } from './path_of'
 
 // NOTE removing any ternary from this file improves the performance and the depth of data structure we can go to
 
-export type FlattenedTypeDefsOf<
+export type FlattenedTypesOfType<
   T extends Type,
   SegmentOverride extends string | null,
   Path extends string = '$',
@@ -66,7 +66,7 @@ type InternalFlattenedTypeDefsOfListChildren<
 > = InternalFlattenedTypeDefsOf<
   T['elements'],
   SegmentOverride,
-  JsonPathOf<Path, number, SegmentOverride>,
+  PathOf<Path, number, SegmentOverride>,
   '',
   Depth
 >
@@ -79,7 +79,7 @@ type InternalFlattenedTypeDefsOfRecordChildren<
 > = InternalFlattenedTypeDefsOf<
   T['valueTypeDef'],
   SegmentOverride,
-  JsonPathOf<Path, T['keyPrototype'], SegmentOverride>,
+  PathOf<Path, T['keyPrototype'], SegmentOverride>,
   '',
   Depth
 >
@@ -90,14 +90,24 @@ type InternalFlattenedTypeDefsOfObjectChildren<
   Path extends string,
   Qualifier extends string,
   Depth extends number,
-> = T extends ObjectTypeDef<infer Fields> ? {} extends Fields ? {} : keyof Fields extends string ? UnionToIntersection<{
-      readonly [K in keyof Fields]-?: InternalFlattenedTypeDefsOf<
-        Exclude<Fields[K], undefined>,
-        SegmentOverride,
-        JsonPathOf<Path, `${Qualifier}${K}`, null>,
-        '',
-        Depth
-      >
+> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+      readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<
+          UnionTypeDef<null, {
+            readonly '0': Exclude<Fields[K], undefined>,
+            readonly '1': LiteralTypeDef<undefined>,
+          }>,
+          SegmentOverride,
+          PathOf<Path, `${Qualifier}${K}`, null>,
+          '',
+          Depth
+        >
+        : InternalFlattenedTypeDefsOf<
+          Exclude<Fields[K], undefined>,
+          SegmentOverride,
+          PathOf<Path, `${Qualifier}${K}`, null>,
+          '',
+          Depth
+        >
     }[keyof Fields]>
   : never
   : never