@incodetech/core 2.0.0-alpha.2 → 2.0.0-alpha.4

package/src/flow/flowStateMachine.ts

@@ -1,182 +0,0 @@
-import { assign, fromPromise, setup } from '@incodetech/infra';
-import type { Flow } from './types';
-
-export type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
-
-export type FlowContext = {
-  flow: Flow | undefined;
-  error: string | undefined;
-  steps: string[];
-  currentStepIndex: number;
-  currentStep: string | undefined;
-  config: unknown;
-  getFlow: GetFlowFn;
-};
-
-export type FlowEvent =
-  | { type: 'LOAD' }
-  | { type: 'CANCEL' }
-  | { type: 'RESET' }
-  | { type: 'NEXT_STEP' }
-  | { type: 'PREV_STEP' };
-
-export type FlowInput = {
-  getFlow: GetFlowFn;
-};
-
-export const flowMachine = setup({
-  types: {
-    context: {} as FlowContext,
-    events: {} as FlowEvent,
-    input: {} as FlowInput,
-  },
-  actors: {
-    fetchFlow: fromPromise<Flow, { getFlow: GetFlowFn }>(
-      async ({ input, signal }) => {
-        return input.getFlow(signal);
-      },
-    ),
-  },
-  actions: {
-    resetContext: assign(({ context }) => ({
-      flow: undefined,
-      error: undefined,
-      steps: [],
-      currentStepIndex: -1,
-      currentStep: undefined,
-      config: undefined,
-      getFlow: context.getFlow,
-    })),
-    setFlowData: assign(({ event }) => {
-      const flow = (event as unknown as { output: Flow }).output;
-      return {
-        flow,
-        steps: (flow.flowModules ?? []).map((m) => m.key),
-        currentStepIndex: (flow.flowModules ?? []).length > 0 ? 0 : -1,
-        currentStep: flow.flowModules?.[0]?.key,
-        config: flow.flowModules?.[0]?.configuration,
-      };
-    }),
-    setError: assign(({ event }) => ({
-      error: String((event as unknown as { error: unknown }).error),
-    })),
-    incrementStep: assign(({ context }) => {
-      const nextIndex = context.currentStepIndex + 1;
-      const module = context.flow?.flowModules?.[nextIndex];
-      return {
-        currentStepIndex: nextIndex,
-        currentStep: module?.key,
-        config: module?.configuration,
-      };
-    }),
-    decrementStep: assign(({ context }) => {
-      const prevIndex = context.currentStepIndex - 1;
-      const module = context.flow?.flowModules?.[prevIndex];
-      return {
-        currentStepIndex: prevIndex,
-        currentStep: module?.key,
-        config: module?.configuration,
-      };
-    }),
-  },
-  guards: {
-    isLastStep: ({ context }) =>
-      context.currentStepIndex >= 0 &&
-      context.currentStepIndex === context.steps.length - 1,
-    canGoNext: ({ context }) =>
-      context.currentStepIndex >= 0 &&
-      context.currentStepIndex < context.steps.length - 1,
-    canGoPrev: ({ context }) => context.currentStepIndex > 0,
-  },
-}).createMachine({
-  id: 'flow',
-  initial: 'idle',
-  context: ({ input }) => ({
-    flow: undefined,
-    error: undefined,
-    steps: [],
-    currentStepIndex: -1,
-    currentStep: undefined,
-    config: undefined,
-    getFlow: input.getFlow,
-  }),
-  states: {
-    idle: {
-      on: {
-        LOAD: {
-          target: 'loading',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    loading: {
-      invoke: {
-        id: 'fetchFlow',
-        src: 'fetchFlow',
-        input: ({ context }) => ({
-          getFlow: context.getFlow,
-        }),
-        onDone: {
-          target: 'ready',
-          actions: 'setFlowData',
-        },
-        onError: {
-          target: 'error',
-          actions: 'setError',
-        },
-      },
-      on: {
-        CANCEL: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    ready: {
-      on: {
-        NEXT_STEP: [
-          {
-            target: 'finished',
-            guard: 'isLastStep',
-          },
-          {
-            target: 'ready',
-            guard: 'canGoNext',
-            actions: 'incrementStep',
-          },
-        ],
-        PREV_STEP: {
-          target: 'ready',
-          guard: 'canGoPrev',
-          actions: 'decrementStep',
-        },
-        RESET: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    finished: {
-      on: {
-        RESET: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    error: {
-      on: {
-        RESET: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-  },
-});
-
-export type FlowMachine = typeof flowMachine;

package/src/flow/index.ts

@@ -1,21 +0,0 @@
-export { getRequiredWasmPipelines } from './flowAnalyzer';
-export type { FinishStatus } from './flowCompletionService';
-export type { FlowReadyState, FlowState } from './flowManager';
-export { createFlowManager } from './flowManager';
-export {
-  createModuleLoader,
-  type LazyModule,
-  type ModuleLoader,
-  type ModuleLoaderRegistry,
-} from './moduleLoader';
-export {
-  createOrchestratedFlowManager,
-  type OrchestratedFlowFinishedState,
-  type OrchestratedFlowReadyState,
-  type OrchestratedFlowState,
-} from './orchestratedFlowManager';
-export type {
-  ModuleRegistry,
-  OrchestratedFlowInput,
-} from './orchestratedFlowStateMachine';
-export type { Flow, FlowModule, FlowModuleConfig } from './types';

package/src/flow/moduleLoader.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createModuleLoader, type ModuleLoaderRegistry } from './moduleLoader';
-
-describe('createModuleLoader', () => {
-  it('should create a module loader', () => {
-    const registry: ModuleLoaderRegistry = {
-      TEST: async () => ({ default: 'test' }),
-    };
-    const loader = createModuleLoader(registry);
-
-    expect(loader).toBeDefined();
-    expect(loader.load).toBeDefined();
-    expect(loader.prefetch).toBeDefined();
-    expect(loader.isLoaded).toBeDefined();
-  });
-
-  describe('load', () => {
-    it('should load a module', async () => {
-      const registry: ModuleLoaderRegistry = {
-        TEST: async () => ({ default: 'test-value' }),
-      };
-      const loader = createModuleLoader(registry);
-
-      const result = await loader.load('TEST');
-      expect(result).toBe('test-value');
-    });
-
-    it('should cache loaded modules', async () => {
-      const loadFn = vi.fn().mockResolvedValue({ default: 'test-value' });
-      const registry: ModuleLoaderRegistry = {
-        TEST: loadFn,
-      };
-      const loader = createModuleLoader(registry);
-
-      await loader.load('TEST');
-      await loader.load('TEST');
-
-      expect(loadFn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should throw error for unknown module', async () => {
-      const registry: ModuleLoaderRegistry = {};
-      const loader = createModuleLoader(registry);
-
-      await expect(loader.load('UNKNOWN')).rejects.toThrow(
-        'Module UNKNOWN not found in registry',
-      );
-    });
-
-    it('should remove from cache on load error', async () => {
-      const loadFn = vi
-        .fn()
-        .mockRejectedValueOnce(new Error('Load failed'))
-        .mockResolvedValueOnce({ default: 'test-value' });
-      const registry: ModuleLoaderRegistry = {
-        TEST: loadFn,
-      };
-      const loader = createModuleLoader(registry);
-
-      await expect(loader.load('TEST')).rejects.toThrow('Load failed');
-      expect(loader.isLoaded('TEST')).toBe(false);
-
-      const result = await loader.load('TEST');
-      expect(result).toBe('test-value');
-    });
-  });
-
-  describe('prefetch', () => {
-    it('should prefetch a module', () => {
-      const loadFn = vi.fn().mockResolvedValue({ default: 'test-value' });
-      const registry: ModuleLoaderRegistry = {
-        TEST: loadFn,
-      };
-      const loader = createModuleLoader(registry);
-
-      loader.prefetch('TEST');
-
-      expect(loadFn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not prefetch already loaded modules', () => {
-      const loadFn = vi.fn().mockResolvedValue({ default: 'test-value' });
-      const registry: ModuleLoaderRegistry = {
-        TEST: loadFn,
-      };
-      const loader = createModuleLoader(registry);
-
-      loader.prefetch('TEST');
-      loader.prefetch('TEST');
-
-      expect(loadFn).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not prefetch unknown modules', () => {
-      const registry: ModuleLoaderRegistry = {};
-      const loader = createModuleLoader(registry);
-
-      expect(() => loader.prefetch('UNKNOWN')).not.toThrow();
-    });
-
-    it('should handle prefetch errors gracefully', async () => {
-      const loadFn = vi.fn().mockRejectedValue(new Error('Prefetch failed'));
-      const registry: ModuleLoaderRegistry = {
-        TEST: loadFn,
-      };
-      const loader = createModuleLoader(registry);
-
-      loader.prefetch('TEST');
-
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      expect(loader.isLoaded('TEST')).toBe(false);
-    });
-  });
-
-  describe('isLoaded', () => {
-    it('should return false for unloaded module', () => {
-      const registry: ModuleLoaderRegistry = {
-        TEST: async () => ({ default: 'test-value' }),
-      };
-      const loader = createModuleLoader(registry);
-
-      expect(loader.isLoaded('TEST')).toBe(false);
-    });
-
-    it('should return true for loaded module', async () => {
-      const registry: ModuleLoaderRegistry = {
-        TEST: async () => ({ default: 'test-value' }),
-      };
-      const loader = createModuleLoader(registry);
-
-      await loader.load('TEST');
-      expect(loader.isLoaded('TEST')).toBe(true);
-    });
-  });
-});

package/src/flow/moduleLoader.ts

@@ -1,73 +0,0 @@
-export type LazyModule<T> = () => Promise<T>;
-
-export type ModuleLoaderRegistry = {
-  [key: string]: LazyModule<{ default: unknown }>;
-};
-
-export interface ModuleLoader {
-  load<T>(moduleKey: string): Promise<T>;
-  prefetch(moduleKey: string): void;
-  isLoaded(moduleKey: string): boolean;
-}
-
-class ModuleLoaderImpl implements ModuleLoader {
-  private loadedModules = new Map<string, Promise<unknown>>();
-  private prefetchedModules = new Set<string>();
-
-  constructor(private registry: ModuleLoaderRegistry) {}
-
-  async load<T>(moduleKey: string): Promise<T> {
-    if (!this.registry[moduleKey]) {
-      throw new Error(`Module ${moduleKey} not found in registry`);
-    }
-
-    const cached = this.loadedModules.get(moduleKey);
-    if (cached) {
-      return (await cached) as T;
-    }
-
-    const loadPromise = this.registry[moduleKey]().then((module) => {
-      if (module && typeof module === 'object' && 'default' in module) {
-        return module.default;
-      }
-      return module;
-    });
-
-    this.loadedModules.set(moduleKey, loadPromise);
-
-    try {
-      return (await loadPromise) as T;
-    } catch (error) {
-      this.loadedModules.delete(moduleKey);
-      throw error;
-    }
-  }
-
-  prefetch(moduleKey: string): void {
-    if (!this.registry[moduleKey]) {
-      return;
-    }
-
-    if (
-      this.prefetchedModules.has(moduleKey) ||
-      this.loadedModules.has(moduleKey)
-    ) {
-      return;
-    }
-
-    this.prefetchedModules.add(moduleKey);
-    this.registry[moduleKey]().catch(() => {
-      this.prefetchedModules.delete(moduleKey);
-    });
-  }
-
-  isLoaded(moduleKey: string): boolean {
-    return this.loadedModules.has(moduleKey);
-  }
-}
-
-export function createModuleLoader(
-  registry: ModuleLoaderRegistry,
-): ModuleLoader {
-  return new ModuleLoaderImpl(registry);
-}

package/src/flow/orchestratedFlowManager.test.ts

@@ -1,240 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { mockPhoneConfig } from '../phone/__mocks__/phoneMocks';
-import { phoneMachine } from '../phone/phoneStateMachine';
-import {
-  createFailingGetFlow,
-  createMockGetFlow,
-  mockFlow,
-} from './__mocks__/flowMocks';
-import { createOrchestratedFlowManager } from './orchestratedFlowManager';
-import type { FlowModule } from './types';
-
-vi.mock('./flowCompletionService', () => ({
-  getFinishStatus: vi.fn().mockResolvedValue({
-    redirectionUrl: 'https://example.com/success',
-    action: 'approved' as const,
-    scoreStatus: 'OK' as const,
-  }),
-}));
-
-vi.mock('../phone/phoneServices', () => ({
-  fetchPhone: vi.fn().mockResolvedValue({ phone: '+14155551234' }),
-  fetchStartInfo: vi.fn().mockResolvedValue({
-    ipIsoCode: 'US',
-    phonePrefix: '+1',
-    country: 'United States',
-  }),
-  addPhone: vi.fn().mockResolvedValue({ success: true }),
-  addPhoneInstantVerify: vi.fn().mockResolvedValue({ success: true }),
-  sendOtp: vi.fn().mockResolvedValue(undefined),
-  verifyOtp: vi.fn().mockResolvedValue({ success: true }),
-}));
-
-vi.mock('../events/addEvent', () => ({
-  addEvent: vi.fn().mockResolvedValue(undefined),
-}));
-
-describe('createOrchestratedFlowManager', () => {
-  describe('Initial state', () => {
-    it('should create an orchestrated flow manager', () => {
-      const getFlow = createMockGetFlow();
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      expect(manager).toBeDefined();
-      expect(manager.getState).toBeDefined();
-      expect(manager.subscribe).toBeDefined();
-      expect(manager.stop).toBeDefined();
-      expect(manager.load).toBeDefined();
-      expect(manager.cancel).toBeDefined();
-      expect(manager.reset).toBeDefined();
-      expect(manager.send).toBeDefined();
-      expect(manager.getModuleConfig).toBeDefined();
-      expect(manager.isModuleEnabled).toBeDefined();
-      manager.stop();
-    });
-
-    it('should start in idle state', () => {
-      const getFlow = createMockGetFlow();
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      expect(manager.getState()).toEqual({ status: 'idle' });
-      manager.stop();
-    });
-  });
-
-  describe('Loading flow', () => {
-    it('should transition to loading when load() is called', () => {
-      const getFlow = createMockGetFlow();
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-      expect(manager.getState().status).toBe('loading');
-      manager.stop();
-    });
-
-    it('should transition to ready when flow is loaded', async () => {
-      const flowWithPhone = {
-        ...mockFlow,
-        flowModules: [
-          {
-            key: 'PHONE',
-            configuration: mockPhoneConfig,
-          } as FlowModule,
-        ],
-      };
-      const getFlow = createMockGetFlow(flowWithPhone);
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      const state = manager.getState();
-      expect(state.status).toBe('ready');
-      if (state.status === 'ready') {
-        expect(state.currentStep).toBe('PHONE');
-        expect(state.config).toBeDefined();
-      }
-      manager.stop();
-    });
-
-    it('should transition to error when flow loading fails', async () => {
-      const getFlow = createFailingGetFlow('Network error');
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      const state = manager.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.error).toContain('Network error');
-      }
-      manager.stop();
-    });
-  });
-
-  describe('State exposure', () => {
-    it('should expose module state in ready state', async () => {
-      const flowWithPhone = {
-        ...mockFlow,
-        flowModules: [
-          {
-            key: 'PHONE',
-            configuration: mockPhoneConfig,
-          } as FlowModule,
-        ],
-      };
-      const getFlow = createMockGetFlow(flowWithPhone);
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      const state = manager.getState();
-      expect(state.status).toBe('ready');
-      if (state.status === 'ready') {
-        expect(state.moduleState).toBeDefined();
-      }
-      manager.stop();
-    });
-  });
-
-  describe('Module configuration', () => {
-    it('should get module config for registered module', async () => {
-      const flowWithPhone = {
-        ...mockFlow,
-        flowModules: [
-          {
-            key: 'PHONE',
-            configuration: mockPhoneConfig,
-          } as FlowModule,
-        ],
-      };
-      const getFlow = createMockGetFlow(flowWithPhone);
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      const config = manager.getModuleConfig<typeof mockPhoneConfig>('PHONE');
-      expect(config).toBeDefined();
-      manager.stop();
-    });
-
-    it('should return undefined for unregistered module', async () => {
-      const flowWithPhone = {
-        ...mockFlow,
-        flowModules: [
-          {
-            key: 'PHONE',
-            configuration: mockPhoneConfig,
-          } as FlowModule,
-        ],
-      };
-      const getFlow = createMockGetFlow(flowWithPhone);
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      // SELFIE is not in the flow, so should return undefined
-      const config = manager.getModuleConfig('SELFIE');
-      expect(config).toBeUndefined();
-      manager.stop();
-    });
-
-    it('should check if module is enabled', async () => {
-      const flowWithPhone = {
-        ...mockFlow,
-        flowModules: [
-          {
-            key: 'PHONE',
-            configuration: mockPhoneConfig,
-          } as FlowModule,
-        ],
-      };
-      const getFlow = createMockGetFlow(flowWithPhone);
-      const manager = createOrchestratedFlowManager({
-        getFlow,
-        modules: { PHONE: phoneMachine },
-      });
-
-      manager.load();
-
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      expect(manager.isModuleEnabled('PHONE')).toBe(true);
-      expect(manager.isModuleEnabled('SELFIE')).toBe(false);
-      manager.stop();
-    });
-  });
-});