cogfy-data-exchange 1.0.10 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogfy-data-exchange",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/__tests__/create-flow.test.ts

@@ -15,6 +15,17 @@ const flow = {
       id: 'SCREEN_A',
       layout: {
         children: [
+          {
+            'on-click-action': {
+              name: 'data_exchange',
+              payload: {
+                test_payload: 'This is a test_payload',
+                trigger: 'screen.SCREEN_A.event.embedded_link_click'
+              }
+            },
+            text: 'This is an embedded link',
+            type: 'EmbeddedLink'
+          },
           {
             label: 'Continuar',
             'on-click-action': {
@@ -53,13 +64,19 @@ const flow = {
 describe('createFlow', () => {
   test('should dispatch screens correctly', async ({ expect }) => {
     const engine = createFlow(flow, {
-      SCREEN_A: async () => {
+      'screen.SCREEN_A': async () => {
+        return {
+          data: { age: 30 },
+          screen: 'SCREEN_B'
+        }
+      },
+      'screen.SCREEN_A.event.embedded_link_click': async () => {
         return {
           data: { age: 30 },
           screen: 'SCREEN_B'
         }
       },
-      SCREEN_B: async () => {
+      'screen.SCREEN_B': async () => {
         return {
           data: {
             profile: { age: 20, name: 'John' }
@@ -67,7 +84,7 @@ describe('createFlow', () => {
           screen: 'SCREEN_D'
         }
       },
-      SCREEN_C: async () => {
+      'screen.SCREEN_C': async () => {
         return {
           data: {
             profile: { age: 25, name: 'Jane' }
@@ -75,7 +92,7 @@ describe('createFlow', () => {
           screen: 'SCREEN_D'
         }
       },
-      SCREEN_D: async () => {
+      'screen.SCREEN_D': async () => {
         throw new Error('end')
       }
     })
@@ -87,4 +104,50 @@ describe('createFlow', () => {
       screen: 'SCREEN_B'
     })
   })
+
+  test('should dispatch embedded link event correctly', async ({ expect }) => {
+    const engine = createFlow(flow, {
+      'screen.SCREEN_A': async () => {
+        return {
+          data: { age: 30 },
+          screen: 'SCREEN_B'
+        }
+      },
+      'screen.SCREEN_A.event.embedded_link_click': async () => {
+        return {
+          data: { age: 25 },
+          screen: 'SCREEN_B'
+        }
+      },
+      'screen.SCREEN_B': async () => {
+        return {
+          data: {
+            profile: { age: 20, name: 'John' }
+          },
+          screen: 'SCREEN_D'
+        }
+      },
+      'screen.SCREEN_C': async () => {
+        return {
+          data: {
+            profile: { age: 25, name: 'Jane' }
+          },
+          screen: 'SCREEN_D'
+        }
+      },
+      'screen.SCREEN_D': async () => {
+        throw new Error('end')
+      }
+    })
+
+    const result = await engine.dispatch('screen.SCREEN_A.event.embedded_link_click', {
+      test_payload: 'This is a test_payload',
+      trigger: 'screen.SCREEN_A.event.embedded_link_click'
+    })
+
+    expect(result).toEqual({
+      data: { age: 25 },
+      screen: 'SCREEN_B'
+    })
+  })
 })

package/src/create-flow.ts

@@ -1,24 +1,25 @@
-import type { ExtractScreen, FlowJson, NextResult, PayloadByScreenId, ScreenName, ScreenTrigger } from './types'
+import type { AllTriggers, ExtractScreen, FlowJson, NextResult, PayloadByTrigger } from './types'
 
 type Handlers<F extends FlowJson> = {
-  [K in ScreenName<F>]: (data: PayloadByScreenId<F, K>) => Promise<NextResult<F, K>>
+  [K in AllTriggers<F>]: (
+    data: PayloadByTrigger<F, K, ExtractScreen<K, F>>
+  ) => Promise<NextResult<F, ExtractScreen<K, F>>>
 }
 
 /**
  * Creates a flow engine based on the provided flow definition and handlers.
  * @param flow The flow definition, which includes the routing model and screen definitions.
- * @param handlers An object mapping screen IDs to their corresponding handler functions. Each handler receives the data for its screen and returns a promise that resolves to the next result, which includes the next screen and its data.
- * @returns An object with a `dispatch` method to trigger screen handlers and the original flow definition.
+ * @param handlers An object mapping trigger strings to their corresponding handler functions. Each handler receives the payload for its trigger and returns a promise that resolves to the next result, which includes the next screen and its data.
+ * @returns An object with a `dispatch` method to trigger handlers and the original flow definition.
  */
 export function createFlow<F extends FlowJson>(flow: F, handlers: Handlers<F>) {
   return {
-    dispatch<T extends ScreenTrigger<ScreenName<F>>>(
+    dispatch<T extends AllTriggers<F>>(
       trigger: T,
-      payload: PayloadByScreenId<F, ExtractScreen<T, F>>
+      payload: PayloadByTrigger<F, T, ExtractScreen<T, F>>
     ): Promise<NextResult<F, ExtractScreen<T, F>>> {
-      const screen = trigger.replace('screen.', '') as ExtractScreen<T, F>
-
-      return handlers[screen](payload)
+      const handler = handlers[trigger] as (data: typeof payload) => Promise<NextResult<F, ExtractScreen<T, F>>>
+      return handler(payload)
     },
 
     flow

package/src/types/payload.ts

@@ -1,21 +1,27 @@
 type ExtractScreenById<T, Id extends string> = T extends {
-  screens: infer Screens;
+  screens: infer Screens
 }
   ? Screens extends readonly unknown[]
     ? Extract<Screens[number], { id: Id }>
     : never
-  : never;
+  : never
 
 type ExtractChildren<T> = T extends { layout: { children: infer C } }
   ? C extends readonly unknown[]
     ? C[number]
     : never
-  : never;
+  : never
 
-type ExtractPayload<T> = T extends { "on-click-action": { payload: infer P } }
-  ? P
-  : never;
+type ExtractPayload<T> = T extends { 'on-click-action': { payload: infer P } } ? P : never
 
-export type PayloadByScreenId<T, Id extends string> = ExtractPayload<
-  ExtractChildren<ExtractScreenById<T, Id>>
->;
+type ExtractChildByTrigger<Children, Trigger extends string> = Children extends {
+  'on-click-action': { payload: { trigger: Trigger } }
+}
+  ? Children
+  : never
+
+export type PayloadByScreenId<T, Id extends string> = ExtractPayload<ExtractChildren<ExtractScreenById<T, Id>>>
+
+export type PayloadByTrigger<T, Trigger extends string, ScreenId extends string> = ExtractPayload<
+  ExtractChildByTrigger<ExtractChildren<ExtractScreenById<T, ScreenId>>, Trigger>
+>

package/src/types/trigger.ts

@@ -3,7 +3,19 @@ import type { ScreenName } from './screen'
 
 export type ScreenTrigger<S extends string> = `screen.${S}`
 
+type AllChildTriggers<F extends FlowJson> = F['screens'][number] extends infer S
+  ? S extends { layout: { children: readonly (infer C)[] } }
+    ? C extends { 'on-click-action': { payload: { trigger: infer T } } }
+      ? T extends string
+        ? T
+        : never
+      : never
+    : never
+  : never
+
+export type AllTriggers<F extends FlowJson> = ScreenTrigger<ScreenName<F>> | AllChildTriggers<F>
+
 export type ExtractScreen<T extends string, F extends FlowJson> = Extract<
-  T extends `screen.${infer S}` ? S : never,
+  T extends `screen.${infer S}.event.${string}` ? S : T extends `screen.${infer S}` ? S : never,
   ScreenName<F>
 >