@strictly/define 0.0.1

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

@@ -0,0 +1,240 @@
+import { valuePathToTypePath } from 'transformers/flatteners/value_path_to_type_path'
+import {
+  booleanType,
+  list,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+import { type ValueToTypePathsOf } from 'types/value_to_type_paths_of'
+
+describe('valuePathToTypePath', function () {
+  describe('literal', function () {
+    const typeDef = numberType
+    type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+
+    const typePath = valuePathToTypePath<JsonPaths, '$'>(typeDef, '$')
+
+    it('maps a value path to the expected type path', function () {
+      expect(typePath).toEqual('$')
+    })
+
+    it('has expected type', function () {
+      expectTypeOf(typePath).toEqualTypeOf<'$'>()
+    })
+
+    describe('fake subpath', function () {
+      const fakeTypePath = valuePathToTypePath<{
+        '$.fake': '$.fake',
+      }, '$.fake'>(typeDef, '$.fake', true)
+
+      it('maps a value path to the expected type path', function () {
+        expect(fakeTypePath).toEqual('$.fake')
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(fakeTypePath).toEqualTypeOf<'$.fake'>()
+      })
+    })
+  })
+
+  describe('list', function () {
+    const typeDef = list(numberType)
+    type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+
+    describe.each([
+      [
+        '$',
+        '$',
+      ],
+      [
+        '$.0',
+        '$.*',
+      ],
+    ] as const)('it maps "%s"', function (from, to) {
+      const typePath = valuePathToTypePath<JsonPaths, typeof from>(typeDef, from)
+
+      it('maps a value path to the expected type path', function () {
+        expect(typePath).toEqual(to)
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(typePath).toEqualTypeOf(to)
+      })
+    })
+
+    describe('fake subpath', function () {
+      const fakeTypePath = valuePathToTypePath<
+        JsonPaths & {
+          [_: `$.${number}.fake`]: '$.*.fake',
+        },
+        '$.0.fake'
+      >(typeDef, '$.0.fake', true)
+
+      it('maps a value path to the expected type path', function () {
+        expect(fakeTypePath).toEqual('$.*.fake')
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(fakeTypePath).toEqualTypeOf<'$.*.fake'>()
+      })
+    })
+  })
+
+  describe('record', function () {
+    type Key = 'a' | 'b'
+    const typeDef = record<typeof numberType, Key>(numberType)
+    type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+
+    describe.each([
+      [
+        '$',
+        '$',
+      ],
+      [
+        '$.a',
+        '$.*',
+      ],
+      [
+        '$.b',
+        '$.*',
+      ],
+    ] as const)('it maps "%s"', function (from, to) {
+      const typePath = valuePathToTypePath<JsonPaths, typeof from>(typeDef, from)
+
+      it('maps a value path to the expected type path', function () {
+        expect(typePath).toEqual(to)
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(typePath).toEqualTypeOf(to)
+      })
+    })
+
+    describe('fake subpath', function () {
+      const fakeTypePath = valuePathToTypePath<
+        JsonPaths & {
+          '$.a.fake': '$.*.fake',
+          '$.b.fake': '$.*.fake',
+        },
+        '$.a.fake'
+      >(typeDef, '$.a.fake', true)
+
+      it('maps a value path to the expected type path', function () {
+        expect(fakeTypePath).toEqual('$.*.fake')
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(fakeTypePath).toEqualTypeOf<'$.*.fake'>()
+      })
+    })
+  })
+
+  describe('object', function () {
+    const typeDef = object().set('a', numberType).set('b', booleanType)
+    type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+
+    describe.each([
+      [
+        '$',
+        '$',
+      ],
+      [
+        '$.a',
+        '$.a',
+      ],
+      [
+        '$.b',
+        '$.b',
+      ],
+    ] as const)('it maps %s', function (from, to) {
+      const typePath = valuePathToTypePath<JsonPaths, typeof from>(typeDef, from)
+
+      it('maps a value path to the expected type path', function () {
+        expect(typePath).toEqual(to)
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(typePath).toEqualTypeOf(to)
+      })
+    })
+
+    describe('fake field', function () {
+      const fakeTypePath = valuePathToTypePath<
+        JsonPaths & {
+          '$.fake': '$.fake',
+        },
+        '$.fake'
+      >(typeDef, '$.fake', true)
+
+      it('maps a value path to the expected type path', function () {
+        expect(fakeTypePath).toEqual('$.fake')
+      })
+
+      it('has expected type', function () {
+        expectTypeOf(fakeTypePath).toEqualTypeOf<'$.fake'>()
+      })
+    })
+  })
+
+  describe('union', function () {
+    describe('discriminated', function () {
+      const typeDef = union('w')
+        .add('x', object().set('a', numberType).set('b', booleanType))
+        .add('y', object().set('b', stringType).set('c', booleanType))
+      type JsonPaths = ValueToTypePathsOf<typeof typeDef>
+
+      describe.each([
+        [
+          '$',
+          '$',
+        ],
+        [
+          '$.x:a',
+          '$.x:a',
+        ],
+        [
+          '$.x:b',
+          '$.x:b',
+        ],
+        [
+          '$.y:b',
+          '$.y:b',
+        ],
+        [
+          '$.y:c',
+          '$.y:c',
+        ],
+      ] as const)('it maps %s', function (from, to) {
+        const typePath = valuePathToTypePath<JsonPaths, typeof from>(typeDef, from)
+
+        it('maps a value path to the expected type path', function () {
+          expect(typePath).toEqual(to)
+        })
+
+        it('has expected type', function () {
+          expectTypeOf(typePath).toEqualTypeOf(to)
+        })
+      })
+
+      describe('fake', function () {
+        const fakeTypePath = valuePathToTypePath<
+          JsonPaths & {
+            '$.fake': '$.fake',
+          },
+          '$.fake'
+        >(typeDef, '$.fake', true)
+
+        it('maps a value path to the expected type path', function () {
+          expect(fakeTypePath).toEqual('$.fake')
+        })
+
+        it('has expected type', function () {
+          expectTypeOf(fakeTypePath).toEqualTypeOf<'$.fake'>()
+        })
+      })
+    })
+  })
+})

package/transformers/flatteners/value_path_to_type_path.ts

@@ -0,0 +1,164 @@
+import {
+  assertEqual,
+  assertExists,
+  assertExistsAndReturn,
+  PreconditionFailedError,
+  reduce,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  type Type,
+  type TypeDef,
+  TypeDefType,
+} from 'types/definitions'
+
+export function valuePathToTypePath<
+  JsonPaths extends Record<string, string>,
+  ValuePath extends keyof JsonPaths,
+>(
+  { definition: typeDef }: Type,
+  valuePath: ValuePath,
+  allowMissingPaths: boolean = false,
+): JsonPaths[ValuePath] {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const valueSteps = (valuePath as string).split(/\.|\[/g)
+  assertEqual(valueSteps[0], '$')
+
+  const typeSteps = internalJsonValuePathToTypePath(
+    typeDef,
+    valueSteps.slice(1),
+    allowMissingPaths,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    valuePath as string,
+  )
+  typeSteps.unshift('$')
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return typeSteps.join('.') as JsonPaths[ValuePath]
+}
+
+function internalJsonValuePathToTypePath(
+  typeDef: TypeDef,
+  valueSteps: string[],
+  allowMissingPaths: boolean,
+  originalValuePath: string,
+): string[] {
+  if (valueSteps.length === 0) {
+    return []
+  }
+  const [
+    valueStep,
+    ...remainingValueSteps
+  ] = valueSteps
+  switch (typeDef.type) {
+    case TypeDefType.Literal:
+      if (allowMissingPaths) {
+        // fake it
+        return valueSteps
+      } else {
+        throw new PreconditionFailedError(
+          'literal should terminate path {} ({})',
+          originalValuePath,
+          valueStep,
+        )
+      }
+    case TypeDefType.List:
+      // TODO assert format of current step
+      return [
+        '*',
+        ...internalJsonValuePathToTypePath(
+          typeDef.elements,
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath,
+        ),
+      ]
+    case TypeDefType.Record:
+      return [
+        '*',
+        ...internalJsonValuePathToTypePath(
+          typeDef.valueTypeDef,
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath,
+        ),
+      ]
+    case TypeDefType.Object:
+      if (allowMissingPaths) {
+        if (typeDef.fields[valueStep] == null) {
+          // fake it
+          return valueSteps
+        }
+      } else {
+        assertExists(typeDef.fields[valueStep], 'missing field in {} ({})', originalValuePath, valueStep)
+      }
+      return [
+        valueStep,
+        ...internalJsonValuePathToTypePath(
+          typeDef.fields[valueStep],
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath,
+        ),
+      ]
+    case TypeDefType.Union:
+      if (typeDef.discriminator == null) {
+        if (remainingValueSteps.length > 0) {
+          // find the non-literal typedef
+          const union = reduce<string, TypeDef, null | TypeDef>(
+            typeDef.unions,
+            function (acc, _k, v) {
+              if (v.type !== TypeDefType.Literal || v.type === TypeDefType.Literal && v.valuePrototype == null) {
+                return v
+              }
+              return acc
+            },
+            null,
+          )
+          assertExists(union, 'expected a complex union {}', originalValuePath)
+          return internalJsonValuePathToTypePath(
+            union,
+            valueSteps,
+            allowMissingPaths,
+            originalValuePath,
+          )
+        } else {
+          // doesn't really matter
+          return []
+        }
+      } else {
+        const qualifierIndex = valueStep.indexOf(':')
+        if (qualifierIndex < 0) {
+          if (allowMissingPaths) {
+            return valueSteps
+          } else {
+            throw new PreconditionFailedError(
+              'mismatched qualifiers in {} (at {})',
+              originalValuePath,
+              valueStep,
+            )
+          }
+        }
+        const qualifier = valueStep.substring(0, qualifierIndex)
+        const remainder = valueStep.substring(qualifierIndex + 1)
+        const union = assertExistsAndReturn(typeDef.unions[qualifier], 'missing union {}', qualifier)
+        const [
+          typeStep,
+          ...remainingTypeSteps
+        ] = internalJsonValuePathToTypePath(
+          union,
+          [
+            remainder,
+            ...remainingValueSteps,
+          ],
+          allowMissingPaths,
+          originalValuePath,
+        )
+        return [
+          `${qualifier}:${typeStep}`,
+          ...remainingTypeSteps,
+        ]
+      }
+    default:
+      throw new UnreachableError(typeDef)
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "baseUrl": "."
+  },
+  "extends": "../../tsconfig.build.json",
+  "include": [
+    ".eslintrc.cjs",
+    "tsup.config.ts",
+    "vitest.workspace.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "./.out"
+  },
+  "extends": "../../tsconfig.json",
+  "include": [
+    "**/*.ts",
+    "tsconfig.json"
+  ],
+  "references": [
+    {"path": "../base"},
+    {"path": "../../support/vite"}
+  ]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import {
+  defineConfig,
+  type Options,
+} from 'tsup'
+
+export default defineConfig((options: Options) => ({
+  entry: ['index.ts'],
+  tsconfig: './tsconfig.build.json',
+  clean: false,
+  dts: true,
+  format: [
+    'cjs',
+    'esm',
+  ],
+  ...options,
+}))