@strictly/react-form 0.0.1 → 0.0.2

package/core/mobx/specs/merge_field_adapters_with_two_way_converter.ts

@@ -0,0 +1,140 @@
+import { type FieldAdapter } from 'core/mobx/field_adapter'
+import { identityAdapter } from 'core/mobx/field_adapter_builder'
+import {
+  type MergedOfFieldAdaptersWithTwoWayConverter,
+  mergeFieldAdaptersWithTwoWayConverter,
+} from 'core/mobx/merge_field_adapters_with_two_way_converter'
+import {
+  annotatedIdentityConverter,
+  unreliableIdentityConverter,
+} from 'field_converters/identity_converter'
+import {
+  type TwoWayFieldConverter,
+  UnreliableFieldConversionType,
+} from 'types/field_converters'
+import {
+  createMockedAdapter,
+  createMockTwoWayFieldConverter,
+  resetMockAdapter,
+  resetMockTwoWayFieldConverter,
+} from './fixtures'
+
+const error1 = Symbol()
+const error2 = Symbol()
+const error3 = Symbol()
+const error4 = Symbol()
+const context = Symbol()
+
+describe('MergedOfFieldAdapterWithTwoWayConverter', function () {
+  type T = {
+    readonly x: FieldAdapter<boolean, string, typeof error1, 'x', typeof context>,
+    readonly y: FieldAdapter<number, boolean, typeof error2, 'y', typeof context>,
+    readonly z: FieldAdapter<string, number, typeof error3, 'z', typeof context>,
+  }
+  type M = MergedOfFieldAdaptersWithTwoWayConverter<T, typeof error4, typeof context>
+
+  let m: {
+    readonly x: FieldAdapter<boolean, string, typeof error1 | typeof error4, 'x', typeof context>,
+    readonly y: FieldAdapter<number, boolean, typeof error2 | typeof error4, 'y', typeof context>,
+    readonly z: FieldAdapter<string, number, typeof error3 | typeof error4, 'z', typeof context>,
+  }
+
+  it('merges the errors', function () {
+    expectTypeOf<M>().toEqualTypeOf(m)
+  })
+})
+
+const originalIntegerAdapter = identityAdapter(0)
+const originalBooleanAdapter = identityAdapter(false, true)
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const originalConverter: TwoWayFieldConverter<any, any, typeof error4, string, typeof context> = {
+  convert: annotatedIdentityConverter(),
+  revert: unreliableIdentityConverter(),
+}
+
+describe('mergeFieldAdaptersWithTwoWayConverter', function () {
+  const integerAdapter = createMockedAdapter(
+    originalIntegerAdapter,
+  )
+  const booleanAdapter = createMockedAdapter(
+    originalBooleanAdapter,
+  )
+
+  beforeEach(function () {
+    resetMockAdapter(originalIntegerAdapter, integerAdapter)
+    resetMockAdapter(originalBooleanAdapter, booleanAdapter)
+  })
+
+  describe('two entries', function () {
+    const fieldAdapters = {
+      integerAdapter,
+      booleanAdapter,
+    }
+
+    const converter = createMockTwoWayFieldConverter(originalConverter)
+
+    beforeEach(function () {
+      resetMockTwoWayFieldConverter(originalConverter, converter)
+    })
+
+    const merged = mergeFieldAdaptersWithTwoWayConverter(fieldAdapters, converter)
+
+    describe('convert', function () {
+      let result: ReturnType<typeof merged.booleanAdapter.convert>
+
+      describe('success', function () {
+        // note don't really need to exercise this too extensively since most of
+        // the work is done in chainXFieldAdapter
+        beforeEach(function () {
+          result = merged.booleanAdapter.convert(true, 'booleanAdapter', context)
+        })
+
+        it('returns the same value on convert', function () {
+          expect(result).toEqual(expect.objectContaining({
+            value: true,
+          }))
+        })
+
+        it('calls the mocked converter', function () {
+          expect(converter.convert).toHaveBeenCalledOnce()
+          expect(converter.convert).toHaveBeenCalledWith(true, 'booleanAdapter', context)
+        })
+
+        it('calls the mocked adapter', function () {
+          expect(booleanAdapter.convert).toHaveBeenCalledOnce()
+          expect(booleanAdapter.convert).toHaveBeenCalledWith(true, 'booleanAdapter', context)
+        })
+      })
+    })
+
+    describe('revert', function () {
+      let result: ReturnType<NonNullable<typeof merged.booleanAdapter.revert>>
+
+      describe('success', function () {
+        // note don't really need to exercise this too extensively since most of
+        // the work is done in chainXFieldAdapter
+        beforeEach(function () {
+          result = merged.booleanAdapter.revert!(true, 'booleanAdapter', context)
+        })
+      })
+
+      it('returns the same value on revert', function () {
+        expect(result).toEqual(expect.objectContaining({
+          value: true,
+          type: UnreliableFieldConversionType.Success,
+        }))
+      })
+
+      it('calls the mocked converter', function () {
+        expect(converter.revert).toHaveBeenCalledOnce()
+        expect(converter.revert).toHaveBeenCalledWith(true, 'booleanAdapter', context)
+      })
+
+      it('calls the mocked adapter', function () {
+        expect(booleanAdapter.revert).toHaveBeenCalledOnce()
+        expect(booleanAdapter.revert).toHaveBeenCalledWith(true, 'booleanAdapter', context)
+      })
+    })
+  })
+})

package/core/mobx/specs/merge_field_adapters_with_validators.tests.ts

@@ -0,0 +1,259 @@
+import {
+  expectDefined,
+  expectEquals,
+} from '@strictly/base'
+import {
+  type AnnotatedValidator,
+  type FunctionalValidator,
+  type Validator,
+} from '@strictly/define'
+import { type FieldAdapter } from 'core/mobx/field_adapter'
+import {
+  identityAdapter,
+} from 'core/mobx/field_adapter_builder'
+import {
+  mergeAdaptersWithValidators,
+  type MergedOfFieldAdaptersWithValidators,
+} from 'core/mobx/merge_field_adapters_with_validators'
+import { UnreliableFieldConversionType } from 'types/field_converters'
+import {
+  createMockedAdapter,
+  resetMockAdapter,
+} from './fixtures'
+
+const error1 = 'error 1'
+const error2 = 'error 2'
+const context = 'context 1'
+
+describe('MergedOfFieldAdaptersWithValidators', function () {
+  describe('empty validators', function () {
+    type Adapters = {
+      readonly a: FieldAdapter<number, string, typeof error1, 'a', typeof context>,
+    }
+    type Validators = {}
+
+    type Merged = MergedOfFieldAdaptersWithValidators<Adapters, Validators>
+
+    it('does not change the adapters', function () {
+      expectTypeOf<Merged>().toEqualTypeOf<Adapters>()
+    })
+  })
+
+  describe('different errors', function () {
+    type Adapters = {
+      readonly a: FieldAdapter<number, string, typeof error1, 'a', typeof context>,
+    }
+    type Validators = {
+      readonly a: Validator<number, typeof error2, 'a', typeof context>,
+    }
+
+    type Merged = MergedOfFieldAdaptersWithValidators<Adapters, Validators>
+
+    it('merges the error types', function () {
+      expectTypeOf<Merged>().toEqualTypeOf<{
+        readonly a: FieldAdapter<number, string, typeof error1 | typeof error2, 'a', typeof context>,
+      }>()
+    })
+  })
+
+  describe('different paths', function () {
+    type Adapters = {
+      readonly a: FieldAdapter<number, string, typeof error1, string, typeof context>,
+    }
+    type Validators = {
+      readonly a: Validator<number, typeof error2, 'a', typeof context>,
+    }
+
+    type Merged = MergedOfFieldAdaptersWithValidators<Adapters, Validators>
+
+    it('merges the error types', function () {
+      expectTypeOf<Merged>().toEqualTypeOf<{
+        readonly a: FieldAdapter<number, string, typeof error1 | typeof error2, string, typeof context>,
+      }>()
+    })
+  })
+
+  describe('different values', function () {
+    type Adapters = {
+      readonly a: FieldAdapter<number, string, typeof error1, 'a', typeof context>,
+    }
+    type Validators = {
+      readonly a: Validator<boolean, typeof error2, 'a', typeof context>,
+    }
+
+    type Merged = MergedOfFieldAdaptersWithValidators<Adapters, Validators>
+
+    it('removes mismatched values', function () {
+      expectTypeOf<Merged>().toEqualTypeOf<{
+        readonly a: never,
+      }>()
+    })
+  })
+})
+
+const originalIntegerToIntegerAdapter = identityAdapter(0)
+const originalBooleanToBooleanAdapter = identityAdapter(false, true)
+
+describe('mergeFieldAdaptersWithValidators', function () {
+  const integerToIntegerAdapter = createMockedAdapter(
+    originalIntegerToIntegerAdapter,
+  )
+  const booleanToBooleanAdapter = createMockedAdapter(
+    originalBooleanToBooleanAdapter,
+  )
+
+  const failingValidator1 = vi.fn<FunctionalValidator>(function () {
+    return 'fail 1'
+  })
+
+  const failingValidator2 = vi.fn<FunctionalValidator>(function () {
+    return 'fail 2'
+  })
+
+  const requiredValidator: AnnotatedValidator = {
+    validate: () => null,
+    annotations: () => ({
+      required: true,
+      readonly: false,
+    }),
+  }
+
+  const readonlyValidator: AnnotatedValidator = {
+    validate: () => null,
+    annotations: () => ({
+      required: false,
+      readonly: true,
+    }),
+  }
+
+  beforeEach(function () {
+    resetMockAdapter(originalIntegerToIntegerAdapter, integerToIntegerAdapter)
+    resetMockAdapter(originalBooleanToBooleanAdapter, booleanToBooleanAdapter)
+    failingValidator1.mockClear()
+    failingValidator2.mockClear()
+  })
+
+  describe('record contents', function () {
+    describe('empty validators', function () {
+      const adapters = {
+        a: integerToIntegerAdapter,
+        b: booleanToBooleanAdapter,
+      } as const
+      const validators = {} as const
+
+      const merged = mergeAdaptersWithValidators(adapters, validators)
+      it('does not change the adapters', function () {
+        expect(merged).toEqual(adapters)
+      })
+    })
+
+    describe('populated validators', function () {
+      const adapters = {
+        a: integerToIntegerAdapter,
+        b: booleanToBooleanAdapter,
+        c: integerToIntegerAdapter,
+        d: integerToIntegerAdapter,
+      } as const
+      const validators = {
+        a: failingValidator1,
+        b: failingValidator2,
+        c: requiredValidator,
+        d: readonlyValidator,
+      } as const
+
+      const merged = mergeAdaptersWithValidators(adapters, validators)
+
+      describe('matching validators', function () {
+        it('has the same keys', function () {
+          expect([...Object.keys(adapters)]).toEqual([
+            'a',
+            'b',
+            'c',
+            'd',
+          ])
+        })
+      })
+
+      describe('revert', function () {
+        it.each([
+          [
+            'a',
+            'fail 1',
+            1,
+          ],
+          [
+            'b',
+            'fail 2',
+            true,
+          ],
+        ] as const)('field %s fails with validation %s', function (key, error, value) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const mergedAdapter: FieldAdapter<any, any, string, any> = merged[key]
+          expectDefined(mergedAdapter.revert)
+          const result = mergedAdapter.revert(value, key, null)
+          expectEquals(result.type, UnreliableFieldConversionType.Failure)
+          expect(result.error).toEqual(error)
+        })
+
+        it.each([
+          [
+            'c',
+            1,
+          ],
+          [
+            'd',
+            true,
+          ],
+        ] as const)('field %s succeeds with value %s', function (key, value) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const mergedAdapter: FieldAdapter<any, any, string, any> = merged[key]
+          expectDefined(mergedAdapter.revert)
+          const result = mergedAdapter.revert(value, key, null)
+          expectEquals(result.type, UnreliableFieldConversionType.Success)
+          expect(result.value).toEqual(value)
+        })
+      })
+
+      describe('convert', function () {
+        it.each([
+          [
+            'a',
+            false,
+            false,
+            1,
+          ],
+          [
+            'b',
+            true,
+            false,
+            true,
+          ],
+          [
+            'c',
+            true,
+            false,
+            2,
+          ],
+          [
+            'd',
+            false,
+            true,
+            3,
+          ],
+        ] as const)(
+          'field %s is required %s and readonly %s',
+          function (key, expectedRequired, expectedReadonly, value) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const adapter: FieldAdapter<any, any, string, any> = merged[key]
+            const {
+              required,
+              readonly,
+            } = adapter.convert(value, key, null)
+            expect(required).toEqual(expectedRequired)
+            expect(readonly).toEqual(expectedReadonly)
+          },
+        )
+      })
+    })
+  })
+})

package/core/mobx/types.ts

@@ -1,5 +1,5 @@
 // TODO rename/split-out this file
-import { type ToTypeOfFieldAdapter } from './field_adapter'
+import { type ToOfFieldAdapter } from './field_adapter'
 import {
   type FlattenedConvertedFieldsOf,
   type FormPresenter,
@@ -23,7 +23,7 @@ export type ValuePathsOfPresenter<
  * Used to extract the render type (so the value that is passed to the view) of a given value path
  * from a presenter
  */
-export type ToTypeOfPresenterValuePath<
+export type ToValueOfPresenterValuePath<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Presenter extends FormPresenter<any, any, any, any>,
   K extends ValuePathsOfPresenter<Presenter>,
@@ -32,7 +32,7 @@ export type ToTypeOfPresenterValuePath<
   infer _2,
   infer _3,
   infer ValuePathsToAdapters
-> ? ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>
+> ? ToOfFieldAdapter<ValuePathsToAdapters[K]>
   : never
 
 /**