@matheuspuel/state-machine 0.4.0 → 0.5.0

package/src/machines/Form.test.ts

@@ -1,21 +1,20 @@
 import { describe, expect, it } from '@effect/vitest'
-import { StateMachine } from '@matheuspuel/state-machine'
-import { Form } from '@matheuspuel/state-machine/form'
+import { Form, StateMachine } from '@matheuspuel/state-machine'
 import { Effect } from 'effect'
+import { NoSuchElementException } from 'effect/Cause'
+import { ValidationError } from './Form.js'
 
 describe('Form', () => {
   it('should work', () => {
-    const formField = Form.field({
-      initial: 0,
+    const formField = Form.transformField(Form.field(0), {
       validate: _ =>
         _ > 1 ? Effect.succeed({ n: _ }) : Effect.fail('low' as const),
       fromData: (data: { n: number }) => data.n,
     })
-    const form = Form.Struct({
+    const machine = Form.Struct({
       a: formField,
       b: Form.Struct({ c: formField }),
     })
-    const machine = StateMachine.Form(form)
     const instance = StateMachine.run(machine)
     const getState = () => instance.ref.get.pipe(Effect.runSync)
     expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
@@ -64,4 +63,122 @@ describe('Form', () => {
       b: { c: { value: 3, error: null } },
     })
   })
+
+  it('TaggedUnion', () => {
+    const stateMachine = Form.TaggedUnion('_tag', {
+      A: Form.Struct({ a: Form.field(0), x: Form.field('') }),
+      B: Form.Struct({ b: Form.field(0), x: Form.field('') }),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.A.a.set(1)
+    form.actions.A.x.set('a')
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      _tag: { value: 'A', error: null },
+      A: { a: { value: 1, error: null }, x: { value: 'a', error: null } },
+      B: { b: { value: 0, error: null }, x: { value: '', error: null } },
+    })
+    const dataA = form.actions.validate().pipe(Effect.runSync)
+    expect(dataA).toStrictEqual<typeof dataA>({
+      _tag: 'A',
+      a: 1,
+      x: 'a',
+    })
+    form.actions._tag.set('B')
+    const dataB = form.actions.validate().pipe(Effect.runSync)
+    expect(dataB).toStrictEqual<typeof dataB>({
+      _tag: 'B',
+      b: 0,
+      x: '',
+    })
+  })
+
+  it('Array', () => {
+    const stateMachine = Form.Struct({
+      list: Form.Array(Form.Struct({ a: Form.NonEmptyString })),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [],
+    })
+    form.actions.list.addItem()
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: null } }],
+    })
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: new NoSuchElementException() } }],
+    })
+    form.actions.list.index(0).a.set('aaa')
+    const data = form.actions.validate().pipe(Effect.runSync)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: 'aaa', error: null } }],
+    })
+    expect(data).toStrictEqual<typeof data>({
+      list: [{ a: 'aaa' }],
+    })
+    form.actions.list.addItem()
+    form.actions.list.removeItem(0)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: null } }],
+    })
+    form.actions.setStateFromData({ list: [{ a: '1' }, { a: '2' }] })
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [
+        { a: { value: '1', error: null } },
+        { a: { value: '2', error: null } },
+      ],
+    })
+  })
+
+  it('change password example', () => {
+    const stateMachine = Form.Struct({
+      oldPassword: Form.field(''),
+      newPassword: StateMachine.mapActions(
+        Form.Struct({
+          password: Form.field(''),
+          confirmation: Form.fieldWithError<'not-match'>()(Form.field('')),
+        }),
+        actions => ({
+          ...actions,
+          validate: () =>
+            Effect.gen(function* () {
+              const result = yield* actions.validate()
+              if (result.password !== result.confirmation) {
+                actions.confirmation.error.set('not-match' as const)
+                return yield* new ValidationError({
+                  error: 'not-match' as const,
+                })
+              }
+              return result.password
+            }),
+          setStateFromData: (password: string) =>
+            actions.setStateFromData({ password, confirmation: password }),
+        }),
+      ),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.newPassword.password.set('123456')
+    form.actions.newPassword.confirmation.set('1234567')
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      oldPassword: { value: '', error: null },
+      newPassword: {
+        password: { value: '123456', error: null },
+        confirmation: { value: '1234567', error: 'not-match' },
+      },
+    })
+    form.actions.newPassword.confirmation.set('123456')
+    const data = form.actions.validate().pipe(Effect.runSync)
+    expect(data).toStrictEqual<typeof data>({
+      oldPassword: '',
+      newPassword: '123456',
+    })
+  })
 })