@hawcx/react-native-sdk 1.0.8 → 1.1.1

package/src/v6Normalization.ts

@@ -0,0 +1,356 @@
+import type {
+  HawcxV6AwaitApprovalPrompt,
+  HawcxV6CompletedPayload,
+  HawcxV6EnterCodePrompt,
+  HawcxV6ErrorDetails,
+  HawcxV6ErrorPayload,
+  HawcxV6FlowEvent,
+  HawcxV6Method,
+  HawcxV6PromptBase,
+  HawcxV6PromptPayload,
+  HawcxV6RedirectPrompt,
+  HawcxV6RiskInfo,
+  HawcxV6SelectMethodPrompt,
+  HawcxV6SetupSmsPrompt,
+  HawcxV6SetupTotpPrompt,
+  HawcxV6StepInfo,
+} from './v6Types';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const asString = (value: unknown): string | undefined => {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+
+const asNumber = (value: unknown): number | undefined =>
+  typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+
+const asBoolean = (value: unknown): boolean | undefined =>
+  typeof value === 'boolean' ? value : undefined;
+
+const asRecordArray = (value: unknown): Record<string, unknown>[] =>
+  Array.isArray(value) ? value.filter(isRecord) : [];
+
+const normalizeStep = (value: unknown): HawcxV6StepInfo | undefined => {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const id = asString(value.id);
+  if (!id) {
+    return undefined;
+  }
+  return {
+    id,
+    label: asString(value.label),
+  };
+};
+
+const normalizeMethod = (value: unknown): HawcxV6Method | undefined => {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const id = asString(value.id);
+  const label = asString(value.label);
+  if (!id || !label) {
+    return undefined;
+  }
+  return {
+    id,
+    label,
+    icon: asString(value.icon),
+  };
+};
+
+const normalizeRisk = (value: unknown): HawcxV6RiskInfo | undefined => {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const detected = asBoolean(value.detected);
+  if (detected === undefined) {
+    return undefined;
+  }
+  const reasons = Array.isArray(value.reasons)
+    ? value.reasons.map(asString).filter((item): item is string => Boolean(item))
+    : [];
+  const location = isRecord(value.location)
+    ? {
+        city: asString(value.location.city),
+        country: asString(value.location.country),
+      }
+    : undefined;
+  return {
+    detected,
+    reasons,
+    message: asString(value.message),
+    location:
+      location && (location.city !== undefined || location.country !== undefined)
+        ? location
+        : undefined,
+    riskScore: asNumber(value.riskScore),
+  };
+};
+
+const normalizeErrorDetails = (value: unknown): HawcxV6ErrorDetails | undefined => {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const errors = asRecordArray(value.errors)
+    .map((entry) => {
+      const field = asString(entry.field);
+      const message = asString(entry.message);
+      if (!field || !message) {
+        return undefined;
+      }
+      return { field, message };
+    })
+    .filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));
+
+  const details: HawcxV6ErrorDetails = {
+    retryAfterSeconds: asNumber(value.retryAfterSeconds),
+    retryAt: asString(value.retryAt),
+    attemptsRemaining: asNumber(value.attemptsRemaining),
+    errors: errors.length > 0 ? errors : undefined,
+  };
+
+  if (
+    details.retryAfterSeconds === undefined &&
+    details.retryAt === undefined &&
+    details.attemptsRemaining === undefined &&
+    details.errors === undefined
+  ) {
+    return undefined;
+  }
+
+  return details;
+};
+
+const normalizePromptBase = (value: Record<string, unknown>): HawcxV6PromptBase | null => {
+  const session = asString(value.session);
+  const traceId = asString(value.traceId);
+  const expiresAt = asString(value.expiresAt);
+  if (!session || !traceId || !expiresAt) {
+    return null;
+  }
+
+  const step =
+    normalizeStep(value.step) ??
+    normalizeStep({
+      id: value.stepId,
+      label: value.stepLabel,
+    });
+
+  return {
+    session,
+    traceId,
+    expiresAt,
+    step,
+    risk: normalizeRisk(value.risk),
+    codeChannel: asString(value.codeChannel),
+  };
+};
+
+const normalizePromptPayload = (value: unknown): HawcxV6PromptPayload | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+
+  const base = normalizePromptBase(value);
+  if (!base) {
+    return null;
+  }
+
+  const rawPrompt = isRecord(value.prompt) ? value.prompt : undefined;
+  const promptType = asString(rawPrompt?.type) ?? asString(value.promptType);
+  if (!promptType) {
+    return null;
+  }
+
+  switch (promptType) {
+    case 'select_method': {
+      const methodsSource = rawPrompt?.methods ?? value.methods;
+      const methods = Array.isArray(methodsSource)
+        ? methodsSource.map(normalizeMethod).filter((item): item is HawcxV6Method => Boolean(item))
+        : [];
+      const payload: HawcxV6SelectMethodPrompt = {
+        ...base,
+        prompt: {
+          type: 'select_method',
+          methods,
+          phase: asString(rawPrompt?.phase ?? value.phase),
+        },
+      };
+      return payload;
+    }
+    case 'enter_code': {
+      const destination = asString(rawPrompt?.destination ?? value.destination);
+      if (!destination) {
+        return null;
+      }
+      const payload: HawcxV6EnterCodePrompt = {
+        ...base,
+        prompt: {
+          type: 'enter_code',
+          destination,
+          codeLength: asNumber(rawPrompt?.codeLength ?? value.codeLength),
+          codeFormat: asString(rawPrompt?.codeFormat ?? value.codeFormat),
+          codeExpiresAt: asString(rawPrompt?.codeExpiresAt ?? value.codeExpiresAt),
+          resendAt: asString(rawPrompt?.resendAt ?? value.resendAt),
+        },
+      };
+      return payload;
+    }
+    case 'enter_totp':
+      return {
+        ...base,
+        prompt: { type: 'enter_totp' },
+      };
+    case 'setup_totp': {
+      const secret = asString(rawPrompt?.secret ?? value.secret);
+      const otpauthUrl = asString(rawPrompt?.otpauthUrl ?? value.otpauthUrl);
+      if (!secret || !otpauthUrl) {
+        return null;
+      }
+      const payload: HawcxV6SetupTotpPrompt = {
+        ...base,
+        prompt: {
+          type: 'setup_totp',
+          secret,
+          otpauthUrl,
+          period: asNumber(rawPrompt?.period ?? value.period),
+        },
+      };
+      return payload;
+    }
+    case 'setup_sms': {
+      const payload: HawcxV6SetupSmsPrompt = {
+        ...base,
+        prompt: {
+          type: 'setup_sms',
+          existingPhone: asString(rawPrompt?.existingPhone ?? value.existingPhone),
+        },
+      };
+      return payload;
+    }
+    case 'redirect': {
+      const url = asString(rawPrompt?.url ?? value.url);
+      if (!url) {
+        return null;
+      }
+      const payload: HawcxV6RedirectPrompt = {
+        ...base,
+        prompt: {
+          type: 'redirect',
+          url,
+          returnScheme: asString(rawPrompt?.returnScheme ?? value.returnScheme),
+        },
+      };
+      return payload;
+    }
+    case 'await_approval': {
+      const promptExpiresAt = asString(
+        rawPrompt?.expiresAt ?? value.promptExpiresAt ?? value.awaitExpiresAt,
+      );
+      const pollInterval = asNumber(rawPrompt?.pollInterval ?? value.pollInterval);
+      if (!promptExpiresAt || pollInterval === undefined) {
+        return null;
+      }
+      const payload: HawcxV6AwaitApprovalPrompt = {
+        ...base,
+        prompt: {
+          type: 'await_approval',
+          qrData: asString(rawPrompt?.qrData ?? value.qrData),
+          expiresAt: promptExpiresAt,
+          pollInterval,
+        },
+      };
+      return payload;
+    }
+    default:
+      return null;
+  }
+};
+
+const normalizeCompletedPayload = (value: unknown): HawcxV6CompletedPayload | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const session = asString(value.session);
+  const authCode = asString(value.authCode);
+  const expiresAt = asString(value.expiresAt);
+  const traceId = asString(value.traceId);
+  if (!session || !authCode || !expiresAt || !traceId) {
+    return null;
+  }
+  return {
+    session,
+    authCode,
+    expiresAt,
+    codeVerifier: asString(value.codeVerifier),
+    traceId,
+  };
+};
+
+const normalizeErrorPayload = (value: unknown): HawcxV6ErrorPayload | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const code = asString(value.code);
+  const message = asString(value.message);
+  const retryable = asBoolean(value.retryable);
+  if (!code || !message || retryable === undefined) {
+    return null;
+  }
+  return {
+    session: asString(value.session),
+    code,
+    action: asString(value.action),
+    message,
+    retryable,
+    details: normalizeErrorDetails(value.details),
+    traceId: asString(value.traceId),
+  };
+};
+
+export const normalizeV6FlowEvent = (value: unknown): HawcxV6FlowEvent | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+
+  const type = asString(value.type);
+  if (!type) {
+    return null;
+  }
+
+  switch (type) {
+    case 'idle':
+      return { type: 'idle' };
+    case 'loading': {
+      const payload = isRecord(value.payload) ? value.payload : {};
+      return {
+        type: 'loading',
+        payload: {
+          session: asString(payload.session),
+        },
+      };
+    }
+    case 'prompt': {
+      const payload = normalizePromptPayload(value.payload);
+      return payload ? { type: 'prompt', payload } : null;
+    }
+    case 'completed': {
+      const payload = normalizeCompletedPayload(value.payload);
+      return payload ? { type: 'completed', payload } : null;
+    }
+    case 'error': {
+      const payload = normalizeErrorPayload(value.payload);
+      return payload ? { type: 'error', payload } : null;
+    }
+    default:
+      return null;
+  }
+};

package/src/v6State.ts

@@ -0,0 +1,238 @@
+import type {
+  HawcxV6AuthState,
+  HawcxV6CompletedPayload,
+  HawcxV6ErrorPayload,
+  HawcxV6FlowEvent,
+  HawcxV6FlowType,
+  HawcxV6PromptPayload,
+  HawcxV6ResendAvailability,
+} from './v6Types';
+
+const DEFAULT_FLOW_TYPE: HawcxV6FlowType = 'signin';
+
+const EMPTY_RESEND_STATE: HawcxV6ResendAvailability = {
+  canResend: false,
+};
+
+const isFiniteTimestamp = (value: string | undefined): number | null => {
+  if (!value) {
+    return null;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+};
+
+const isEnterCodePrompt = (
+  prompt: HawcxV6PromptPayload | undefined,
+): prompt is Extract<HawcxV6PromptPayload, { prompt: { type: 'enter_code' } }> =>
+  prompt?.prompt.type === 'enter_code';
+
+export const normalizeHawcxV6FlowType = (value?: HawcxV6FlowType): HawcxV6FlowType => {
+  switch (value) {
+    case 'signup':
+    case 'account_manage':
+      return value;
+    case 'signin':
+    default:
+      return DEFAULT_FLOW_TYPE;
+  }
+};
+
+export const getHawcxV6ResendAvailability = (
+  prompt?: HawcxV6PromptPayload,
+  nowMs: number = Date.now(),
+): HawcxV6ResendAvailability => {
+  if (!isEnterCodePrompt(prompt)) {
+    return EMPTY_RESEND_STATE;
+  }
+
+  const resendAt = prompt.prompt.resendAt;
+  const resendTimestamp = isFiniteTimestamp(resendAt);
+
+  if (resendTimestamp === null) {
+    return {
+      canResend: true,
+      resendAt,
+      secondsUntilResend: 0,
+    };
+  }
+
+  const diffMs = resendTimestamp - nowMs;
+  if (diffMs <= 0) {
+    return {
+      canResend: true,
+      resendAt,
+      secondsUntilResend: 0,
+    };
+  }
+
+  return {
+    canResend: false,
+    resendAt,
+    secondsUntilResend: Math.ceil(diffMs / 1000),
+  };
+};
+
+export const canHawcxV6Resend = (
+  promptOrState?: HawcxV6PromptPayload | HawcxV6AuthState,
+  nowMs: number = Date.now(),
+): boolean => {
+  if (!promptOrState) {
+    return false;
+  }
+
+  const prompt = 'status' in promptOrState ? promptOrState.prompt : promptOrState;
+
+  return getHawcxV6ResendAvailability(prompt, nowMs).canResend;
+};
+
+export const createInitialHawcxV6AuthState = (flowType?: HawcxV6FlowType): HawcxV6AuthState => ({
+  status: 'identifier',
+  flowType: normalizeHawcxV6FlowType(flowType),
+  resend: EMPTY_RESEND_STATE,
+  isLoading: false,
+  requiresRedirect: false,
+  awaitingApproval: false,
+});
+
+export const createIdentifierHawcxV6AuthState = ({
+  previous,
+  identifier,
+  flowType,
+}: {
+  previous?: HawcxV6AuthState;
+  identifier?: string;
+  flowType?: HawcxV6FlowType;
+} = {}): HawcxV6AuthState => ({
+  status: 'identifier',
+  flowType: normalizeHawcxV6FlowType(flowType ?? previous?.flowType),
+  identifier,
+  resend: EMPTY_RESEND_STATE,
+  isLoading: false,
+  requiresRedirect: false,
+  awaitingApproval: false,
+});
+
+const reducePromptState = (
+  prompt: HawcxV6PromptPayload,
+  previous: HawcxV6AuthState,
+  nowMs: number,
+): HawcxV6AuthState => {
+  const resend = getHawcxV6ResendAvailability(prompt, nowMs);
+
+  return {
+    status: prompt.prompt.type,
+    flowType: previous.flowType,
+    identifier: previous.identifier,
+    session: prompt.session,
+    traceId: prompt.traceId,
+    expiresAt: prompt.expiresAt,
+    step: prompt.step,
+    risk: prompt.risk,
+    codeChannel: prompt.codeChannel,
+    prompt,
+    completed: undefined,
+    error: undefined,
+    resend,
+    isLoading: false,
+    requiresRedirect: prompt.prompt.type === 'redirect',
+    awaitingApproval: prompt.prompt.type === 'await_approval',
+  };
+};
+
+const reduceCompletedState = (
+  completed: HawcxV6CompletedPayload,
+  previous: HawcxV6AuthState,
+): HawcxV6AuthState => ({
+  status: 'completed',
+  flowType: previous.flowType,
+  identifier: previous.identifier,
+  session: completed.session,
+  traceId: completed.traceId,
+  expiresAt: completed.expiresAt,
+  prompt: undefined,
+  completed,
+  error: undefined,
+  resend: EMPTY_RESEND_STATE,
+  isLoading: false,
+  requiresRedirect: false,
+  awaitingApproval: false,
+});
+
+const reduceErrorState = (
+  error: HawcxV6ErrorPayload,
+  previous: HawcxV6AuthState,
+): HawcxV6AuthState => ({
+  status: 'error',
+  flowType: previous.flowType,
+  identifier: previous.identifier,
+  session: error.session ?? previous.session,
+  traceId: error.traceId ?? previous.traceId,
+  expiresAt: previous.expiresAt,
+  step: previous.step,
+  risk: previous.risk,
+  codeChannel: previous.codeChannel,
+  prompt: previous.prompt,
+  completed: undefined,
+  error,
+  resend: previous.resend,
+  isLoading: false,
+  requiresRedirect: false,
+  awaitingApproval: false,
+});
+
+export const reduceHawcxV6FlowEvent = (
+  event: HawcxV6FlowEvent,
+  previous: HawcxV6AuthState,
+  nowMs: number = Date.now(),
+): HawcxV6AuthState => {
+  switch (event.type) {
+    case 'idle':
+      return createIdentifierHawcxV6AuthState({
+        previous,
+        identifier: previous.identifier,
+      });
+    case 'loading':
+      return {
+        ...previous,
+        status: 'loading',
+        session: event.payload.session ?? previous.session,
+        isLoading: true,
+        requiresRedirect: false,
+        awaitingApproval: false,
+        error: undefined,
+        completed: undefined,
+      };
+    case 'prompt':
+      return reducePromptState(event.payload, previous, nowMs);
+    case 'completed':
+      return reduceCompletedState(event.payload, previous);
+    case 'error':
+      return reduceErrorState(event.payload, previous);
+    default:
+      return previous;
+  }
+};
+
+export const refreshHawcxV6AuthState = (
+  state: HawcxV6AuthState,
+  nowMs: number = Date.now(),
+): HawcxV6AuthState => {
+  if (!state.prompt) {
+    return state;
+  }
+
+  const resend = getHawcxV6ResendAvailability(state.prompt, nowMs);
+  if (
+    resend.canResend === state.resend.canResend &&
+    resend.resendAt === state.resend.resendAt &&
+    resend.secondsUntilResend === state.resend.secondsUntilResend
+  ) {
+    return state;
+  }
+
+  return {
+    ...state,
+    resend,
+  };
+};