create-stackr 0.2.0

package/templates/features/mobile/auth/services/deviceSession.ts

@@ -0,0 +1,370 @@
+import axios from 'axios';
+import api from './api';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { logger } from '../utils/logger';
+import { Platform } from 'react-native';
+import * as Application from 'expo-application';
+import * as SecureStore from 'expo-secure-store';
+
+export interface DeviceSession {
+  id: string;
+  deviceId: string;
+  sessionToken: string;
+  createdAt: string;
+  lastActiveAt: string;
+  migrated: boolean;
+  migratedToUserId?: string;
+  preferredCurrency: string;
+}
+
+export interface CreateDeviceSessionResponse {
+  session: DeviceSession;
+  sessionToken: string;
+}
+
+export interface DeviceSessionValidationResponse {
+  valid: boolean;
+  session?: DeviceSession;
+}
+
+export interface DeviceSessionMigrationEligibilityResponse {
+  canMigrate: boolean;
+  reason?: string;
+}
+
+class DeviceSessionService {
+  private static instance: DeviceSessionService;
+  private sessionToken: string | null = null;
+  private deviceId: string | null = null;
+  private session: DeviceSession | null = null;
+
+  private readonly SESSION_TOKEN_KEY = 'device_session_token';
+  private readonly DEVICE_ID_KEY = 'device_id';
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+
+  private constructor() {
+    logger.debug('DeviceSessionService: Initializing...');
+  }
+
+  public static getInstance(): DeviceSessionService {
+    if (!DeviceSessionService.instance) {
+      DeviceSessionService.instance = new DeviceSessionService();
+    }
+    return DeviceSessionService.instance;
+  }
+
+  async initialize(): Promise<DeviceSession | null> {
+    try {
+      logger.info('SessionService: Initializing session...');
+      
+      // Get or create device ID
+      const deviceId = await this.getOrCreateDeviceId();
+      
+      // Check for existing session token
+      const existingToken = await this.getSessionToken();
+      
+      if (existingToken) {
+        // Validate existing device session
+        const validation = await this.validateDeviceSession(existingToken);
+        if (validation.valid && validation.session) {
+          this.session = validation.session;
+          this.sessionToken = existingToken;
+          this.startHeartbeat();
+          logger.info('DeviceSessionService: Restored existing device session');
+          return validation.session;
+        }
+      }
+
+      // Create new device session if no valid existing session
+      const newSession = await this.createDeviceSession(deviceId);
+      this.session = newSession.session;
+      this.sessionToken = newSession.sessionToken;
+      await this.setSessionToken(newSession.sessionToken);
+      this.startHeartbeat();
+      
+      logger.info('SessionService: Created new session');
+      return newSession.session;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to initialize session', { error });
+      throw error;
+    }
+  }
+
+  async createDeviceSession(deviceId: string): Promise<CreateDeviceSessionResponse> {
+    try {
+      logger.info('DeviceSessionService: Creating new device session for device:', deviceId);
+
+      const response = await api.post<CreateDeviceSessionResponse>('/device-sessions', { deviceId });
+
+      logger.info('DeviceSessionService: Device session created successfully');
+      return response.data;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to create session', { error });
+      
+      if (axios.isAxiosError(error)) {
+        throw new Error(error.response?.data?.error?.message || 'Failed to create session');
+      }
+      
+      throw new Error('Session creation failed');
+    }
+  }
+
+  async validateDeviceSession(sessionToken: string): Promise<DeviceSessionValidationResponse> {
+    try {
+      logger.debug('DeviceSessionService: Validating device session token...');
+
+      const response = await api.post<DeviceSessionValidationResponse>('/device-sessions/validate', { sessionToken });
+
+      logger.debug('DeviceSessionService: Device session validation complete');
+      return response.data;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to validate session', { error });
+      
+      // Return invalid for validation errors
+      return { valid: false };
+    }
+  }
+
+  async updateActivity(): Promise<void> {
+    try {
+      const token = await this.getSessionToken();
+      if (!token) {
+        logger.warn('SessionService: No session token for activity update');
+        return;
+      }
+
+      logger.debug('SessionService: Updating session activity...');
+      
+      await api.put('/device-sessions/activity', { sessionToken: token });
+      
+      logger.debug('SessionService: Session activity updated');
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to update session activity', { error });
+      
+      // Don't throw for activity update errors
+    }
+  }
+
+  async getMigrationEligibility(): Promise<DeviceSessionMigrationEligibilityResponse> {
+    try {
+      const token = await this.getSessionToken();
+      if (!token) {
+        throw new Error('No device session token available');
+      }
+
+      logger.debug('DeviceSessionService: Checking migration eligibility...');
+
+      const response = await api.post<DeviceSessionMigrationEligibilityResponse>('/device-sessions/migration-eligibility', { sessionToken: token });
+
+      logger.debug('DeviceSessionService: Migration eligibility checked');
+      return response.data;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to check migration eligibility', { error });
+      
+      if (axios.isAxiosError(error)) {
+        throw new Error(error.response?.data?.error?.message || 'Failed to check migration eligibility');
+      }
+      
+      throw new Error('Migration eligibility check failed');
+    }
+  }
+
+  async deleteSession(): Promise<void> {
+    try {
+      const token = await this.getSessionToken();
+      if (!token) {
+        logger.warn('SessionService: No session token to delete');
+        return;
+      }
+
+      logger.info('SessionService: Deleting session...');
+      
+      try {
+        await api.delete('/device-sessions', { data: { sessionToken: token } });
+      } catch (error) {
+        logger.warn('SessionService: Session deletion API call failed, continuing with local cleanup', { error });
+      }
+      
+      // Always clear local session data
+      await this.clearSession();
+      logger.info('SessionService: Session deleted successfully');
+      
+    } catch (error) {
+      logger.error('SessionService: Error during session deletion', { error });
+      // Still try to clear local data on error
+      await this.clearSession();
+    }
+  }
+
+  // Device ID management
+  private async getOrCreateDeviceId(): Promise<string> {
+    try {
+      // Try to get existing device ID from secure storage
+      let deviceId = await SecureStore.getItemAsync(this.DEVICE_ID_KEY);
+      
+      if (deviceId) {
+        this.deviceId = deviceId;
+        logger.debug('SessionService: Found existing device ID');
+        return deviceId;
+      }
+      
+      // Generate new device ID
+      deviceId = await this.generateDeviceId();
+      await SecureStore.setItemAsync(this.DEVICE_ID_KEY, deviceId);
+      this.deviceId = deviceId;
+      
+      logger.info('SessionService: Generated new device ID');
+      return deviceId;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to get/create device ID', { error });
+      
+      // Fallback to AsyncStorage if SecureStore fails
+      try {
+        let deviceId = await AsyncStorage.getItem(this.DEVICE_ID_KEY);
+        
+        if (deviceId) {
+          this.deviceId = deviceId;
+          return deviceId;
+        }
+        
+        deviceId = await this.generateDeviceId();
+        await AsyncStorage.setItem(this.DEVICE_ID_KEY, deviceId);
+        this.deviceId = deviceId;
+        
+        return deviceId;
+      } catch (fallbackError) {
+        logger.error('SessionService: Fallback device ID generation failed', { fallbackError });
+        throw new Error('Failed to generate device ID');
+      }
+    }
+  }
+
+  private async generateDeviceId(): Promise<string> {
+    try {
+      // Create a unique device identifier
+      const installId = Application.applicationId || 'unknown';
+      const buildId = Application.nativeBuildVersion || '0';
+      const platform = Platform.OS;
+      const timestamp = Date.now().toString();
+      const randomBytes = Math.random().toString(36).substring(2, 15);
+      
+      const deviceId = `${platform}-${installId.replace(/\./g, '_')}-${buildId}-${timestamp}-${randomBytes}`;
+      
+      logger.debug('SessionService: Generated device ID pattern:', deviceId.substring(0, 20) + '...');
+      return deviceId;
+      
+    } catch (error) {
+      logger.error('SessionService: Failed to generate device ID', { error });
+      
+      // Fallback to simple random ID
+      const fallbackId = `${Platform.OS}-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+      logger.warn('SessionService: Using fallback device ID');
+      return fallbackId;
+    }
+  }
+
+  // Session token management
+  public async getSessionToken(): Promise<string | null> {
+    if (this.sessionToken) {
+      return this.sessionToken;
+    }
+    try {
+      const token = await AsyncStorage.getItem(this.SESSION_TOKEN_KEY);
+      this.sessionToken = token;
+      return token;
+    } catch (error) {
+      logger.error('SessionService: Failed to get session token from storage', { error });
+      return null;
+    }
+  }
+
+  private async setSessionToken(token: string): Promise<void> {
+    try {
+      logger.debug('SessionService: Setting session token...');
+      await AsyncStorage.setItem(this.SESSION_TOKEN_KEY, token);
+      this.sessionToken = token;
+      logger.debug('SessionService: Session token set successfully');
+    } catch (error) {
+      logger.error('SessionService: Failed to save session token to storage', { error });
+      throw new Error('Failed to save session token');
+    }
+  }
+
+  private async removeSessionToken(): Promise<void> {
+    try {
+      logger.debug('SessionService: Removing session token...');
+      await AsyncStorage.removeItem(this.SESSION_TOKEN_KEY);
+      this.sessionToken = null;
+      logger.debug('SessionService: Session token removed successfully');
+    } catch (error) {
+      logger.error('SessionService: Failed to remove session token from storage', { error });
+      throw new Error('Failed to remove session token');
+    }
+  }
+
+  async clearSession(): Promise<void> {
+    try {
+      logger.info('SessionService: Clearing session...');
+      this.stopHeartbeat();
+      await this.removeSessionToken();
+      this.session = null;
+      logger.info('SessionService: Session cleared successfully');
+    } catch (error) {
+      logger.error('SessionService: Failed to clear session', { error });
+      throw new Error('Failed to clear session');
+    }
+  }
+
+  // Device session state getters
+  getCurrentDeviceSession(): DeviceSession | null {
+    return this.session;
+  }
+
+  async isDeviceSessionValid(): Promise<boolean> {
+    try {
+      const token = await this.getSessionToken();
+      if (!token) {
+        return false;
+      }
+
+      const validation = await this.validateDeviceSession(token);
+      return validation.valid;
+    } catch (error) {
+      logger.error('DeviceSessionService: Error checking device session validity:', error);
+      return false;
+    }
+  }
+
+  getDeviceId(): string | null {
+    return this.deviceId;
+  }
+
+  // Heartbeat management
+  private startHeartbeat(): void {
+    // Clear any existing heartbeat
+    this.stopHeartbeat();
+    
+    // Update activity every 5 minutes
+    this.heartbeatInterval = setInterval(() => {
+      this.updateActivity();
+    }, 5 * 60 * 1000);
+    
+    logger.debug('SessionService: Heartbeat started');
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+      logger.debug('SessionService: Heartbeat stopped');
+    }
+  }
+}
+
+export const deviceSessionService = DeviceSessionService.getInstance();

package/templates/features/mobile/auth/store/deviceSession.store.ts

@@ -0,0 +1,326 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { deviceSessionService, DeviceSession, DeviceSessionMigrationEligibilityResponse } from '../services/deviceSession';
+import { logger } from '../utils/logger';
+
+export interface MigrateSessionData {
+  name: string;
+  email: string;
+  password: string;
+  passwordConfirmation: string;
+}
+
+export interface SessionMigrationResponse {
+  user: {
+    id: string;
+    email: string;
+    name: string;
+    preferredCurrency: string;
+    createdAt: string;
+    updatedAt: string;
+  };
+  token: string;
+}
+
+interface SessionState {
+  // State
+  session: DeviceSession | null;
+  sessionToken: string | null;
+  deviceId: string | null;
+  isLoading: boolean;
+  isSessionChecked: boolean;
+  error: string | null;
+
+  // Actions
+  setSession: (session: DeviceSession | null) => void;
+  setSessionToken: (token: string | null) => void;
+  setDeviceId: (deviceId: string | null) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  setSessionChecked: (checked: boolean) => void;
+  clearSession: () => void;
+  clearError: () => void;
+
+  // Async actions
+  initializeSession: () => Promise<void>;
+  deleteSession: () => Promise<void>;
+  isSessionValid: () => Promise<boolean>;
+  getMigrationEligibility: () => Promise<DeviceSessionMigrationEligibilityResponse>;
+  migrateSession: (data: MigrateSessionData) => Promise<SessionMigrationResponse>;
+  refreshSession: () => Promise<void>;
+
+  // Computed values
+  hasValidSession: boolean;
+}
+
+export const useSessionStore = create<SessionState>()(
+  (set, get) => ({
+    // Initial state
+    session: null,
+    sessionToken: null,
+    deviceId: null,
+    isLoading: false,
+    isSessionChecked: false,
+    error: null,
+
+    // Actions
+    setSession: (session) => set({ session }),
+    setSessionToken: (sessionToken) => set({ sessionToken }),
+    setDeviceId: (deviceId) => set({ deviceId }),
+    setLoading: (isLoading) => set({ isLoading }),
+    setError: (error) => set({ error }),
+    setSessionChecked: (isSessionChecked) => set({ isSessionChecked }),
+    
+    clearSession: () => set({ 
+      session: null, 
+      sessionToken: null, 
+      deviceId: null,
+      error: null,
+      isLoading: false 
+    }),
+    
+    clearError: () => set({ error: null }),
+
+    // Async actions
+    initializeSession: async () => {
+      try {
+        logger.debug('SessionStore: Initializing session...');
+        set({ isLoading: true, error: null });
+
+        const sessionData = await deviceSessionService.initialize();
+        
+        if (sessionData) {
+          set({
+            session: sessionData,
+            sessionToken: await deviceSessionService.getSessionToken(),
+            deviceId: deviceSessionService.getDeviceId(),
+          });
+          logger.info('SessionStore: Session initialized successfully', { 
+            sessionId: sessionData.id,
+            deviceId: sessionData.deviceId 
+          });
+        } else {
+          logger.warn('SessionStore: No session data returned from initialize');
+          set({ session: null, sessionToken: null });
+        }
+        
+      } catch (error) {
+        logger.error('SessionStore: Failed to initialize session', { error });
+        
+        const errorMessage = error instanceof Error ? error.message : 'Session initialization failed';
+        set({ error: errorMessage, session: null, sessionToken: null });
+        
+      } finally {
+        set({ isLoading: false, isSessionChecked: true });
+      }
+    },
+
+    deleteSession: async () => {
+      try {
+        logger.info('SessionStore: Deleting session...');
+        set({ isLoading: true, error: null });
+
+        // Clear onboarding flag to restart onboarding flow
+        try {
+          await AsyncStorage.removeItem('onboarding_completed');
+          logger.info('Onboarding flag cleared after session deletion');
+        } catch (error) {
+          logger.error('Failed to clear onboarding flag', { error });
+          // Don't throw - not critical
+        }
+
+        await deviceSessionService.deleteSession();
+        set({ session: null, sessionToken: null, deviceId: null });
+
+        logger.info('SessionStore: Session deleted successfully');
+
+      } catch (error) {
+        // Still clear onboarding flag even on error
+        try {
+          await AsyncStorage.removeItem('onboarding_completed');
+        } catch (e) {
+          logger.error('Failed to clear onboarding flag in error handler', { e });
+        }
+
+        logger.error('SessionStore: Failed to delete session', { error });
+
+        const errorMessage = error instanceof Error ? error.message : 'Session deletion failed';
+        set({ error: errorMessage });
+
+        throw error;
+
+      } finally {
+        set({ isLoading: false });
+      }
+    },
+
+    isSessionValid: async () => {
+      try {
+        logger.debug('SessionStore: Checking session validity...');
+        
+        const isValid = await deviceSessionService.isDeviceSessionValid();
+        
+        if (!isValid && get().session) {
+          // Session became invalid, clear it
+          logger.warn('SessionStore: Session is no longer valid, clearing');
+          set({ session: null, sessionToken: null, error: 'Session expired' });
+        }
+        
+        return isValid;
+        
+      } catch (error) {
+        logger.error('SessionStore: Error checking session validity', { error });
+        return false;
+      }
+    },
+
+    getMigrationEligibility: async () => {
+      try {
+        logger.debug('SessionStore: Checking migration eligibility...');
+        set({ error: null });
+        
+        const eligibility = await deviceSessionService.getMigrationEligibility();
+        
+        logger.debug('SessionStore: Migration eligibility checked', { 
+          canMigrate: eligibility.canMigrate
+        });
+        
+        return eligibility;
+        
+      } catch (error) {
+        logger.error('SessionStore: Failed to check migration eligibility', { error });
+        
+        const errorMessage = error instanceof Error ? error.message : 'Migration eligibility check failed';
+        set({ error: errorMessage });
+        
+        throw error;
+      }
+    },
+
+    migrateSession: async (data: MigrateSessionData): Promise<SessionMigrationResponse> => {
+      try {
+        logger.info('SessionStore: Migrating session to user account...');
+        set({ isLoading: true, error: null });
+        
+        const sessionToken = get().sessionToken;
+        if (!sessionToken) {
+          throw new Error('No session token available for migration');
+        }
+
+        // Call the migration endpoint
+        const migrationData = {
+          sessionToken,
+          ...data,
+        };
+
+        // This would be a direct API call since migration is a one-time operation
+        const response = await fetch(`${process.env.EXPO_PUBLIC_API_URL}/sessions/migrate`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(migrationData),
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json() as { error?: { message?: string } };
+          throw new Error(errorData.error?.message || 'Migration failed');
+        }
+
+        const result = await response.json() as SessionMigrationResponse;
+        
+        // Clear session data after successful migration
+        set({ session: null, sessionToken: null, deviceId: null });
+        
+        logger.info('SessionStore: Session migrated successfully', {
+          userId: result.user.id,
+        });
+        
+        return result;
+        
+      } catch (error) {
+        logger.error('SessionStore: Failed to migrate session', { error });
+        
+        const errorMessage = error instanceof Error ? error.message : 'Session migration failed';
+        set({ error: errorMessage });
+        
+        throw error;
+        
+      } finally {
+        set({ isLoading: false });
+      }
+    },
+
+    refreshSession: async () => {
+      try {
+        logger.info('SessionStore: Refreshing session...');
+        set({ error: null });
+        
+        // Check if current session is still valid
+        const currentSession = deviceSessionService.getCurrentDeviceSession();
+        if (currentSession) {
+          const isValid = await deviceSessionService.isDeviceSessionValid();
+          
+          if (isValid) {
+            // Session is still valid, just update the local state
+            set({ session: currentSession });
+            logger.debug('SessionStore: Session is still valid');
+            return;
+          }
+        }
+        
+        // Session is invalid or doesn't exist, initialize a new one
+        await get().initializeSession();
+        
+      } catch (error) {
+        logger.error('SessionStore: Failed to refresh session', { error });
+        
+        const errorMessage = error instanceof Error ? error.message : 'Session refresh failed';
+        set({ error: errorMessage });
+        
+        throw error;
+      }
+    },
+
+    // Computed values
+    get hasValidSession() {
+      const state = get();
+      return !!(state.session && state.sessionToken);
+    },
+  })
+);
+
+// Selectors for commonly used combinations
+export const useSession = () => {
+  const state = useSessionStore();
+  return {
+    session: state.session,
+    sessionToken: state.sessionToken,
+    deviceId: state.deviceId,
+    isLoading: state.isLoading,
+    isSessionChecked: state.isSessionChecked,
+    error: state.error,
+    hasValidSession: state.hasValidSession,
+    clearError: state.clearError,
+  };
+};
+
+export const useSessionActions = () => {
+  const state = useSessionStore();
+  return {
+    setSession: state.setSession,
+    setSessionToken: state.setSessionToken,
+    setDeviceId: state.setDeviceId,
+    setLoading: state.setLoading,
+    setError: state.setError,
+    setSessionChecked: state.setSessionChecked,
+    clearSession: state.clearSession,
+    initializeSession: state.initializeSession,
+    deleteSession: state.deleteSession,
+    isSessionValid: state.isSessionValid,
+    getMigrationEligibility: state.getMigrationEligibility,
+    migrateSession: state.migrateSession,
+    refreshSession: state.refreshSession,
+  };
+};

package/templates/features/mobile/onboarding/app/(onboarding)/_layout.tsx.ejs

@@ -0,0 +1,11 @@
+import { Stack } from 'expo-router';
+
+export default function OnboardingLayout() {
+  return (
+    <Stack screenOptions={{ headerShown: false }}>
+      <% for (let i = 1; i <= features.onboarding.pages && i <= 3; i++) { %>
+      <Stack.Screen name="page-<%= i %>" />
+      <% } %>
+    </Stack>
+  );
+}