@umituz/react-native-design-system 2.6.128 → 2.8.0

package/src/onboarding/infrastructure/services/ValidationManager.ts

@@ -0,0 +1,127 @@
+/**
+ * Onboarding Validation Service
+ *
+ * Business logic for validating onboarding question answers
+ * Follows Single Responsibility Principle
+ */
+
+import type { OnboardingQuestion } from "../../domain/entities/OnboardingQuestion";
+
+/**
+ * ValidationManager
+ */
+export class ValidationManager {
+  /**
+   * Validate answer against question validation rules
+   * @param question - The question to validate against
+   * @param answer - The answer to validate
+   * @returns true if valid, false otherwise
+   */
+  static validateAnswer(
+    question: OnboardingQuestion,
+    answer: any,
+  ): boolean {
+    const { validation } = question;
+    if (!validation) {
+      return true;
+    }
+
+    // Required validation
+    if (validation.required && !answer) {
+      return false;
+    }
+
+    // Type-specific validations
+    switch (question.type) {
+      case "multiple_choice":
+        return this.validateMultipleChoice(answer, validation);
+      case "text_input":
+        return this.validateTextInput(answer, validation);
+      case "rating":
+        return this.validateNumeric(answer, validation);
+      default:
+        break;
+    }
+
+    // Custom validator
+    if (validation.customValidator) {
+      const customResult = validation.customValidator(answer);
+      return customResult === true;
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate multiple choice answer
+   */
+  private static validateMultipleChoice(
+    answer: any,
+    validation: OnboardingQuestion["validation"],
+  ): boolean {
+    if (!validation) return true;
+
+    if (validation.minSelections) {
+      if (!answer || !Array.isArray(answer) || answer.length < validation.minSelections) {
+        return false;
+      }
+    }
+
+    if (validation.maxSelections) {
+      if (Array.isArray(answer) && answer.length > validation.maxSelections) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate text input answer
+   */
+  private static validateTextInput(
+    answer: any,
+    validation: OnboardingQuestion["validation"],
+  ): boolean {
+    if (!validation) return true;
+
+    if (typeof answer !== "string") {
+      return false;
+    }
+
+    if (validation.minLength && answer.length < validation.minLength) {
+      return false;
+    }
+
+    if (validation.maxLength && answer.length > validation.maxLength) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate numeric answer (rating)
+   */
+  private static validateNumeric(
+    answer: any,
+    validation: OnboardingQuestion["validation"],
+  ): boolean {
+    if (!validation) return true;
+
+    if (typeof answer !== "number") {
+      return false;
+    }
+
+    if (validation.min !== undefined && answer < validation.min) {
+      return false;
+    }
+
+    if (validation.max !== undefined && answer > validation.max) {
+      return false;
+    }
+
+    return true;
+  }
+}
+

package/src/onboarding/infrastructure/storage/OnboardingStore.ts

@@ -0,0 +1,99 @@
+/**
+ * Onboarding Store
+ *
+ * Zustand store for managing onboarding completion state
+ * Uses @umituz/react-native-storage for persistence
+ */
+
+import { useMemo } from "react";
+import { createStore } from "@umituz/react-native-storage";
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+import { initialOnboardingState } from "./OnboardingStoreState";
+import { createOnboardingStoreActions } from "./OnboardingStoreActions";
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+import { createOnboardingStoreSelectors } from "./OnboardingStoreSelectors";
+
+interface OnboardingActions {
+  // Simple actions
+  setCurrentStep: (step: number) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  setState: (state: Partial<OnboardingStoreState>) => void;
+  getState: () => OnboardingStoreState;
+  // Async actions for initialization (match OnboardingStoreActions signatures)
+  initialize: (storageKey?: string) => Promise<void>;
+  complete: (storageKey?: string) => Promise<void>;
+  skip: (storageKey?: string) => Promise<void>;
+  reset: (storageKey?: string) => Promise<void>;
+  saveAnswer: (questionId: string, answer: unknown) => Promise<void>;
+  setUserData: (data: OnboardingUserData) => Promise<void>;
+}
+
+export const useOnboardingStore = createStore<
+  OnboardingStoreState,
+  OnboardingActions
+>({
+  name: "onboarding-store",
+  initialState: initialOnboardingState,
+  persist: false,
+  actions: (
+    set: (state: Partial<OnboardingStoreState>) => void,
+    get: () => OnboardingStoreState
+  ): OnboardingActions => {
+    const actions = createOnboardingStoreActions(set, get);
+
+    return {
+      setCurrentStep: (step: number) => set({ currentStep: step }),
+      setLoading: (loading: boolean) => set({ loading }),
+      setError: (error: string | null) => set({ error }),
+      setState: set,
+      getState: get,
+
+      // Async actions from actions module
+      initialize: actions.initialize,
+      complete: actions.complete,
+      skip: actions.skip,
+      reset: actions.reset,
+      saveAnswer: actions.saveAnswer,
+      setUserData: actions.setUserData,
+    };
+  },
+});
+
+/**
+ * Hook for accessing onboarding state
+ * Memoized to prevent unnecessary re-renders in consumer components
+ */
+export const useOnboarding = () => {
+  const store = useOnboardingStore();
+  const setState = store.setState;
+  const getState = store.getState;
+
+  const actions = useMemo(() => createOnboardingStoreActions(setState, getState), [setState, getState]);
+  const selectors = useMemo(() => createOnboardingStoreSelectors(getState), [getState]);
+
+  return useMemo(() => ({
+    // State
+    isOnboardingComplete: store.isOnboardingComplete,
+    currentStep: store.currentStep,
+    loading: store.loading,
+    error: store.error,
+    userData: store.userData,
+
+    // Actions
+    initialize: actions.initialize,
+    complete: actions.complete,
+    skip: actions.skip,
+    setCurrentStep: store.setCurrentStep,
+    reset: actions.reset,
+    setLoading: store.setLoading,
+    setError: store.setError,
+    saveAnswer: actions.saveAnswer,
+    setUserData: actions.setUserData,
+
+    // Selectors
+    getAnswer: selectors.getAnswer,
+    getUserData: selectors.getUserData,
+  }), [store, actions, selectors]);
+};
+

package/src/onboarding/infrastructure/storage/OnboardingStoreActions.ts

@@ -0,0 +1,50 @@
+/**
+ * Onboarding Store Actions
+ * Single Responsibility: Async store actions interface and factory
+ */
+
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+import {
+  initializeAction,
+  completeAction,
+  skipAction,
+  resetAction,
+  saveAnswerAction,
+  setUserDataAction,
+  DEFAULT_STORAGE_KEY,
+} from "./actions";
+
+export interface OnboardingStoreActions {
+  initialize: (storageKey?: string) => Promise<void>;
+  complete: (storageKey?: string) => Promise<void>;
+  skip: (storageKey?: string) => Promise<void>;
+  reset: (storageKey?: string) => Promise<void>;
+  saveAnswer: (questionId: string, answer: unknown) => Promise<void>;
+  setUserData: (data: OnboardingUserData) => Promise<void>;
+}
+
+export function createOnboardingStoreActions(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  get: () => OnboardingStoreState
+): OnboardingStoreActions {
+  return {
+    initialize: (storageKey = DEFAULT_STORAGE_KEY) =>
+      initializeAction(set, storageKey),
+
+    complete: (storageKey = DEFAULT_STORAGE_KEY) =>
+      completeAction(set, get, storageKey),
+
+    skip: (storageKey = DEFAULT_STORAGE_KEY) =>
+      skipAction(set, get, storageKey),
+
+    reset: (storageKey = DEFAULT_STORAGE_KEY) =>
+      resetAction(set, storageKey),
+
+    saveAnswer: (questionId: string, answer: unknown) =>
+      saveAnswerAction(set, get, questionId, answer),
+
+    setUserData: (data: OnboardingUserData) =>
+      setUserDataAction(set, data),
+  };
+}

package/src/onboarding/infrastructure/storage/OnboardingStoreSelectors.ts

@@ -0,0 +1,25 @@
+/**
+ * Onboarding Store Selectors
+ * Single Responsibility: Store state selectors
+ */
+
+import type { OnboardingStoreState } from "./OnboardingStoreState";
+
+export interface OnboardingStoreSelectors {
+  getAnswer: (questionId: string) => any;
+  getUserData: () => OnboardingStoreState['userData'];
+}
+
+export function createOnboardingStoreSelectors(
+  get: () => OnboardingStoreState
+): OnboardingStoreSelectors {
+  return {
+    getAnswer: (questionId: string) => {
+      return get().userData.answers[questionId];
+    },
+
+    getUserData: () => {
+      return get().userData;
+    },
+  };
+}

package/src/onboarding/infrastructure/storage/OnboardingStoreState.ts

@@ -0,0 +1,22 @@
+/**
+ * Onboarding Store State
+ * Single Responsibility: Store state interface and initial state
+ */
+
+import type { OnboardingUserData } from "../../domain/entities/OnboardingUserData";
+
+export interface OnboardingStoreState {
+  isOnboardingComplete: boolean;
+  currentStep: number;
+  loading: boolean;
+  error: string | null;
+  userData: OnboardingUserData;
+}
+
+export const initialOnboardingState: OnboardingStoreState = {
+  isOnboardingComplete: false,
+  currentStep: 0,
+  loading: true,
+  error: null,
+  userData: { answers: {} },
+};

package/src/onboarding/infrastructure/storage/__tests__/OnboardingStore.test.ts

@@ -0,0 +1,85 @@
+/**
+ * OnboardingStore Tests
+ */
+
+import { renderHook, act } from '@testing-library/react-native';
+import { useOnboardingStore, useOnboarding } from '../OnboardingStore';
+
+// Mock storage repository
+jest.mock('@umituz/react-native-storage', () => ({
+  storageRepository: {
+    getString: jest.fn(),
+    setString: jest.fn(),
+    getObject: jest.fn(),
+    setObject: jest.fn(),
+    removeItem: jest.fn(),
+  },
+  StorageKey: {
+    ONBOARDING_COMPLETED: '@onboarding_completed',
+  },
+  unwrap: jest.fn((result, defaultValue) => result.success ? result.data : defaultValue),
+}));
+
+describe('OnboardingStore', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('useOnboardingStore', () => {
+    it('should have initial state', () => {
+      const { result } = renderHook(() => useOnboardingStore());
+
+      expect(result.current.isOnboardingComplete).toBe(false);
+      expect(result.current.currentStep).toBe(0);
+      expect(result.current.loading).toBe(true);
+      expect(result.current.error).toBe(null);
+      expect(result.current.userData).toEqual({ answers: {} });
+    });
+
+    it('should set current step', () => {
+      const { result } = renderHook(() => useOnboardingStore());
+
+      act(() => {
+        result.current.setCurrentStep(5);
+      });
+
+      expect(result.current.currentStep).toBe(5);
+    });
+
+    it('should set loading state', () => {
+      const { result } = renderHook(() => useOnboardingStore());
+
+      act(() => {
+        result.current.setLoading(false);
+      });
+
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('should set error state', () => {
+      const { result } = renderHook(() => useOnboardingStore());
+      const errorMessage = 'Test error';
+
+      act(() => {
+        result.current.setError(errorMessage);
+      });
+
+      expect(result.current.error).toBe(errorMessage);
+    });
+  });
+
+  describe('useOnboarding', () => {
+    it('should return all store properties and methods', () => {
+      const { result } = renderHook(() => useOnboarding());
+
+      expect(typeof result.current.initialize).toBe('function');
+      expect(typeof result.current.complete).toBe('function');
+      expect(typeof result.current.skip).toBe('function');
+      expect(typeof result.current.reset).toBe('function');
+      expect(typeof result.current.saveAnswer).toBe('function');
+      expect(typeof result.current.getAnswer).toBe('function');
+      expect(typeof result.current.getUserData).toBe('function');
+      expect(typeof result.current.setUserData).toBe('function');
+    });
+  });
+});

package/src/onboarding/infrastructure/storage/actions/answerActions.ts

@@ -0,0 +1,47 @@
+/**
+ * Answer Actions
+ * Single Responsibility: Save and update user answers
+ */
+
+import { storageRepository } from "@umituz/react-native-storage";
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+import { USER_DATA_STORAGE_KEY, handleError, logSuccess } from "./storageHelpers";
+
+export async function saveAnswerAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  get: () => OnboardingStoreState,
+  questionId: string,
+  answer: unknown
+): Promise<void> {
+  try {
+    const userData: OnboardingUserData = {
+      ...get().userData,
+      answers: {
+        ...get().userData.answers,
+        [questionId]: answer,
+      },
+    };
+
+    await storageRepository.setItem(USER_DATA_STORAGE_KEY, userData);
+    set({ userData });
+
+    logSuccess(`Answer saved for question: ${questionId}`);
+  } catch (error) {
+    handleError(error, "save answer");
+  }
+}
+
+export async function setUserDataAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  data: OnboardingUserData
+): Promise<void> {
+  try {
+    await storageRepository.setItem(USER_DATA_STORAGE_KEY, data);
+    set({ userData: data });
+
+    logSuccess("User data updated successfully");
+  } catch (error) {
+    handleError(error, "set user data");
+  }
+}

package/src/onboarding/infrastructure/storage/actions/completeAction.ts

@@ -0,0 +1,45 @@
+/**
+ * Complete Action
+ * Single Responsibility: Mark onboarding as completed
+ */
+
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+import {
+  saveCompletionStatus,
+  saveUserData,
+  handleError,
+  logSuccess,
+} from "./storageHelpers";
+
+export async function completeAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  get: () => OnboardingStoreState,
+  storageKey: string
+): Promise<void> {
+  try {
+    set({ loading: true, error: null });
+
+    await saveCompletionStatus(storageKey);
+
+    const userData: OnboardingUserData = {
+      ...get().userData,
+      completedAt: new Date().toISOString(),
+    };
+
+    await saveUserData(userData);
+
+    set({
+      isOnboardingComplete: true,
+      userData,
+      loading: false,
+      error: null,
+    });
+
+    logSuccess("Onboarding completed and persisted successfully");
+  } catch (error) {
+    const errorMessage = handleError(error, "complete onboarding");
+    set({ loading: false, error: errorMessage });
+    throw error;
+  }
+}

package/src/onboarding/infrastructure/storage/actions/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Actions Index
+ * Single Responsibility: Export all action functions
+ */
+
+export {
+  loadCompletionStatus,
+  loadUserData,
+  saveCompletionStatus,
+  saveUserData,
+  removeStorageKeys,
+  handleError,
+  logSuccess,
+  DEFAULT_STORAGE_KEY,
+  USER_DATA_STORAGE_KEY,
+} from "./storageHelpers";
+
+export { initializeAction } from "./initializeAction";
+export { completeAction } from "./completeAction";
+export { skipAction } from "./skipAction";
+export { resetAction } from "./resetAction";
+export { saveAnswerAction, setUserDataAction } from "./answerActions";

package/src/onboarding/infrastructure/storage/actions/initializeAction.ts

@@ -0,0 +1,40 @@
+/**
+ * Initialize Action
+ * Single Responsibility: Load initial onboarding state from storage
+ */
+
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+import {
+  loadCompletionStatus,
+  loadUserData,
+  handleError,
+  logSuccess,
+} from "./storageHelpers";
+
+export async function initializeAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  storageKey: string
+): Promise<void> {
+  try {
+    set({ loading: true, error: null });
+
+    const isComplete = await loadCompletionStatus(storageKey);
+    const defaultData: OnboardingUserData = { answers: {} };
+    const userData = await loadUserData(defaultData);
+
+    set({
+      isOnboardingComplete: isComplete,
+      userData,
+      loading: false,
+      error: null,
+    });
+
+    logSuccess(`Initialized with completion status: ${isComplete}`);
+  } catch (error) {
+    set({
+      loading: false,
+      error: handleError(error, "initialize onboarding"),
+    });
+  }
+}

package/src/onboarding/infrastructure/storage/actions/resetAction.ts

@@ -0,0 +1,37 @@
+/**
+ * Reset Action
+ * Single Responsibility: Reset onboarding state
+ */
+
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+import {
+  removeStorageKeys,
+  handleError,
+  logSuccess,
+} from "./storageHelpers";
+
+export async function resetAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  storageKey: string
+): Promise<void> {
+  try {
+    set({ loading: true, error: null });
+
+    await removeStorageKeys(storageKey);
+
+    set({
+      isOnboardingComplete: false,
+      currentStep: 0,
+      userData: { answers: {} },
+      loading: false,
+      error: null,
+    });
+
+    logSuccess("Onboarding reset successfully");
+  } catch (error) {
+    set({
+      loading: false,
+      error: handleError(error, "reset onboarding"),
+    });
+  }
+}

package/src/onboarding/infrastructure/storage/actions/skipAction.ts

@@ -0,0 +1,46 @@
+/**
+ * Skip Action
+ * Single Responsibility: Mark onboarding as skipped
+ */
+
+import type { OnboardingUserData } from "../../../domain/entities/OnboardingUserData";
+import type { OnboardingStoreState } from "../OnboardingStoreState";
+import {
+  saveCompletionStatus,
+  saveUserData,
+  handleError,
+  logSuccess,
+} from "./storageHelpers";
+
+export async function skipAction(
+  set: (state: Partial<OnboardingStoreState>) => void,
+  get: () => OnboardingStoreState,
+  storageKey: string
+): Promise<void> {
+  try {
+    set({ loading: true, error: null });
+
+    await saveCompletionStatus(storageKey);
+
+    const userData: OnboardingUserData = {
+      ...get().userData,
+      skipped: true,
+      completedAt: new Date().toISOString(),
+    };
+
+    await saveUserData(userData);
+
+    set({
+      isOnboardingComplete: true,
+      userData,
+      loading: false,
+      error: null,
+    });
+
+    logSuccess("Onboarding skipped and persisted successfully");
+  } catch (error) {
+    const errorMessage = handleError(error, "skip onboarding");
+    set({ loading: false, error: errorMessage });
+    throw error;
+  }
+}