@strictly/define 0.0.1

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

@@ -0,0 +1,146 @@
+import { flattenTypeDefTo } from 'transformers/flatteners/flatten_type_def_to'
+import {
+  booleanType,
+  list,
+  nullType,
+  numberType,
+  object,
+  record,
+  union,
+} from 'types/builders'
+import {
+  type TypeDef,
+  TypeDefType,
+} from 'types/definitions'
+import {
+  type Mock,
+  vi,
+} from 'vitest'
+
+describe('flattenTypeDefTo', function () {
+  let toTypeDefType: Mock<(typeDef: TypeDef) => number>
+  let flattened: Record<string, TypeDefType>
+
+  beforeEach(function () {
+    toTypeDefType = vi.fn(function (typeDef: TypeDef) {
+      return typeDef.type
+    })
+  })
+
+  describe('literal', function () {
+    beforeEach(function () {
+      flattened = flattenTypeDefTo(numberType, toTypeDefType)
+    })
+
+    it('equals expected type', function () {
+      expect(flattened).toEqual({
+        $: TypeDefType.Literal,
+      })
+    })
+
+    it('calls the mapper function', function () {
+      expect(toTypeDefType).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('list', function () {
+    const type = list(numberType)
+    beforeEach(function () {
+      flattened = flattenTypeDefTo(type, toTypeDefType)
+    })
+
+    it('equals expected type', function () {
+      expect(flattened).toEqual({
+        $: TypeDefType.List,
+        '$.*': TypeDefType.Literal,
+      })
+    })
+
+    it('calls the mapper function', function () {
+      expect(toTypeDefType).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('record', function () {
+    const type = record<typeof numberType, 'a' | 'b'>(numberType)
+    beforeEach(function () {
+      flattened = flattenTypeDefTo(type, toTypeDefType)
+    })
+
+    it('equals expected type', function () {
+      expect(
+        flattened,
+      ).toEqual({
+        $: TypeDefType.Record,
+        '$.*': TypeDefType.Literal,
+      })
+    })
+
+    it('calls the mapper function', function () {
+      expect(toTypeDefType).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('object', function () {
+    const type = object().set('a', numberType).set('b', list(booleanType))
+    beforeEach(function () {
+      flattened = flattenTypeDefTo(type, toTypeDefType)
+    })
+
+    it('equals expected type', function () {
+      expect(flattened).toEqual({
+        $: TypeDefType.Object,
+        '$.a': TypeDefType.Literal,
+        '$.b': TypeDefType.List,
+        '$.b.*': TypeDefType.Literal,
+      })
+    })
+
+    it('calls the mapper function', function () {
+      expect(toTypeDefType).toHaveBeenCalledTimes(4)
+    })
+  })
+
+  describe('union', function () {
+    describe('non-discriminated', function () {
+      const type = union()
+        .add('a', nullType)
+        .add('b', booleanType)
+        .add('c', numberType)
+      beforeEach(function () {
+        flattened = flattenTypeDefTo(type, toTypeDefType)
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: TypeDefType.Union,
+        })
+      })
+
+      it('calls the mapper function', function () {
+        expect(toTypeDefType).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    describe('discriminated', function () {
+      const type = union('d')
+        .add('a', object().set('a', booleanType))
+        .add('b', object().set('b', numberType))
+      beforeEach(function () {
+        flattened = flattenTypeDefTo(type, toTypeDefType)
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: TypeDefType.Union,
+          '$.a:a': TypeDefType.Literal,
+          '$.b:b': TypeDefType.Literal,
+        })
+      })
+
+      it('calls the mapper function', function () {
+        expect(toTypeDefType).toHaveBeenCalledTimes(3)
+      })
+    })
+  })
+})

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

@@ -0,0 +1,26 @@
+import { flattenTypeDefsOf } from 'transformers/flatteners/flatten_type_defs_of'
+import {
+  booleanType,
+  list,
+  numberType,
+  object,
+} from 'types/builders'
+
+describe('flattenTypeDefsOf', function () {
+  it('flattens', function () {
+    const listTypeDef = list(numberType)
+    const structTypeDef = object()
+      .set('a', listTypeDef)
+      .set('b', booleanType)
+    const flattened = flattenTypeDefsOf(
+      structTypeDef,
+    )
+
+    expect(flattened).toEqual({
+      $: structTypeDef.narrow,
+      '$.a': listTypeDef.narrow,
+      '$.a.*': numberType.narrow,
+      '$.b': booleanType.narrow,
+    })
+  })
+})

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

@@ -0,0 +1,452 @@
+import {
+  type AnyValueType,
+  flattenValueTypeTo,
+  type Mapper,
+  type Setter,
+} from 'transformers/flatteners/flatten_value_type_to'
+import { type SimplifyDeep } from 'type-fest'
+import {
+  booleanType,
+  list,
+  literal,
+  nullType,
+  numberType,
+  object,
+  record,
+  union,
+} from 'types/builders'
+import {
+  type Type,
+  type TypeDef,
+} from 'types/definitions'
+import { type FlattenedTypeDefsOf } from 'types/flattened_type_defs_of'
+import { type ValueTypeOf } from 'types/value_type_of'
+import {
+  type Mock,
+  vi,
+} from 'vitest'
+
+type FlattenedSetters<R extends Record<string, Type>> = {
+  [K in keyof R]: Setter<ValueTypeOf<R[K]>>
+}
+
+type FlattenedToStrings<R extends Record<string, Type>> = {
+  [K in keyof R]: string
+}
+
+describe('flattenValueTypeTo', function () {
+  let toStringMapper: Mock<Mapper<string>>
+  let setMapper: Mock<Mapper<(v: AnyValueType) => void>>
+  let setter: Mock<(v: AnyValueType) => void>
+  beforeEach(function () {
+    toStringMapper = vi.fn(function (_t: TypeDef, v: AnyValueType) {
+      return JSON.stringify(v)
+    })
+    setMapper = vi.fn(function (_t: TypeDef, _v: AnyValueType, setter: Setter<AnyValueType>) {
+      return setter
+    })
+    setter = vi.fn()
+  })
+
+  describe('literal', function () {
+    const typeDef = numberType
+    type F = FlattenedTypeDefsOf<typeof typeDef, null>
+    describe('toString', function () {
+      let flattened: FlattenedToStrings<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          1,
+          setter,
+          toStringMapper,
+        )
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: '1',
+        })
+      })
+
+      it('calls the mapping function', function () {
+        expect(toStringMapper).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    describe('setter', function () {
+      let flattened: FlattenedSetters<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          1,
+          setter,
+          setMapper,
+        )
+      })
+
+      it('calls the top level setter', function () {
+        const value = 3
+        flattened.$(value)
+        expect(setter).toHaveBeenCalledTimes(1)
+        expect(setter).toHaveBeenCalledWith(value)
+      })
+    })
+  })
+
+  describe('list', function () {
+    const typeDef = list(numberType)
+    type F = FlattenedTypeDefsOf<typeof typeDef, null>
+    let l: ValueTypeOf<typeof typeDef>
+    beforeEach(function () {
+      l = [
+        1,
+        2,
+        3,
+      ]
+    })
+
+    describe('toString', function () {
+      let flattened: FlattenedToStrings<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          l,
+          setter,
+          toStringMapper,
+        )
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: '[1,2,3]',
+          ['$.0']: '1',
+          ['$.1']: '2',
+          ['$.2']: '3',
+        })
+      })
+
+      it('calls the mapping function', function () {
+        expect(toStringMapper).toHaveBeenCalledTimes(4)
+      })
+    })
+
+    describe('setter', function () {
+      let flattened: FlattenedSetters<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          l,
+          setter,
+          setMapper,
+        )
+      })
+
+      it('sets a value in the list', function () {
+        flattened['$.1'](4)
+        expect(l).toEqual([
+          1,
+          4,
+          3,
+        ])
+      })
+    })
+  })
+
+  describe('record', function () {
+    const typeDef = record<typeof numberType, 'a' | 'b'>(numberType)
+    type F = FlattenedTypeDefsOf<typeof typeDef, null>
+
+    let m: ValueTypeOf<typeof typeDef>
+    beforeEach(function () {
+      m = {
+        a: 1,
+        b: 3,
+      }
+    })
+
+    describe('toString', function () {
+      let flattened: FlattenedToStrings<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          m,
+          setter,
+          toStringMapper,
+        )
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: '{"a":1,"b":3}',
+          ['$.a']: '1',
+          ['$.b']: '3',
+        })
+      })
+    })
+
+    describe('setter', function () {
+      let flattened: FlattenedSetters<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          m,
+          setter,
+          setMapper,
+        )
+      })
+
+      it('sets a value in the record', function () {
+        flattened['$.a'](4)
+        expect(m).toEqual({
+          a: 4,
+          b: 3,
+        })
+      })
+    })
+  })
+
+  describe('object', function () {
+    const typeDef = object()
+      .set('a', numberType)
+      .set('b', booleanType)
+    type F = FlattenedTypeDefsOf<typeof typeDef, null>
+
+    let s: ValueTypeOf<typeof typeDef>
+    beforeEach(function () {
+      s = {
+        a: 1,
+        b: false,
+      }
+    })
+
+    describe('toString', function () {
+      let flattened: FlattenedToStrings<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          s,
+          setter,
+          toStringMapper,
+        )
+      })
+
+      it('equals expected type', function () {
+        expect(flattened).toEqual({
+          $: '{"a":1,"b":false}',
+          ['$.a']: '1',
+          ['$.b']: 'false',
+        })
+      })
+    })
+
+    describe('setter', function () {
+      let flattened: FlattenedSetters<F>
+      beforeEach(function () {
+        flattened = flattenValueTypeTo(
+          typeDef,
+          s,
+          setter,
+          setMapper,
+        )
+      })
+
+      it('sets "a" in the object', function () {
+        flattened['$.a'](2)
+        expect(s).toEqual({
+          a: 2,
+          b: false,
+        })
+      })
+
+      it('sets "b" in the object', function () {
+        flattened['$.b'](true)
+        expect(s).toEqual({
+          a: 1,
+          b: true,
+        })
+      })
+    })
+  })
+
+  describe('union', function () {
+    describe('discriminated', function () {
+      const typeDef = union('d')
+        .add('1', object().set('a', numberType))
+        .add('2', object().set('b', booleanType))
+      type F = SimplifyDeep<FlattenedTypeDefsOf<typeof typeDef, null>>
+      let u: ValueTypeOf<typeof typeDef>
+      beforeEach(function () {
+        u = {
+          d: '1',
+          a: 2,
+        }
+      })
+
+      describe('toString', function () {
+        let flattened: FlattenedToStrings<F>
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            toStringMapper,
+          )
+        })
+
+        it('equals expected type', function () {
+          expect(flattened).toEqual({
+            $: '{"d":"1","a":2}',
+            ['$.1:a']: '2',
+          })
+        })
+      })
+
+      describe('setter', function () {
+        type G = SimplifyDeep<FlattenedSetters<F>>
+        let flattened: G
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            setMapper,
+          )
+        })
+
+        it('sets a value', function () {
+          const value = {
+            d: '2',
+            b: false,
+          } as const
+          flattened.$(value)
+
+          expect(setter).toHaveBeenCalledWith(value)
+        })
+
+        it('sets an internal value', function () {
+          flattened['$.1:a'](1)
+
+          expect(u).toEqual({
+            d: '1',
+            a: 1,
+          })
+        })
+      })
+    })
+    describe('non-discriminated', function () {
+      const typeDef = union()
+        .add('0', numberType)
+        .add('1', nullType)
+      type F = FlattenedTypeDefsOf<typeof typeDef, null>
+      let u: ValueTypeOf<typeof typeDef>
+
+      beforeEach(function () {
+        u = null
+      })
+
+      describe('toString', function () {
+        let flattened: FlattenedToStrings<F>
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            toStringMapper,
+          )
+        })
+
+        it('equals expected type', function () {
+          expect(flattened).toEqual({
+            $: 'null',
+          })
+        })
+      })
+
+      describe('setter', function () {
+        let flattened: FlattenedSetters<F>
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            setMapper,
+          )
+        })
+
+        it('sets a value', function () {
+          const value = 2
+          flattened.$(value)
+
+          expect(setter).toHaveBeenCalledWith(value)
+        })
+      })
+    })
+
+    describe('complex non-discriminated', function () {
+      const typeDef = union()
+        .add('z', list(numberType))
+        .add('x', nullType)
+        .add('y', literal([false]))
+      type F = FlattenedTypeDefsOf<typeof typeDef, null>
+
+      let u: ValueTypeOf<typeof typeDef>
+      beforeEach(function () {
+        u = [
+          1,
+          2,
+          3,
+        ]
+      })
+
+      describe('toString', function () {
+        let flattened: FlattenedToStrings<F>
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            toStringMapper,
+          )
+        })
+
+        it('equals expected type', function () {
+          expect(flattened).toEqual({
+            $: '[1,2,3]',
+            ['$.0']: '1',
+            ['$.1']: '2',
+            ['$.2']: '3',
+          })
+        })
+      })
+
+      describe('setter', function () {
+        let flattened: FlattenedSetters<F>
+        beforeEach(function () {
+          flattened = flattenValueTypeTo(
+            typeDef,
+            u,
+            setter,
+            setMapper,
+          )
+        })
+
+        it('sets the top level value', function () {
+          const value = [100]
+          flattened.$(value)
+          expect(setter).toHaveBeenCalledWith(value)
+        })
+
+        it('sets a subordinate value', function () {
+          // need to cast to any as TS cannot guarantee that '$.a' is present
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+          ;(flattened as any)['$.1'](4)
+          expect(u).toEqual([
+            1,
+            4,
+            3,
+          ])
+        })
+      })
+    })
+  })
+})

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

@@ -0,0 +1,46 @@
+import { flattenValueTypesOf } from 'transformers/flatteners/flatten_value_types_of'
+import {
+  booleanType,
+  list,
+  numberType,
+  object,
+} from 'types/builders'
+
+describe('flattenValueTypesOf', function () {
+  // note that we already have tests for the type and the function that this calls, so
+  // this is only a sanity check
+  it('flattens', function () {
+    const flattened = flattenValueTypesOf(
+      object()
+        .set('a', list(numberType))
+        .set('b', booleanType),
+      {
+        a: [
+          1,
+          2,
+          4,
+        ],
+        b: false,
+      },
+    )
+    expect(flattened).toEqual({
+      $: {
+        a: [
+          1,
+          2,
+          4,
+        ],
+        b: false,
+      },
+      '$.a': [
+        1,
+        2,
+        4,
+      ],
+      '$.a.0': 1,
+      '$.a.1': 2,
+      '$.a.2': 4,
+      '$.b': false,
+    })
+  })
+})