@strictly/define 0.0.1

package/transformers/flatteners/flatten_type_def_to.ts

@@ -0,0 +1,127 @@
+import {
+  reduce,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  TypeDefType,
+} from 'types/definitions'
+import {
+  type StrictListTypeDef,
+  type StrictObjectTypeDef,
+  type StrictRecordTypeDef,
+  type StrictType,
+  type StrictTypeDef,
+  type StrictUnionTypeDef,
+} from 'types/strict_definitions'
+import { jsonPath } from './json_path'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyValueType = any
+
+export type Mapper<R> = (t: StrictTypeDef) => R
+
+export function flattenTypeDefTo<M, R extends Readonly<Record<string, M>>>(
+  { definition }: StrictType,
+  mapper: Mapper<M>,
+): R {
+  const typeDefs = internalFlattenTypeDef('$', definition, {})
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return reduce(
+    typeDefs,
+    function (acc, key, typeDef) {
+      acc[key] = mapper(typeDef)
+      return acc
+    },
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    {} as Record<string, M>,
+  ) as R
+}
+
+function internalFlattenTypeDef(
+  path: string,
+  t: StrictTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  r[path] = t
+  return internalFlattenTypeDefChildren(path, '', t, r)
+}
+
+function internalFlattenTypeDefChildren(
+  path: string,
+  qualifier: string,
+  t: StrictTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  switch (t.type) {
+    case TypeDefType.Literal:
+      return r
+    case TypeDefType.List:
+      return internalFlattenedListTypeDefChildren(path, t, r)
+    case TypeDefType.Record:
+      return internalFlattenRecordTypeDefChildren(path, t, r)
+    case TypeDefType.Object:
+      return internalFlattenObjectTypeDefChildren(path, qualifier, t, r)
+    case TypeDefType.Union:
+      return internalFlattenUnionTypeDefChildren(path, qualifier, t, r)
+    default:
+      throw new UnreachableError(t)
+  }
+}
+
+function internalFlattenedListTypeDefChildren(
+  path: string,
+  { elements }: StrictListTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  return internalFlattenTypeDef(jsonPath(path, '*'), elements, r)
+}
+
+function internalFlattenRecordTypeDefChildren(
+  path: string,
+  { valueTypeDef }: StrictRecordTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  return internalFlattenTypeDef(jsonPath(path, '*'), valueTypeDef, r)
+}
+
+function internalFlattenObjectTypeDefChildren(
+  path: string,
+  qualifier: string,
+  { fields }: StrictObjectTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  return reduce(
+    fields,
+    function (acc, fieldName, fieldTypeDef) {
+      return internalFlattenTypeDef(
+        jsonPath(path, fieldName, qualifier),
+        fieldTypeDef,
+        acc,
+      )
+    },
+    r,
+  )
+}
+
+function internalFlattenUnionTypeDefChildren(
+  path: string,
+  qualifier: string,
+  {
+    discriminator,
+    unions,
+  }: StrictUnionTypeDef,
+  r: Record<string, StrictTypeDef>,
+): Record<string, StrictTypeDef> {
+  return reduce(
+    unions,
+    function (acc, key, typeDef: StrictTypeDef) {
+      return internalFlattenTypeDefChildren(
+        path,
+        discriminator != null ? `${qualifier}${key}:` : qualifier,
+        typeDef,
+        acc,
+      )
+    },
+    r,
+  )
+}

package/transformers/flatteners/flatten_type_defs_of.ts

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

package/transformers/flatteners/flatten_value_type_to.ts

@@ -0,0 +1,227 @@
+import {
+  reduce,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  type TypeDef,
+  TypeDefType,
+  type UnionTypeDef,
+} from 'types/definitions'
+import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of'
+import {
+  type StrictListTypeDef,
+  type StrictObjectTypeDef,
+  type StrictRecordTypeDef,
+  type StrictType,
+  type StrictTypeDef,
+  type StrictUnionTypeDef,
+} from 'types/strict_definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+import { jsonPath } from './json_path'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyValueType = any
+export type Setter<V> = (v: V) => void
+
+export type Mapper<R> = (
+  t: StrictTypeDef,
+  v: AnyValueType,
+  setter: Setter<AnyValueType>,
+  typePath: string,
+  valuePath: string,
+) => R
+
+export function flattenValueTypeTo<
+  T extends StrictType,
+  M,
+  R extends Readonly<Record<string, M>>,
+>(
+  { definition }: T,
+  v: ValueTypeOf<T>,
+  setter: Setter<ValueTypeOf<T>>,
+  mapper: Mapper<M>,
+): R {
+  const r: Record<string, AnyValueType> = {}
+  internalFlattenValue(
+    '$',
+    '$',
+    definition,
+    v,
+    setter,
+    mapper,
+    r,
+  )
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return r as R
+}
+
+function internalFlattenValue<M>(
+  valuePath: string,
+  typePath: string,
+  typeDef: StrictTypeDef,
+  v: AnyValueType,
+  setter: Setter<AnyValueType>,
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+) {
+  r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath)
+  return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r)
+}
+
+function internalFlattenValueChildren<M>(
+  valuePath: string,
+  typePath: string,
+  qualifier: string,
+  typeDef: StrictTypeDef,
+  v: AnyValueType,
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+) {
+  switch (typeDef.type) {
+    case TypeDefType.Literal:
+      // no children
+      return r
+    case TypeDefType.List:
+      return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r)
+    case TypeDefType.Record:
+      return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r)
+    case TypeDefType.Object:
+      return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r)
+    case TypeDefType.Union:
+      return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r)
+    default:
+      throw new UnreachableError(typeDef)
+  }
+}
+
+function internalFlattenListChildren<M>(
+  valuePath: string,
+  typePath: string,
+  { elements }: StrictListTypeDef,
+  v: AnyValueType[],
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+) {
+  const newTypePath = jsonPath(typePath, '*')
+  return v.reduce(function (r, e, i) {
+    return internalFlattenValue(
+      jsonPath(valuePath, i),
+      newTypePath,
+      elements,
+      e,
+      (e: AnyValueType) => {
+        v[i] = e
+      },
+      mapper,
+      r,
+    )
+  }, r)
+}
+
+function internalFlattenRecordChildren<M>(
+  valuePath: string,
+  typePath: string,
+  { valueTypeDef }: StrictRecordTypeDef,
+  v: Record<string, AnyValueType>,
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+): Record<string, M> {
+  const newTypePath = jsonPath(typePath, '*')
+  return reduce(
+    v,
+    function (r, k, value) {
+      return internalFlattenValue(
+        jsonPath(valuePath, k),
+        newTypePath,
+        valueTypeDef,
+        value,
+        (value: AnyValueType) => {
+          v[k] = value
+        },
+        mapper,
+        r,
+      )
+    },
+    r,
+  )
+}
+
+function internalFlattenObjectChildren<M>(
+  valuePath: string,
+  typePath: string,
+  qualifier: string,
+  { fields }: StrictObjectTypeDef,
+  v: Record<string, AnyValueType>,
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+): Record<string, M> {
+  return reduce(
+    fields,
+    function (r, k, fieldTypeDef) {
+      const fieldValue = v[k]
+      return internalFlattenValue(
+        jsonPath(valuePath, k, qualifier),
+        jsonPath(typePath, k, qualifier),
+        fieldTypeDef,
+        fieldValue,
+        (value: AnyValueType) => {
+          v[k] = value
+        },
+        mapper,
+        r,
+      )
+    },
+    r,
+  )
+}
+
+function internalFlattenUnionChildren<M>(
+  valuePath: string,
+  typePath: string,
+  qualifier: string,
+  typeDef: StrictUnionTypeDef,
+  v: AnyValueType,
+  mapper: Mapper<M>,
+  r: Record<string, M>,
+): AnyValueType {
+  const childTypeDef = getUnionTypeDef(typeDef, v)
+  const newQualifier = typeDef.discriminator != null ? `${qualifier}${v[typeDef.discriminator]}:` : qualifier
+  return internalFlattenValueChildren(
+    valuePath,
+    typePath,
+    newQualifier,
+    childTypeDef,
+    v,
+    mapper,
+    r,
+  )
+}
+
+export function getUnionTypeDef<T extends UnionTypeDef>(
+  typeDef: T,
+  v: ValueTypeOf<ReadonlyTypeDefOf<{
+    definition: T,
+  }>>,
+) {
+  if (typeDef.discriminator == null) {
+    // find either a literal who's prototype we match, or assume that
+    // we match the non-literal, or the literal value with no prototype, value
+    return reduce<string, TypeDef, null | TypeDef>(
+      typeDef.unions,
+      function (acc, _k, t) {
+        if (t.type === TypeDefType.Literal && t.valuePrototype) {
+          if (t.valuePrototype.indexOf(v) >= 0) {
+            return t
+          }
+        } else {
+          if (acc == null) {
+            return t
+          }
+        }
+        return acc
+      },
+      null,
+    )
+  }
+  return typeDef.unions[v[typeDef.discriminator]]
+}

package/transformers/flatteners/flatten_value_types_of.ts

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

package/transformers/flatteners/json_path.ts

@@ -0,0 +1,15 @@
+export function jsonPath(prefix: string, segment: number | string, qualifier: string = ''): string {
+  const s = `.${qualifier}${segment}`
+  return `${prefix}${s}`
+}
+
+export function jsonPathPop(path: string): [string, string] | null {
+  const parts = path.split('.')
+  if (parts.length <= 1) {
+    return null
+  }
+  return [
+    parts.slice(0, -1).join('.'),
+    parts.pop()!,
+  ]
+}

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

@@ -0,0 +1,113 @@
+import { expectDefinedAndReturn } from '@strictly/base'
+import { flattenAccessorsOf } from 'transformers/flatteners/flatten_accessors_of'
+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 Mock,
+  vi,
+} from 'vitest'
+
+describe('flattenAccessorsOf', function () {
+  let setter: Mock
+  const builder = object()
+    .set('a', list(numberType))
+    .set('b', booleanType)
+    .narrow
+
+  let flattened: FlattenedAccessorsOf<typeof builder>
+  let value: ValueTypeOf<typeof builder>
+
+  beforeEach(function () {
+    setter = vi.fn()
+    value = {
+      a: [
+        1,
+        2,
+        4,
+      ],
+      b: false,
+    }
+    flattened = flattenAccessorsOf<typeof builder>(
+      builder,
+      value,
+      setter,
+    )
+  })
+
+  // note that we already have tests for the type and the function that this calls, so
+  // this is only a sanity check
+  it('flattens to expected type', function () {
+    expect(flattened).toEqual({
+      $: {
+        value: {
+          a: [
+            1,
+            2,
+            4,
+          ],
+          b: false,
+        },
+        set: setter,
+      },
+      '$.a': expect.objectContaining({
+        value: [
+          1,
+          2,
+          4,
+        ],
+      }),
+      '$.a.0': expect.objectContaining({
+        value: 1,
+      }),
+      '$.a.1': expect.objectContaining({
+        value: 2,
+      }),
+      '$.a.2': expect.objectContaining({
+        value: 4,
+      }),
+      '$.b': expect.objectContaining({
+        value: false,
+      }),
+    })
+  })
+
+  it('sets an internal value of a struct', function () {
+    expectDefinedAndReturn(flattened['$.a']).set([5])
+
+    expect(value).toEqual({
+      a: [5],
+      b: false,
+    })
+  })
+
+  it('sets an internal value of an array', function () {
+    expectDefinedAndReturn(flattened['$.a.1']).set(99)
+
+    expect(value).toEqual({
+      a: [
+        1,
+        99,
+        4,
+      ],
+      b: false,
+    })
+  })
+
+  it('sets the top level value', function () {
+    const newValue: ValueTypeOf<typeof builder> = {
+      a: [
+        -1,
+        5,
+      ],
+      b: true,
+    }
+    expectDefinedAndReturn(flattened.$).set(newValue)
+    expect(setter).toHaveBeenCalledWith(newValue)
+  })
+})

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

@@ -0,0 +1,115 @@
+import { flattenJsonValueToTypePathsOf } from 'transformers/flatteners/flatten_json_value_to_type_paths_of'
+import {
+  booleanType,
+  list,
+  nullType,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+
+describe('flattenJsonValueToTypePathsOf', function () {
+  describe('literal', function () {
+    const typeDef = numberType
+    const flattened = flattenJsonValueToTypePathsOf(typeDef, 1)
+
+    it('equals expected value', function () {
+      expect(flattened).toEqual({
+        $: '$',
+      })
+    })
+  })
+
+  describe('list', function () {
+    const typeDef = list(numberType)
+    const flattened = flattenJsonValueToTypePathsOf(typeDef, [
+      1,
+      2,
+    ])
+
+    it('equals expected value', function () {
+      expect(flattened).toEqual({
+        $: '$',
+        '$.0': '$.*',
+        '$.1': '$.*',
+      })
+    })
+  })
+
+  describe('record', function () {
+    const typeDef = record<typeof numberType, 'a' | 'b'>(numberType)
+    const flattened = flattenJsonValueToTypePathsOf(typeDef, {
+      a: 1,
+      b: 3,
+    })
+
+    it('equals expected value', function () {
+      expect(flattened).toEqual({
+        $: '$',
+        '$.a': '$.*',
+        '$.b': '$.*',
+      })
+    })
+  })
+
+  describe('object', function () {
+    const typeDef = object()
+      .set('a', numberType)
+      .set('b', booleanType)
+    const flattened = flattenJsonValueToTypePathsOf(typeDef, {
+      a: 1,
+      b: true,
+    })
+
+    it('equals expected value', function () {
+      expect(flattened).toEqual({
+        $: '$',
+        '$.a': '$.a',
+        '$.b': '$.b',
+      })
+    })
+  })
+
+  describe('union', function () {
+    describe('non-discriminated', function () {
+      const typeDef = union()
+        .add('a', list(numberType))
+        .add('b', nullType)
+      const flattened = flattenJsonValueToTypePathsOf(typeDef, [
+        1,
+        2,
+        3,
+      ])
+
+      it('equals expected value', function () {
+        expect(flattened).toEqual({
+          $: '$',
+          '$.0': '$.*',
+          '$.1': '$.*',
+          '$.2': '$.*',
+        })
+      })
+    })
+
+    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))
+      const flattened = flattenJsonValueToTypePathsOf(typeDef, {
+        d: 'x',
+        a: 1,
+        b: true,
+      })
+
+      it('equals expected value', function () {
+        expect(flattened).toEqual({
+          $: '$',
+          '$.x:a': '$.x:a',
+          '$.x:b': '$.x:b',
+        })
+      })
+    })
+  })
+})