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

package/src/selfie/selfieUploadService.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { uploadSelfie } from './selfieUploadService';
-import { FACE_ERROR_CODES } from './types';
-
-vi.mock('../device', () => ({
-  getDeviceClass: vi.fn(() => 'desktop'),
-}));
-
-vi.mock('../http/api', () => ({
-  api: {
-    post: vi.fn(),
-  },
-}));
-
-describe('selfieUploadService', () => {
-  it('returns data on success', async () => {
-    const { api } = await import('../http/api');
-    vi.mocked(api.post).mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      statusText: 'OK',
-      url: 'x',
-      headers: {},
-      data: {
-        age: 1,
-        confidence: 0,
-        hasClosedEyes: false,
-        hasFaceMask: false,
-        hasHeadCover: false,
-        hasLenses: false,
-        isBright: true,
-        liveness: true,
-        imageBase64: '',
-        sessionStatus: 'ok',
-      },
-    });
-
-    await expect(
-      uploadSelfie({ encryptedBase64Image: 'abc', faceCoordinates: undefined }),
-    ).resolves.toMatchObject({ confidence: 0, sessionStatus: 'ok' });
-  });
-
-  it('maps HTTP 400 status 4019 to FACE_NOT_FOUND', async () => {
-    const { api } = await import('../http/api');
-    vi.mocked(api.post).mockRejectedValueOnce({
-      ok: false,
-      status: 400,
-      data: { status: 4019 },
-    });
-
-    await expect(
-      uploadSelfie({ encryptedBase64Image: 'abc', faceCoordinates: undefined }),
-    ).rejects.toThrow(FACE_ERROR_CODES.FACE_NOT_FOUND);
-  });
-
-  it('maps HTTP 400 with missing backend status to BAD_REQUEST', async () => {
-    const { api } = await import('../http/api');
-    vi.mocked(api.post).mockRejectedValueOnce({
-      ok: false,
-      status: 400,
-      data: {},
-    });
-
-    await expect(
-      uploadSelfie({ encryptedBase64Image: 'abc', faceCoordinates: undefined }),
-    ).rejects.toThrow(FACE_ERROR_CODES.BAD_REQUEST);
-  });
-
-  it('maps non-400 HTTP error to SERVER_ERROR', async () => {
-    const { api } = await import('../http/api');
-    vi.mocked(api.post).mockRejectedValueOnce({
-      ok: false,
-      status: 500,
-      data: { status: 9999 },
-    });
-
-    await expect(
-      uploadSelfie({ encryptedBase64Image: 'abc', faceCoordinates: undefined }),
-    ).rejects.toThrow(FACE_ERROR_CODES.SERVER);
-  });
-
-  it('maps unknown error shapes to SERVER_ERROR', async () => {
-    const { api } = await import('../http/api');
-    vi.mocked(api.post).mockRejectedValueOnce(new Error('boom'));
-
-    await expect(
-      uploadSelfie({ encryptedBase64Image: 'abc', faceCoordinates: undefined }),
-    ).rejects.toThrow(FACE_ERROR_CODES.SERVER);
-  });
-});

package/src/selfie/selfieUploadService.ts

@@ -1,81 +0,0 @@
-import type { FaceCoordinates } from '@incodetech/infra';
-import { getDeviceClass } from '../device';
-import { api } from '../http/api';
-import { endpoints } from '../http/endpoints';
-import type { FaceErrorCode, SendFaceImageResponse } from './types';
-import { FACE_ERROR_CODES } from './types';
-
-export type UploadSelfieParams = {
-  encryptedBase64Image: string;
-  faceCoordinates?: FaceCoordinates;
-  signal?: AbortSignal;
-};
-
-/**
- * Uploads a selfie image to the backend.
- */
-export async function uploadSelfie({
-  encryptedBase64Image,
-  faceCoordinates,
-  signal,
-}: UploadSelfieParams): Promise<SendFaceImageResponse> {
-  try {
-    const res = await api.post<SendFaceImageResponse>(
-      endpoints.selfie,
-      {
-        base64Image: encryptedBase64Image,
-        faceCoordinates: faceCoordinates ?? undefined,
-        encrypted: true,
-        clientInfo: { deviceClass: getDeviceClass() },
-      },
-      { signal, query: { imageType: 'selfie' } },
-    );
-    if (!res.ok) {
-      throw new Error(
-        `POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`,
-      );
-    }
-    return res.data as SendFaceImageResponse;
-  } catch (error) {
-    const errorCode = getFaceErrorCodeFromHttpError(error);
-    if (errorCode) {
-      throw new Error(errorCode);
-    }
-    throw new Error(FACE_ERROR_CODES.SERVER);
-  }
-}
-
-const getFaceErrorCodeFromHttpError = (
-  error: unknown,
-): FaceErrorCode | undefined => {
-  const err = error as {
-    ok?: boolean;
-    status?: number;
-    data?: { status?: number };
-  };
-
-  if (err.ok !== false || typeof err.status !== 'number') {
-    return undefined;
-  }
-
-  if (err.status !== 400) {
-    return FACE_ERROR_CODES.SERVER;
-  }
-
-  if (typeof err.data?.status !== 'number') {
-    return FACE_ERROR_CODES.BAD_REQUEST;
-  }
-
-  const errorMap: Record<number, FaceErrorCode> = {
-    3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
-    3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
-    3006: FACE_ERROR_CODES.TOO_BLURRY,
-    3007: FACE_ERROR_CODES.TOO_DARK,
-    4010: FACE_ERROR_CODES.MULTIPLE_FACES,
-    4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
-    4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-    4078: FACE_ERROR_CODES.FACE_OCCLUDED,
-  };
-
-  return errorMap[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
-};

package/src/selfie/types.ts

@@ -1,103 +0,0 @@
-import type {
-  IRecordingCapability,
-  RecordingConnection,
-} from '@incodetech/infra';
-
-export type { PermissionResult, PermissionStatus } from '../permissions/types';
-
-export type SelfieConfig = {
-  showTutorial: boolean;
-  showPreview: boolean;
-  assistedOnboarding: boolean;
-  enableFaceRecording: boolean;
-  recording?: {
-    capability?: IRecordingCapability;
-  };
-  autoCaptureTimeout: number;
-  captureAttempts: number;
-  validateLenses: boolean;
-  validateFaceMask: boolean;
-  validateHeadCover: boolean;
-  validateClosedEyes: boolean;
-  validateBrightness: boolean;
-  deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
-};
-
-export type DetectionStatus =
-  | 'idle'
-  | 'detecting'
-  | 'noFace'
-  | 'tooManyFaces'
-  | 'tooClose'
-  | 'tooFar'
-  | 'blur'
-  | 'dark'
-  | 'faceAngle'
-  | 'headWear'
-  | 'lenses'
-  | 'eyesClosed'
-  | 'faceMask'
-  | 'centerFace'
-  | 'manualCapture'
-  | 'success'
-  | 'error'
-  | 'capturing'
-  | 'getReady'
-  | 'getReadyFinished'
-  | 'offline';
-
-export type SendFaceImageResponse = {
-  age: number;
-  confidence: number;
-  hasClosedEyes: boolean;
-  hasFaceMask: boolean;
-  hasHeadCover: boolean;
-  hasLenses: boolean;
-  isBright: boolean;
-  liveness: boolean;
-  imageBase64: string;
-  sessionStatus: string;
-};
-
-export const FACE_ERROR_CODES = {
-  FACE_OCCLUDED: 'FACE_OCCLUDED',
-  LIVENESS: 'LIVENESS_ERROR',
-  BRIGHTNESS: 'BRIGHTNESS_ERROR',
-  LENSES: 'LENSES_ERROR',
-  MASK: 'MASK_ERROR',
-  CLOSED_EYES: 'CLOSED_EYES_ERROR',
-  HEAD_COVER: 'HEAD_COVER_ERROR',
-  SERVER: 'SERVER_ERROR',
-  FACE_NOT_FOUND: 'FACE_NOT_FOUND',
-  MULTIPLE_FACES: 'MULTIPLE_FACES',
-  TOO_BLURRY: 'TOO_BLURRY_ERROR',
-  TOO_DARK: 'TOO_DARK_ERROR',
-  USER_IS_NOT_RECOGNIZED: 'USER_IS_NOT_RECOGNIZED',
-  SPOOF_ATTEMPT_DETECTED: 'SPOOF_ATTEMPT_DETECTED',
-  FACE_TOO_DARK: 'FACE_TOO_DARK',
-  LENSES_DETECTED: 'LENSES_DETECTED',
-  FACE_MASK_DETECTED: 'FACE_MASK_DETECTED',
-  CLOSED_EYES_DETECTED: 'CLOSED_EYES_DETECTED',
-  HEAD_COVER_DETECTED: 'HEAD_COVER_DETECTED',
-  FACE_CROPPING_FAILED: 'FACE_CROPPING_FAILED',
-  FACE_TOO_SMALL: 'FACE_TOO_SMALL',
-  FACE_TOO_BLURRY: 'FACE_TOO_BLURRY',
-  BAD_PHOTO_QUALITY: 'BAD_PHOTO_QUALITY',
-  PROCESSING_ERROR: 'PROCESSING_ERROR',
-  BAD_REQUEST: 'BAD_REQUEST',
-  NONEXISTENT_CUSTOMER: 'NONEXISTENT_CUSTOMER',
-  HINT_NOT_PROVIDED: 'HINT_NOT_PROVIDED',
-  SELFIE_IMAGE_LOW_QUALITY: 'SELFIE_IMAGE_LOW_QUALITY',
-} as const;
-
-export type FaceErrorCode =
-  (typeof FACE_ERROR_CODES)[keyof typeof FACE_ERROR_CODES];
-
-export type RecordingSession = {
-  token: string;
-  sessionId: string;
-  videoRecordingId: string;
-  connection: RecordingConnection;
-  resolution?: string;
-  hasAudio: boolean;
-};

package/src/session/index.ts

@@ -1,5 +0,0 @@
-export {
-  type CreateSessionOptions,
-  createSession,
-  type Session,
-} from './sessionService';

package/src/session/sessionService.ts

@@ -1,78 +0,0 @@
-import { getApi } from '../http/api';
-import { endpoints } from '../http/endpoints';
-
-export type CreateSessionOptions = {
-  /** The configuration/flow ID from the Incode dashboard */
-  configurationId: string;
-  /** External ID to associate with this session */
-  externalId?: string;
-  /** External customer ID */
-  externalCustomerId?: string;
-  /** Language for the session (e.g., 'en-US', 'es-MX') */
-  language?: string;
-  /** Custom fields to attach to the session */
-  customFields?: Record<string, unknown>;
-  /** UUID for continuing an existing session */
-  uuid?: string;
-  /** Interview ID for continuing an existing interview */
-  interviewId?: string;
-};
-
-export type Session = {
-  token: string;
-  interviewId: string;
-  uuid?: string;
-  regulationType?: string;
-  showMandatoryConsent?: boolean;
-};
-
-/**
- * Creates a new onboarding session.
- *
- * @param apiKey - The API key from the Incode dashboard
- * @param options - Session creation options
- * @param signal - Optional AbortSignal for request cancellation
- * @returns The created session with token
- *
- * @example
- * ```ts
- * const session = await createSession('your-api-key', {
- *   configurationId: 'your-flow-id',
- *   language: 'en-US',
- * });
- * console.log(session.token); // Use this token for subsequent API calls
- * ```
- */
-export async function createSession(
-  apiKey: string,
-  options: CreateSessionOptions,
-  signal?: AbortSignal,
-): Promise<Session> {
-  const res = await getApi().post<Session>(
-    endpoints.createSession,
-    {
-      configurationId: options.configurationId,
-      externalId: options.externalId,
-      externalCustomerId: options.externalCustomerId,
-      language: options.language ?? 'en-US',
-      customFields: options.customFields,
-      uuid: options.uuid ?? null,
-      interviewId: options.interviewId ?? null,
-    },
-    {
-      headers: {
-        'x-api-key': apiKey,
-        'api-version': '1.0',
-      },
-      signal,
-    },
-  );
-
-  if (!res.ok) {
-    throw new Error(
-      `POST ${endpoints.createSession} failed: ${res.status} ${res.statusText}`,
-    );
-  }
-
-  return res.data as Session;
-}

package/src/setup.test.ts

@@ -1,61 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { getApi, getToken } from './http/api';
-import { isConfigured, reset, setup } from './setup';
-
-describe('setup', () => {
-  beforeEach(() => {
-    reset();
-  });
-
-  describe('setup()', () => {
-    it('should configure the SDK with apiURL and token', () => {
-      setup({ apiURL: 'https://api.test.com', token: 'test-token' });
-
-      expect(isConfigured()).toBe(true);
-    });
-
-    it('should configure the SDK with custom headers', () => {
-      setup({
-        apiURL: 'https://api.test.com',
-        token: 'test-token',
-        customHeaders: { 'X-Custom': 'value' },
-      });
-
-      const client = getApi();
-      expect(client.defaults.headers['X-Custom']).toBe('value');
-      expect(getToken()).toBe('test-token');
-    });
-
-    it('should configure the SDK with timeout', () => {
-      setup({
-        apiURL: 'https://api.test.com',
-        token: 'test-token',
-        timeout: 5000,
-      });
-
-      expect(isConfigured()).toBe(true);
-    });
-  });
-
-  describe('isConfigured()', () => {
-    it('should return false before setup()', () => {
-      expect(isConfigured()).toBe(false);
-    });
-
-    it('should return true after setup()', () => {
-      setup({ apiURL: 'https://api.test.com', token: 'test-token' });
-
-      expect(isConfigured()).toBe(true);
-    });
-  });
-
-  describe('reset()', () => {
-    it('should reset the SDK', () => {
-      setup({ apiURL: 'https://api.test.com', token: 'test-token' });
-      expect(isConfigured()).toBe(true);
-
-      reset();
-      expect(isConfigured()).toBe(false);
-    });
-  });
-});

package/src/setup.ts

@@ -1,171 +0,0 @@
-import {
-  createApi,
-  type WasmPipeline,
-  WasmUtilProvider,
-  warmupWasm,
-} from '@incodetech/infra';
-import { resetApi, setClient, setToken } from './http/api';
-
-/**
- * WASM warmup configuration.
- */
-export type WasmConfig = {
-  /** Path to the WASM binary */
-  wasmPath: string;
-  /** Path to the SIMD-optimized WASM binary (optional) */
-  wasmSimdPath?: string;
-  /** Path to the WASM glue code */
-  glueCodePath: string;
-  /** Whether to use SIMD optimizations (default: true) */
-  useSimd?: boolean;
-  /** Which pipelines to preload models for */
-  pipelines?: WasmPipeline[];
-  /**
-   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
-   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
-   */
-  modelsBasePath?: string;
-};
-
-let wasmConfig: WasmConfig | undefined;
-
-/**
- * Configuration options for the SDK setup.
- */
-export type SetupOptions = {
-  /** The base URL for the API */
-  apiURL: string;
-  /** The session token for API requests (optional - can be set later or omitted for createSession calls) */
-  token?: string;
-  /** Custom headers to include in all requests */
-  customHeaders?: Record<string, string>;
-  /** Request timeout in milliseconds */
-  timeout?: number;
-  /** Optional WASM warmup config - if provided, preloads WASM and ML models */
-  wasm?: WasmConfig;
-};
-
-let configured = false;
-
-/**
- * Initializes the SDK with the provided configuration.
- * Must be called before using any SDK functionality.
- *
- * If `wasm` config is provided, this function becomes async and will
- * preload WASM binary and ML models. Otherwise, it's synchronous.
- *
- * @param options - Configuration options for the SDK
- *
- * @example
- * ```ts
- * import { setup, createSession } from '@incodetech/core';
- *
- * // Setup with API URL first (for session creation)
- * await setup({ apiURL: 'https://api.incode.com' });
- * const session = await createSession('api-key', { configurationId: 'flow-id' });
- *
- * // Basic setup with token
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   token: 'session-token',
- * });
- *
- * // Setup with WASM warmup
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   token: 'session-token',
- *   wasm: {
- *     wasmPath: '/wasm/ml-wasm.wasm',
- *     glueCodePath: '/wasm/ml-wasm.js',
- *     pipelines: ['selfie', 'idCapture'],
- *   },
- * });
- * ```
- */
-export async function setup(options: SetupOptions): Promise<void> {
-  const client = createApi({
-    apiURL: options.apiURL,
-    customHeaders: options.customHeaders,
-    timeout: options.timeout,
-  });
-  setClient(client);
-  if (options.token) {
-    setToken(options.token);
-  }
-  configured = true;
-
-  if (options.wasm) {
-    await warmupWasm({
-      wasmPath: options.wasm.wasmPath,
-      wasmSimdPath: options.wasm.wasmSimdPath,
-      glueCodePath: options.wasm.glueCodePath,
-      useSimd: options.wasm.useSimd,
-      pipelines: options.wasm.pipelines,
-      modelsBasePath: options.wasm.modelsBasePath,
-    });
-
-    const provider = await WasmUtilProvider.getInstance();
-    await provider.initialize({
-      wasmPath: options.wasm.wasmPath,
-      wasmSimdPath: options.wasm.wasmSimdPath,
-      glueCodePath: options.wasm.glueCodePath,
-      useSimd: options.wasm.useSimd,
-      pipelines: options.wasm.pipelines,
-      modelsBasePath: options.wasm.modelsBasePath,
-    });
-  }
-}
-
-/**
- * Sets the WASM configuration without performing warmup.
- * Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
- *
- * @param config - WASM configuration to store
- */
-export function setWasmConfig(config: WasmConfig): void {
-  wasmConfig = config;
-}
-
-/**
- * Initializes WasmUtilProvider with the stored WASM configuration.
- * Should be called after warmupWasm() completes when using conditional warmup.
- * This ensures image encryption works properly.
- *
- * @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
- * @throws Error if no config is provided and none is stored
- */
-export async function initializeWasmUtil(config?: WasmConfig): Promise<void> {
-  const wasmConfigToUse = config ?? wasmConfig;
-  if (!wasmConfigToUse) {
-    throw new Error(
-      'WASM config is required. Provide config parameter or call setWasmConfig() first.',
-    );
-  }
-  const provider = await WasmUtilProvider.getInstance();
-  await provider.initialize({
-    wasmPath: wasmConfigToUse.wasmPath,
-    wasmSimdPath: wasmConfigToUse.wasmSimdPath,
-    glueCodePath: wasmConfigToUse.glueCodePath,
-    useSimd: wasmConfigToUse.useSimd,
-    pipelines: wasmConfigToUse.pipelines,
-    modelsBasePath: wasmConfigToUse.modelsBasePath,
-  });
-}
-
-/**
- * Checks if the SDK has been configured.
- *
- * @returns true if setup() has been called, false otherwise
- */
-export function isConfigured(): boolean {
-  return configured;
-}
-
-/**
- * Resets the SDK configuration. Useful for testing.
- */
-export function reset(): void {
-  resetApi();
-  configured = false;
-  WasmUtilProvider.resetInstance();
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../config/ts/tsconfig.strict.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "paths": {
-      "@incodetech/config/*": ["../config/*"],
-      "@incodetech/infra": ["../infra/src"],
-      "@incodetech/infra/*": ["../infra/src/*"]
-    }
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsdown.config.ts

@@ -1,22 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  format: ['esm'],
-  dts: {
-    sourcemap: false,
-  },
-  sourcemap: false,
-  clean: true,
-  target: 'es2021',
-  outDir: 'dist',
-  outExtensions: () => ({ js: '.esm.js', dts: '.d.ts' }),
-  entry: {
-    index: 'src/index.ts',
-    flow: 'src/flow/index.ts',
-    selfie: 'src/selfie/index.ts',
-    phone: 'src/phone/index.ts',
-    email: 'src/email/index.ts',
-  },
-  noExternal: ['@incodetech/infra'],
-  platform: 'browser',
-});

package/vitest.config.ts

@@ -1,37 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { defineConfig, mergeConfig } from 'vitest/config';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const baseConfigUrl = pathToFileURL(
-  resolve(__dirname, '../config/vitest/base.ts'),
-).href;
-const baseConfig = await import(baseConfigUrl);
-
-export default mergeConfig(
-  baseConfig.default,
-  defineConfig({
-    resolve: {
-      alias: {
-        '@incodetech/config': resolve(__dirname, '../config'),
-        '@incodetech/infra': resolve(__dirname, '../infra/src'),
-      },
-    },
-    test: {
-      environment: 'node',
-      setupFiles: ['./vitest.setup.ts'],
-      coverage: {
-        exclude: ['**/__mocks__/**', '**/id/**'],
-        thresholds: {
-          // Camera module has async flows that are hard to test reliably
-          // The state machine transitions happen asynchronously and
-          // the permission API cannot be easily mocked in Node.js
-          lines: 45,
-          functions: 75,
-          branches: 20,
-          statements: 45,
-        },
-      },
-    },
-  }),
-);