@strictly/define 0.0.1 → 0.0.2

package/index.ts

@@ -1,20 +1,26 @@
 export * from './transformers/copies/copy'
 export * from './transformers/copies/mobx_copy'
-export * from './transformers/flatteners/flatten_accessors_of'
+export * from './transformers/flatteners/flatten_accessors_of_type'
 export * from './transformers/flatteners/flatten_json_value_to_type_paths_of'
-export * from './transformers/flatteners/flatten_type_defs_of'
-export * from './transformers/flatteners/flatten_value_type_to'
+export * from './transformers/flatteners/flatten_types_of_type'
+export * from './transformers/flatteners/flatten_validators_of_validating_type'
+export * from './transformers/flatteners/flatten_value_to'
+export * from './transformers/flatteners/flatten_values_of_type'
 export * from './transformers/flatteners/json_path'
 export * from './transformers/flatteners/value_path_to_type_path'
 export * from './types/builders'
 export * from './types/definitions'
-export * from './types/flattened_accessors_of'
-export * from './types/flattened_type_defs_of'
-export * from './types/flattened_value_types_of'
-export * from './types/json_paths_of'
-export * from './types/mobx_value_type_of'
-export * from './types/readonly_type_def_of'
+export * from './types/flattened_accessors_of_type'
+export * from './types/flattened_types_of_type'
+export * from './types/flattened_values_of_type'
+export * from './types/mobx_value_of_type'
+export * from './types/paths_of_type'
+export * from './types/readonly_type_of_type'
 export * from './types/strict_definitions'
-export * from './types/value_to_type_paths_of'
-export * from './types/value_type_of'
+export * from './types/value_of_type'
+export * from './types/value_to_type_paths_of_type'
 export * from './types/value_types_of_discriminated_union'
+export * from './validation/validator'
+export * from './validation/validators/defined_validator'
+export * from './validation/validators/minimum_string_length_validator'
+export * from './validation/validators_of_values'

package/package.json

@@ -1,4 +1,5 @@
 {
+  "author": "Chris <chris.glover@gmail.com> (@madmaw)",
   "dependencies": {
     "@strictly/base": "*",
     "mobx": "^6.13.5"
@@ -6,20 +7,27 @@
   "devDependencies": {
     "@strictly/support-vite": "*"
   },
+  "homepage": "https://madmaw.github.io/strictly/define",
+  "keywords": [
+    "react",
+    "state management",
+    "types"
+  ],
   "license": "MIT",
   "name": "@strictly/define",
+  "packageManager": "yarn@1.22.22",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "directory": "packages/define",
     "type": "git",
-    "url": "git+https://github.com/madmaw/de.git"
+    "url": "git+https://github.com/madmaw/strictly.git"
   },
   "scripts": {
     "build": "tsup",
     "check-types": "tsc",
-    "clean": "del-cli dist",
+    "clean": "del-cli dist .out .turbo",
     "lint": "cross-env ESLINT_USE_FLAT_CONFIG=false eslint . --max-warnings=0",
     "lint:fix": "cross-env ESLINT_USE_FLAT_CONFIG=false eslint . --fix",
     "release:exports": "json -f package.json -f package.exports.json --merge > package.release.json",
@@ -27,7 +35,7 @@
     "test:watch": "vitest"
   },
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "exports": {
     ".": {
       "import": {

package/transformers/copies/copy.ts

@@ -1,6 +1,6 @@
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
 import { type StrictType } from 'types/strict_definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type AnyValueType,
   copyTo,
@@ -12,7 +12,7 @@ function identity(v: AnyValueType): AnyValueType {
 
 export function copy<T extends StrictType>(
   t: T,
-  proto: ValueTypeOf<ReadonlyTypeDefOf<T>>,
-): ValueTypeOf<T> {
+  proto: ValueOfType<ReadonlyTypeOfType<T>>,
+): ValueOfType<T> {
   return copyTo(t, proto, identity)
 }

package/transformers/copies/copy_to.ts

@@ -10,18 +10,18 @@ import {
   TypeDefType,
   type UnionKey,
 } from 'types/definitions'
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
 import {
   type StrictListTypeDef,
   type StrictLiteralTypeDef,
   type StrictObjectTypeDef,
+  type StrictObjectTypeDefFields,
   type StrictRecordTypeDef,
-  type StrictStructuredTypeDefFields,
   type StrictType,
   type StrictTypeDef,
   type StrictUnionTypeDef,
 } from 'types/strict_definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyValueType = any
@@ -30,10 +30,10 @@ export type Copier<R> = (v: AnyValueType, t: StrictTypeDef) => R
 
 export function copyTo<
   T extends StrictType,
-  R extends ValueTypeOf<ReadonlyTypeDefOf<T>>,
+  R extends ValueOfType<ReadonlyTypeOfType<T>>,
 >(
   { definition }: T,
-  value: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+  value: ValueOfType<ReadonlyTypeOfType<T>>,
   copier: Copier<R>,
 ): R {
   return internalCopyTo(
@@ -54,6 +54,10 @@ function internalCopyTo<R>(
   value: AnyValueType,
   copier: Copier<R>,
 ): R {
+  if (value === undefined) {
+    // don't copy things that don't exist
+    return undefined!
+  }
   switch (definition.type) {
     case TypeDefType.Literal:
       return copyLiteral(
@@ -94,7 +98,7 @@ function copyLiteral<
   R,
 >(
   typeDef: StrictLiteralTypeDef,
-  value: ValueTypeOf<{ definition: StrictLiteralTypeDef }>,
+  value: ValueOfType<{ definition: StrictLiteralTypeDef }>,
   copier: Copier<R>,
 ): R {
   // mutable and immutable literals should be the same type
@@ -146,7 +150,7 @@ function copyObjectFields<
   R,
   Extra extends Record<string, UnionKey>,
 >(
-  fields: StrictStructuredTypeDefFields,
+  fields: StrictObjectTypeDefFields,
   value: Record<ObjectFieldKey, AnyValueType>,
   copier: Copier<R>,
   extra: Extra,

package/transformers/copies/mobx_copy.ts

@@ -7,18 +7,18 @@ import {
   makeObservable,
   observable,
 } from 'mobx'
-import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_type_to'
+import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_to'
 import {
   type ObjectFieldKey,
   TypeDefType,
 } from 'types/definitions'
-import { type MobxValueTypeOf } from 'types/mobx_value_type_of'
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import { type MobxValueOfType } from 'types/mobx_value_of_type'
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
 import {
   type StrictType,
   type StrictTypeDef,
 } from 'types/strict_definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type AnyValueType,
   copyTo,
@@ -75,7 +75,7 @@ function observeValue(
 
 export function mobxCopy<T extends StrictType>(
   t: T,
-  proto: ValueTypeOf<ReadonlyTypeDefOf<T>>,
-): MobxValueTypeOf<T> {
+  proto: ValueOfType<ReadonlyTypeOfType<T>>,
+): MobxValueOfType<T> {
   return copyTo(t, proto, observeValue)
 }

package/transformers/copies/specs/copy_to.tests.ts

@@ -72,9 +72,9 @@ describe('copyTo', function () {
 
   describe('object', function () {
     const typeDef = object()
-      .set('a', numberType)
-      .set('b', booleanType)
-      .set('c', stringType)
+      .field('a', numberType)
+      .field('b', booleanType)
+      .field('c', stringType)
     it('copies', function () {
       const c = copyTo(
         typeDef,
@@ -96,9 +96,9 @@ describe('copyTo', function () {
   describe('union', function () {
     describe('non-discriminated', function () {
       const typeDef = union()
-        .add('0', list(numberType))
-        .add('1', literal(['b']))
-        .add('2', literal([false]))
+        .or('0', list(numberType))
+        .or('1', literal(['b']))
+        .or('2', literal([false]))
       it('copies string literal', function () {
         const c = copyTo(
           typeDef,
@@ -120,8 +120,8 @@ describe('copyTo', function () {
 
     describe('discriminated', function () {
       const typeDef = union('d')
-        .add('a', object().set('x', numberType))
-        .add('b', object().set('y', booleanType))
+        .or('a', object().field('x', numberType))
+        .or('b', object().field('y', booleanType))
 
       it('copies', function () {
         const c = copyTo(

package/transformers/copies/specs/mobx_copy.tests.ts

@@ -3,13 +3,13 @@ import {
   numberType,
   object,
 } from 'types/builders'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 
 describe('mobxCopy', function () {
   describe('object', function () {
     describe('optional field', function () {
-      const type = object().setOptional('n', numberType)
-      type T = ValueTypeOf<typeof type>
+      const type = object().optionalField('n', numberType)
+      type T = ValueOfType<typeof type>
       it('copies unpopulated', function () {
         const v: T = {}
         const c = mobxCopy(type, v)

package/transformers/flatteners/{flatten_accessors_of.ts → flatten_accessors_of_type.ts}

@@ -4,14 +4,14 @@ import {
 } from 'types/definitions'
 import {
   type Accessor,
-  type FlattenedAccessorsOf,
-} from 'types/flattened_accessors_of'
-import { type ValueTypeOf } from 'types/value_type_of'
+  type FlattenedAccessorsOfType,
+} from 'types/flattened_accessors_of_type'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type AnyValueType,
-  flattenValueTypeTo,
+  flattenValueTo,
   type Setter,
-} from './flatten_value_type_to'
+} from './flatten_value_to'
 
 function mapAccessor(
   _t: TypeDef,
@@ -24,17 +24,17 @@ function mapAccessor(
   }
 }
 
-export function flattenAccessorsOf<
+export function flattenAccessorsOfType<
   T extends Type,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOf<T>,
+  R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOfType<T>,
 >(
   t: T,
-  value: ValueTypeOf<T>,
-  setValue: Setter<ValueTypeOf<T>>,
+  value: ValueOfType<T>,
+  setValue: Setter<ValueOfType<T>>,
 ): R {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return flattenValueTypeTo<T, Accessor<any>, R>(
+  return flattenValueTo<T, Accessor<any>, R>(
     t,
     value,
     setValue,

package/transformers/flatteners/flatten_json_value_to_type_paths_of.ts

@@ -2,12 +2,12 @@ import {
   type Type,
   type TypeDef,
 } from 'types/definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type AnyValueType,
-  flattenValueTypeTo,
+  flattenValueTo,
   type Setter,
-} from './flatten_value_type_to'
+} from './flatten_value_to'
 
 function mapTypePaths(
   _t: TypeDef,
@@ -23,12 +23,12 @@ export function flattenJsonValueToTypePathsOf<
   R extends Record<string, string | number | symbol>,
 >(
   t: T,
-  value: ValueTypeOf<T>,
+  value: ValueOfType<T>,
   // TODO
   // : FlattenedJsonValueToTypePathsOf<T>
 ): R {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return flattenValueTypeTo(
+  return flattenValueTo(
     t,
     value,
     function () {

package/transformers/flatteners/{flatten_type_def_to.ts → flatten_type_to.ts}

@@ -20,7 +20,7 @@ export type AnyValueType = any
 
 export type Mapper<R> = (t: StrictTypeDef) => R
 
-export function flattenTypeDefTo<M, R extends Readonly<Record<string, M>>>(
+export function flattenTypeTo<M, R extends Readonly<Record<string, M>>>(
   { definition }: StrictType,
   mapper: Mapper<M>,
 ): R {

package/transformers/flatteners/{flatten_type_defs_of.ts → flatten_types_of_type.ts}

@@ -3,11 +3,11 @@ import {
   type TypeDef,
 } from 'types/definitions'
 import { type StrictType } from 'types/strict_definitions'
-import { flattenTypeDefTo } from './flatten_type_def_to'
+import { flattenTypeTo } from './flatten_type_to'
 
-export function flattenTypeDefsOf<T extends StrictType>(t: T) {
+export function flattenTypesOfType<T extends StrictType>(t: T) {
   // Type should be FlattenedTypeDefsOf<T>, but infinite depth error
-  return flattenTypeDefTo<StrictType, Record<string, Type>>(
+  return flattenTypeTo<StrictType, Record<string, Type>>(
     t,
     function (definition: TypeDef) {
       return { definition }

package/transformers/flatteners/flatten_validation_errors_of_type.ts

@@ -0,0 +1,93 @@
+import { type AnyValueType } from 'transformers/copies/copy_to'
+import {
+  flattenValueTo,
+  type Setter,
+} from 'transformers/flatteners/flatten_value_to'
+import {
+  type ReadonlyDeep,
+  type ValueOf,
+} from 'type-fest'
+import { type Type } from 'types/definitions'
+import { type FlattenedTypesOfType } from 'types/flattened_types_of_type'
+import { type FlattenedValuesOfType } from 'types/flattened_values_of_type'
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
+import { type StrictTypeDef } from 'types/strict_definitions'
+import { type ValueOfType } from 'types/value_of_type'
+import {
+  validate,
+  type Validator,
+} from 'validation/validator'
+
+type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E | null : never
+
+export type ErrorsOfFlattenedValidators<
+  TypePathsToValidators extends Readonly<Record<string, Validator>>,
+> = {
+  [K in keyof TypePathsToValidators]: ErrorOfValidator<TypePathsToValidators[K]>
+}
+
+export type FlattenedTypePathsToValidatorsOf<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  FlattenedValues extends Readonly<Record<string, any>>,
+  Context,
+> = {
+  readonly [
+    K in keyof FlattenedValues
+    // TODO would be better to use the equivalent readonly typedef, but it causes typescript to
+    // infinitely recurse
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ]?: Validator<ReadonlyDeep<FlattenedValues[K]>, any, any, Context>
+}
+
+export type ValuePathsToValidatorsOf<
+  TypePathsToAdapters extends Partial<Readonly<Record<string, Validator>>>,
+  ValuePathsToTypePaths extends Readonly<Record<string, string>>,
+> = keyof TypePathsToAdapters extends ValueOf<ValuePathsToTypePaths> ? {
+    readonly [
+      K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K
+    ]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>
+  }
+  : never
+
+export type FlattenedValidatorsOfType<
+  T extends Type,
+  Flattened extends Readonly<Record<string, Type>> = FlattenedTypesOfType<T, '*'>,
+> = {
+  [K in keyof Flattened]: Validator
+}
+
+export function flattenValidationErrorsOfType<
+  T extends Type,
+  ValueToTypePaths extends Readonly<Record<string, string>>,
+  TypePathsToValidators extends FlattenedTypePathsToValidatorsOf<
+    FlattenedValuesOfType<T, '*'>,
+    ValueOfType<ReadonlyTypeOfType<T>>
+  >,
+  ValuePathsToValidators extends ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths> =
+    ValuePathsToValidatorsOf<
+      TypePathsToValidators,
+      ValueToTypePaths
+    >,
+>(
+  type: T,
+  value: ValueOfType<T>,
+  validators: TypePathsToValidators,
+): ErrorsOfFlattenedValidators<ValuePathsToValidators> {
+  return flattenValueTo(
+    type,
+    value,
+    () => {},
+    function (
+      _t: StrictTypeDef,
+      v: AnyValueType,
+      _setter: Setter<AnyValueType>,
+      typePath: string,
+      valuePath: string,
+    ) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const validator = validators[typePath as keyof TypePathsToValidators]
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return validator != null ? validate(validator as Validator, v, valuePath, value) : null
+    },
+  )
+}

package/transformers/flatteners/flatten_validators_of_validating_type.ts

@@ -0,0 +1,32 @@
+import { type FlattenedTypesOfValidatingType } from 'types/flattened_types_of_validating_type'
+import { type FlattenedValidatorsOfValidatingType } from 'types/flattened_validators_of_validating_type'
+import {
+  type ValidatingType,
+  type ValidatingTypeDef,
+} from 'types/validating_definitions'
+import { type Validator } from 'validation/validator'
+import { flattenTypeTo } from './flatten_type_to'
+
+export function flattenValidatorsOfValidatingType<
+  T extends ValidatingType,
+  TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>,
+  FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfValidatingType<T, '*'>,
+>(type: T): FlattenedValidatorsOfValidatingType<T, TypePathsToValuePaths, FlattenedTypes> {
+  return flattenTypeTo(type, function (definition): Validator {
+    const {
+      rule,
+      readonly,
+      required,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    } = definition as ValidatingTypeDef
+    return {
+      annotations: function () {
+        return {
+          readonly,
+          required,
+        }
+      },
+      validate: rule,
+    }
+  })
+}

package/transformers/flatteners/{flatten_value_type_to.ts → flatten_value_to.ts}

@@ -7,7 +7,7 @@ import {
   TypeDefType,
   type UnionTypeDef,
 } from 'types/definitions'
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
 import {
   type StrictListTypeDef,
   type StrictObjectTypeDef,
@@ -16,7 +16,7 @@ import {
   type StrictTypeDef,
   type StrictUnionTypeDef,
 } from 'types/strict_definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 import { jsonPath } from './json_path'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -31,14 +31,14 @@ export type Mapper<R> = (
   valuePath: string,
 ) => R
 
-export function flattenValueTypeTo<
+export function flattenValueTo<
   T extends StrictType,
   M,
   R extends Readonly<Record<string, M>>,
 >(
   { definition }: T,
-  v: ValueTypeOf<T>,
-  setter: Setter<ValueTypeOf<T>>,
+  v: ValueOfType<T>,
+  setter: Setter<ValueOfType<T>>,
   mapper: Mapper<M>,
 ): R {
   const r: Record<string, AnyValueType> = {}
@@ -65,7 +65,12 @@ function internalFlattenValue<M>(
   r: Record<string, M>,
 ) {
   r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath)
-  return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r)
+  // assume undefined means the field is optional and not populated
+  // TODO: actually capture if field is optional in typedef (or in builder for creating validator)
+  if (v !== undefined) {
+    return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r)
+  }
+  return r
 }
 
 function internalFlattenValueChildren<M>(
@@ -199,7 +204,7 @@ function internalFlattenUnionChildren<M>(
 
 export function getUnionTypeDef<T extends UnionTypeDef>(
   typeDef: T,
-  v: ValueTypeOf<ReadonlyTypeDefOf<{
+  v: ValueOfType<ReadonlyTypeOfType<{
     definition: T,
   }>>,
 ) {

package/transformers/flatteners/{flatten_value_types_of.ts → flatten_values_of_type.ts}

@@ -1,20 +1,20 @@
 import { type Type } from 'types/definitions'
 import { type StrictTypeDef } from 'types/strict_definitions'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type AnyValueType,
-  flattenValueTypeTo,
-} from './flatten_value_type_to'
+  flattenValueTo,
+} from './flatten_value_to'
 
 function mapper(_t: StrictTypeDef, v: AnyValueType) {
   return v
 }
 
-export function flattenValueTypesOf<T extends Type>(
+export function flattenValuesOfType<T extends Type>(
   typeDef: Type,
-  value: ValueTypeOf<T>,
+  value: ValueOfType<T>,
 ) {
-  return flattenValueTypeTo(
+  return flattenValueTo(
     typeDef,
     value,
     () => {},

package/transformers/flatteners/specs/{flatten_accessors_of.tests.ts → flatten_accessors_of_type.tests.ts}

@@ -1,27 +1,26 @@
 import { expectDefinedAndReturn } from '@strictly/base'
-import { flattenAccessorsOf } from 'transformers/flatteners/flatten_accessors_of'
+import { flattenAccessorsOfType } from 'transformers/flatteners/flatten_accessors_of_type'
 import {
   booleanType,
   list,
   numberType,
   object,
 } from 'types/builders'
-import { type FlattenedAccessorsOf } from 'types/flattened_accessors_of'
-import { type ValueTypeOf } from 'types/value_type_of'
+import { type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type'
+import { type ValueOfType } from 'types/value_of_type'
 import {
   type Mock,
   vi,
 } from 'vitest'
 
-describe('flattenAccessorsOf', function () {
+describe('flattenAccessorsOfType', function () {
   let setter: Mock
   const builder = object()
-    .set('a', list(numberType))
-    .set('b', booleanType)
-    .narrow
+    .field('a', list(numberType))
+    .field('b', booleanType)
 
-  let flattened: FlattenedAccessorsOf<typeof builder>
-  let value: ValueTypeOf<typeof builder>
+  let flattened: FlattenedAccessorsOfType<typeof builder>
+  let value: ValueOfType<typeof builder>
 
   beforeEach(function () {
     setter = vi.fn()
@@ -33,7 +32,7 @@ describe('flattenAccessorsOf', function () {
       ],
       b: false,
     }
-    flattened = flattenAccessorsOf<typeof builder>(
+    flattened = flattenAccessorsOfType<typeof builder>(
       builder,
       value,
       setter,
@@ -100,7 +99,7 @@ describe('flattenAccessorsOf', function () {
   })
 
   it('sets the top level value', function () {
-    const newValue: ValueTypeOf<typeof builder> = {
+    const newValue: ValueOfType<typeof builder> = {
       a: [
         -1,
         5,

package/transformers/flatteners/specs/flatten_json_value_to_type_paths_of.tests.ts

@@ -56,8 +56,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
 
   describe('object', function () {
     const typeDef = object()
-      .set('a', numberType)
-      .set('b', booleanType)
+      .field('a', numberType)
+      .field('b', booleanType)
     const flattened = flattenJsonValueToTypePathsOf(typeDef, {
       a: 1,
       b: true,
@@ -75,8 +75,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
   describe('union', function () {
     describe('non-discriminated', function () {
       const typeDef = union()
-        .add('a', list(numberType))
-        .add('b', nullType)
+        .or('a', list(numberType))
+        .or('b', nullType)
       const flattened = flattenJsonValueToTypePathsOf(typeDef, [
         1,
         2,
@@ -95,8 +95,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
 
     describe('discriminated', function () {
       const typeDef = union('d')
-        .add('x', object().set('a', numberType).set('b', booleanType))
-        .add('y', object().set('c', stringType).set('d', booleanType))
+        .or('x', object().field('a', numberType).field('b', booleanType))
+        .or('y', object().field('c', stringType).field('d', booleanType))
       const flattened = flattenJsonValueToTypePathsOf(typeDef, {
         d: 'x',
         a: 1,