@imksh/create 1.0.24 → 1.0.26

package/templates/production-fullstack/mobile/src/features/auth/store/useAuthStore.ts

@@ -0,0 +1,273 @@
+import { create } from "zustand";
+import { authService } from "../api/auth.service";
+import { save, remove, get } from "../../../lib/storage";
+import { User } from "../types/auth.type";
+import { initializeSocket, disconnectSocket } from "../../../lib/socket";
+import { useNotificationStore } from "../../../store/useNotificationStore";
+
+// ── Module-level prefetch ──────────────────────────────────────────────────
+// Kick off the AsyncStorage read the instant this module is imported
+// (before any React component mounts). By the time loadCachedUser() is
+// called from a useEffect, the promise is already resolved or very close.
+const _prefetchedUser: Promise<User | null> = get("user");
+
+export interface AuthState {
+  user: User | null;
+  loading: boolean;
+  isCheckingAuth: boolean;
+  error: string | null;
+  sendOtp: (email: string) => Promise<boolean>;
+  signup: (
+    name: string,
+    email: string,
+    password: string,
+    otp: string,
+    role?: string,
+  ) => Promise<boolean>;
+  login: (email: string, password: string) => Promise<boolean>;
+  demoLogin: () => Promise<void>;
+  getMe: () => Promise<void>;
+  updateProfile: (updates: Partial<User> | FormData) => Promise<boolean>;
+  logout: () => Promise<void>;
+  genOtp: (email: string) => Promise<boolean>;
+  verifyOtp: (email: string, otp: string) => Promise<boolean>;
+  resetPassword: (newPassword: string) => Promise<boolean>;
+  changePassword: (oldPassword: string, newPassword: string) => Promise<boolean>;
+  setUser: (user: User) => void;
+  clearError: () => void;
+  loadCachedUser: () => Promise<void>;
+}
+
+export const useAuthStore = create<AuthState>((set) => ({
+  user: null,
+  loading: false,
+  isCheckingAuth: true,
+  error: null,
+
+  setUser: (user: User) => set({ user }),
+
+  clearError: () => set({ error: null }),
+
+  loadCachedUser: async () => {
+    // Await the already-in-flight prefetch — typically resolves in <1ms here
+    const cached = await _prefetchedUser;
+    if (cached) {
+      set({ user: cached, isCheckingAuth: false });
+      // Re-establish socket + push on app resume with a cached session
+      initializeSocket();
+      const notifStore = useNotificationStore.getState();
+      notifStore.listenForSocketEvents();
+      notifStore.registerForPushNotificationsAsync();
+      notifStore.fetchNotifications();
+    } else {
+      // No cache — mark auth check done so routing doesn't hang
+      set({ isCheckingAuth: false });
+    }
+  },
+
+  sendOtp: async (email: string) => {
+    set({ loading: true, error: null });
+    try {
+      await authService.sendOtp(email);
+      return true;
+    } catch (err: any) {
+      set({
+        error: err.response?.data?.message || err.message,
+        loading: false,
+      });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  signup: async (
+    name: string,
+    email: string,
+    password: string,
+    otp: string,
+    role = "user",
+  ) => {
+    set({ loading: true, error: null });
+    try {
+      const { data } = await authService.signup(
+        name,
+        email,
+        password,
+        otp,
+        role,
+      );
+      if (data.data?.token) {
+        save("token", data.data.token);
+      }
+      const user = data.data?.user;
+      if (user) save("user", user);
+      set({
+        user,
+        loading: false,
+      });
+      // Initialise socket + push after signup
+      initializeSocket();
+      const notifStore = useNotificationStore.getState();
+      notifStore.listenForSocketEvents();
+      notifStore.registerForPushNotificationsAsync();
+      notifStore.fetchNotifications();
+      return true;
+    } catch (err: any) {
+      set({
+        error: err.response?.data?.message || err.message,
+        loading: false,
+      });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  login: async (email: string, password: string) => {
+    set({ loading: true, error: null });
+    try {
+      const { data } = await authService.login(email, password);
+      if (data.data?.token) {
+        save("token", data.data.token);
+      }
+      const user = data.data?.user;
+      if (user) save("user", user);
+      set({
+        user,
+        loading: false,
+      });
+      // Initialise socket + push after login
+      initializeSocket();
+      const notifStore = useNotificationStore.getState();
+      notifStore.listenForSocketEvents();
+      notifStore.registerForPushNotificationsAsync();
+      notifStore.fetchNotifications();
+      return true;
+    } catch (err: any) {
+      set({
+        error: err.response?.data?.message || err.message,
+        loading: false,
+      });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  demoLogin: async () => {
+    set({ loading: true, error: null });
+    // Simulate network delay
+    await new Promise(resolve => setTimeout(resolve, 800));
+    save("token", "demo-token-123");
+    set({
+      user: {
+        id: "demo_user_123",
+        name: "Demo User",
+        email: "demo@imksh.com",
+        role: "admin",
+      },
+      loading: false,
+    });
+  },
+
+  getMe: async () => {
+    try {
+      const { data } = await authService.getMe();
+      const user = data.data;
+      // Always update cache with fresh server data
+      if (user) save("user", user);
+      set({ user, isCheckingAuth: false });
+      // Network failed — cached user (already loaded) stays in place
+    } finally {
+      set({ isCheckingAuth: false });
+    }
+  },
+
+  updateProfile: async (updates: Partial<User> | FormData) => {
+    set({ loading: true, error: null });
+    try {
+      const { data } = await authService.updateMe(updates);
+      set({ user: data.data, loading: false });
+      return true;
+    } catch (err: any) {
+      set({
+        error: err.response?.data?.message || err.message,
+        loading: false,
+      });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  logout: async () => {
+    try {
+      await authService.logout();
+    } catch {
+      // ignore errors — cookie may already be expired
+    } finally {
+      await remove("token");
+      await remove("user");   // clear cached user on logout
+      disconnectSocket();
+      set({ loading: false });
+    }
+    set({
+      user: null,
+      error: null,
+    });
+  },
+
+  genOtp: async (email: string) => {
+    set({ loading: true, error: null });
+    try {
+      await authService.genOtp(email);
+      return true;
+    } catch (err: any) {
+      set({ error: err.response?.data?.message || err.message, loading: false });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  verifyOtp: async (email: string, otp: string) => {
+    set({ loading: true, error: null });
+    try {
+      const { data } = await authService.verifyOtp(email, otp);
+      if (data.token) save("token", data.token);
+      return true;
+    } catch (err: any) {
+      set({ error: err.response?.data?.message || err.message, loading: false });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  resetPassword: async (newPassword: string) => {
+    set({ loading: true, error: null });
+    try {
+      await authService.resetPassword(newPassword);
+      return true;
+    } catch (err: any) {
+      set({ error: err.response?.data?.message || err.message, loading: false });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+
+  changePassword: async (oldPassword: string, newPassword: string) => {
+    set({ loading: true, error: null });
+    try {
+      await authService.changePassword(oldPassword, newPassword);
+      return true;
+    } catch (err: any) {
+      set({ error: err.response?.data?.message || err.message, loading: false });
+      return false;
+    } finally {
+      set({ loading: false });
+    }
+  },
+}));

package/templates/production-fullstack/mobile/src/features/auth/types/auth.type.ts

@@ -0,0 +1,14 @@
+export interface User {
+  id: string; // Updated from _id for Prisma consistency
+  _id?: string; // Fallback for mongo legacy if any
+  name: string;
+  email: string;
+  phone?: string;
+  role: string;
+  avatar?: {
+    url?: string;
+    publicId?: string;
+  };
+  createdAt?: string;
+  updatedAt?: string;
+}

package/templates/production-fullstack/mobile/src/hooks/useDebounce.ts

@@ -0,0 +1,17 @@
+import { useState, useEffect } from "react";
+
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+
+  return debouncedValue;
+}

package/templates/production-fullstack/mobile/src/lib/axios.ts

@@ -0,0 +1,27 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from "axios";
+import { get } from "./storage";
+import { ApiResponse } from "../types/common.type";
+
+declare module 'axios' {
+  export interface AxiosInstance {
+    get<T = any, R = AxiosResponse<ApiResponse<T>>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
+    delete<T = any, R = AxiosResponse<ApiResponse<T>>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
+    post<T = any, R = AxiosResponse<ApiResponse<T>>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
+    put<T = any, R = AxiosResponse<ApiResponse<T>>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
+    patch<T = any, R = AxiosResponse<ApiResponse<T>>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
+  }
+}
+
+// eslint-disable-next-line import/no-named-as-default-member
+export const api = axios.create({
+  baseURL: process.env.EXPO_PUBLIC_API_URL,
+  withCredentials: true,
+});
+
+api.interceptors.request.use(async (config) => {
+  const token = await get("token");
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});

package/templates/production-fullstack/mobile/src/lib/query-client.ts

@@ -0,0 +1,11 @@
+import { QueryClient } from "@tanstack/react-query";
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false, // React Native doesn't have traditional window focus
+      retry: 1,
+      staleTime: 5 * 60 * 1000,
+    },
+  },
+});

package/templates/production-fullstack/mobile/src/lib/socket.ts

@@ -0,0 +1,36 @@
+import { io, Socket } from 'socket.io-client';
+import { get } from './storage';
+import Constants from 'expo-constants';
+
+let socket: Socket | null = null;
+
+// Set your backend socket URL
+const SOCKET_URL = Constants.expoConfig?.extra?.apiUrl || 'http://localhost:3000';
+
+export const initializeSocket = async () => {
+  if (socket) return;
+  const token = await get('token');
+  if (!token) return;
+
+  socket = io(SOCKET_URL, {
+    auth: { token },
+    transports: ['websocket'],
+  });
+
+  socket.on('connect', () => {
+    console.log('Connected to socket server');
+  });
+
+  socket.on('disconnect', () => {
+    console.log('Disconnected from socket server');
+  });
+};
+
+export const getSocket = () => socket;
+
+export const disconnectSocket = () => {
+  if (socket) {
+    socket.disconnect();
+    socket = null;
+  }
+};

package/templates/production-fullstack/mobile/src/lib/storage.ts

@@ -0,0 +1,55 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+// Save data
+export const save = async (key: string, value: any) => {
+  if (!key || !value) return; 
+  try {
+    const jsonValue = JSON.stringify(value);
+    await AsyncStorage.setItem(key, jsonValue);
+  } catch (error) {
+    console.warn("AsyncStorage save error:", error);
+  }
+};
+
+// Get data
+export const get = async (key: string) => {
+  try {
+    if (!AsyncStorage) return null;
+    const value = await AsyncStorage.getItem(key);
+    return value ? JSON.parse(value) : null;
+  } catch (error) {
+    console.warn('AsyncStorage get error:', error);
+    return null;
+  }
+};
+
+export const getData = async (key: string) => {
+  try {
+    if (!AsyncStorage) return null;
+    const value = await AsyncStorage.getItem(key);
+    return value ? JSON.parse(value) : null;
+  } catch (error) {
+    console.warn('AsyncStorage get error:', error);
+    return null;
+  }
+};
+
+// Remove specific key
+export const remove = async (key: string) => {
+  try {
+    if (!AsyncStorage) return;
+    await AsyncStorage.removeItem(key);
+  } catch (error) {
+    console.warn('AsyncStorage remove error:', error);
+  }
+};
+
+// Clear entire storage
+export const clear = async () => {
+  try {
+    if (!AsyncStorage) return;
+    await AsyncStorage.clear();
+  } catch (error) {
+    console.warn('AsyncStorage clear error:', error);
+  }
+};

package/templates/production-fullstack/mobile/src/services/permission.service.ts

@@ -0,0 +1,214 @@
+import { Platform, Alert } from "react-native";
+import {
+  check,
+  request,
+  PERMISSIONS,
+  RESULTS,
+  Permission,
+  PermissionStatus,
+  openSettings,
+} from "react-native-permissions";
+
+export type AppPermissionType =
+  | "camera"
+  | "audio" // Microphone
+  | "notification" // Notifications (Push)
+  | "image" // Photo Library / Read External Storage
+  | "file" // Write External Storage
+  | "location" // Location When In Use
+  | "locationAlways" // Location Always
+  | "contacts" // Contacts
+  | "phone" // Call Phone
+  | "nearbydevice" // Bluetooth
+  | "calendar"; // Calendar
+
+class PermissionService {
+  /**
+   * Helper to determine the correct native Permission object based on platform
+   */
+  private getNativePermission(type: AppPermissionType): Permission | null {
+    if (Platform.OS === "ios") {
+      switch (type) {
+        case "camera":
+          return PERMISSIONS.IOS.CAMERA;
+        case "audio":
+          return PERMISSIONS.IOS.MICROPHONE;
+        case "image":
+          return PERMISSIONS.IOS.PHOTO_LIBRARY;
+        case "file":
+          // iOS doesn't have a broad "file system" permission for the app sandbox
+          // Usually handled via DocumentPicker or PhotoLibrary depending on use case.
+          return PERMISSIONS.IOS.PHOTO_LIBRARY;
+        case "location":
+          return PERMISSIONS.IOS.LOCATION_WHEN_IN_USE;
+        case "locationAlways":
+          return PERMISSIONS.IOS.LOCATION_ALWAYS;
+        case "contacts":
+          return PERMISSIONS.IOS.CONTACTS;
+        case "calendar":
+          return PERMISSIONS.IOS.CALENDARS;
+        case "nearbydevice":
+          return PERMISSIONS.IOS.BLUETOOTH;
+        case "notification":
+          // handled uniquely by react-native-permissions using requestNotifications
+          return null;
+        case "phone":
+          // iOS doesn't require explicit permission to use Linking.openURL('tel:...')
+          return null;
+        default:
+          return null;
+      }
+    } else if (Platform.OS === "android") {
+      switch (type) {
+        case "camera":
+          return PERMISSIONS.ANDROID.CAMERA;
+        case "audio":
+          return PERMISSIONS.ANDROID.RECORD_AUDIO;
+        case "image":
+          return PERMISSIONS.ANDROID.READ_EXTERNAL_STORAGE;
+        case "file":
+          return PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE;
+        case "location":
+          return PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
+        case "locationAlways":
+          return PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION;
+        case "contacts":
+          return PERMISSIONS.ANDROID.READ_CONTACTS;
+        case "calendar":
+          return PERMISSIONS.ANDROID.READ_CALENDAR;
+        case "nearbydevice":
+          // Required for Android 12+
+          return PERMISSIONS.ANDROID.BLUETOOTH_CONNECT;
+        case "phone":
+          return PERMISSIONS.ANDROID.CALL_PHONE;
+        case "notification":
+          // handled uniquely by checkNotifications/requestNotifications
+          return null;
+        default:
+          return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check the current status of a permission without asking the user
+   */
+  async checkPermission(type: AppPermissionType): Promise<PermissionStatus> {
+    if (type === "notification") {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { checkNotifications } = require("react-native-permissions");
+      const { status } = await checkNotifications();
+      return status;
+    }
+    
+    const nativePerm = this.getNativePermission(type);
+    if (!nativePerm) {
+      // If the permission doesn't exist on this platform (e.g. Phone on iOS), we consider it granted
+      return RESULTS.GRANTED;
+    }
+    try {
+      return await check(nativePerm);
+    } catch (error) {
+      console.error(`Error checking permission ${type}:`, error);
+      return RESULTS.UNAVAILABLE;
+    }
+  }
+
+  /**
+   * Request a permission from the user
+   */
+  async requestPermission(type: AppPermissionType): Promise<PermissionStatus> {
+    if (type === "notification") {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { requestNotifications } = require("react-native-permissions");
+      const { status } = await requestNotifications(["alert", "sound", "badge"]);
+      return status;
+    }
+
+    const nativePerm = this.getNativePermission(type);
+    if (!nativePerm) {
+      return RESULTS.GRANTED;
+    }
+    try {
+      return await request(nativePerm);
+    } catch (error) {
+      console.error(`Error requesting permission ${type}:`, error);
+      return RESULTS.UNAVAILABLE;
+    }
+  }
+
+  /**
+   * Ensures a permission is granted. If not, requests it.
+   */
+  async requirePermission(type: AppPermissionType): Promise<boolean> {
+    let status = await this.checkPermission(type);
+
+    if (status === RESULTS.DENIED) {
+      status = await this.requestPermission(type);
+    }
+
+    return status === RESULTS.GRANTED || status === RESULTS.LIMITED;
+  }
+
+  /**
+   * Helper to open the OS Settings screen for the app if permission is blocked
+   */
+  async openSettingsForApp(
+    title = "Permission Required",
+    message = "Please enable this permission in your device settings."
+  ) {
+    Alert.alert(title, message, [
+      { text: "Cancel", style: "cancel" },
+      { text: "Open Settings", onPress: () => openSettings() },
+    ]);
+  }
+  /**
+   * Utility to register and fetch the Expo Push Token for this device.
+   * This uses the unified PermissionService to request the notification permission.
+   * NOTE: This will only return a token on physical devices.
+   */
+  async registerForPushNotificationsAsync(): Promise<string | null> {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Device = require("expo-device");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Notifications = require("expo-notifications");
+
+    if (!Device.isDevice) {
+      console.log("Must use physical device for Push Notifications");
+      return null;
+    }
+
+    const hasPermission = await this.requirePermission("notification");
+    if (!hasPermission) {
+      console.log("User denied push notification permissions");
+      return null;
+    }
+
+    // Set channel for Android
+    if (Platform.OS === "android") {
+      Notifications.setNotificationChannelAsync("default", {
+        name: "default",
+        importance: Notifications.AndroidImportance.MAX,
+        vibrationPattern: [0, 250, 250, 250],
+        lightColor: "#FF231F7C",
+      });
+    }
+
+    try {
+      const projectId =
+        require("../../app.json")?.expo?.extra?.eas?.projectId;
+      
+      const tokenData = await Notifications.getExpoPushTokenAsync({
+        projectId,
+      });
+
+      return tokenData.data;
+    } catch (e) {
+      console.error("Failed to get push token", e);
+      return null;
+    }
+  }
+}
+
+export const permissionService = new PermissionService();

package/templates/production-fullstack/mobile/src/store/localStore.ts

@@ -0,0 +1,7 @@
+import { create } from "zustand";
+
+const useLocalStore = create((set, get) => ({
+  
+}));
+
+export default useLocalStore;