@thetechfossil/auth2 1.2.19 → 1.2.20

package/dist/index.next.d.mts

@@ -16,6 +16,8 @@ interface User {
     phoneNumber?: string;
     avatar?: string;
     role: string;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
     linkedAccounts?: LinkedAccount[];
     createdAt: string;
     updatedAt: string;
@@ -65,6 +67,7 @@ interface AuthConfig {
     localStorageKey?: string;
     token?: string;
     csrfEnabled?: boolean;
+    enableSocket?: boolean;
     upfilesConfig?: UpfilesConfig;
 }
 interface UpfilesConfig {
@@ -132,17 +135,57 @@ interface UseAuthReturn {
     }>;
     revokeSession: (sessionId: string) => Promise<AuthResponse>;
     revokeAllSessions: () => Promise<AuthResponse>;
+    adminCreateUser: (data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }) => Promise<AuthResponse & {
+        user?: User;
+    }>;
+    adminVerifyUser: (userId: string) => Promise<AuthResponse>;
+    adminSuspendUser: (userId: string) => Promise<AuthResponse>;
+    adminActivateUser: (userId: string) => Promise<AuthResponse>;
 }
 
+type SocketEventHandler<T = any> = (data: T) => void;
+
 declare class AuthService {
     private httpClient;
+    private socketService;
     private config;
     private token;
     private upfilesClient;
+    private cachedUser;
+    private userCacheTimestamp;
+    private readonly USER_CACHE_TTL;
     constructor(config: AuthConfig);
     private loadTokenFromStorage;
     private saveTokenToStorage;
     private removeTokenFromStorage;
+    private connectSocket;
+    private disconnectSocket;
+    onUserUpdated(handler: SocketEventHandler<{
+        user: User;
+    }>): () => void;
+    onSessionRevoked(handler: SocketEventHandler<{
+        sessionId?: string;
+    }>): () => void;
+    onAllSessionsRevoked(handler: SocketEventHandler<{}>): () => void;
+    onPasswordChanged(handler: SocketEventHandler<{}>): () => void;
+    on2FAChanged(handler: SocketEventHandler<{
+        enabled: boolean;
+    }>): () => void;
+    onSocketConnected(handler: SocketEventHandler<{}>): () => void;
+    onSocketDisconnected(handler: SocketEventHandler<{
+        reason: string;
+    }>): () => void;
+    onSocketError(handler: SocketEventHandler<{
+        error: string;
+    }>): () => void;
+    isSocketConnected(): boolean;
+    clearUserCache(): void;
+    private isCacheValid;
     isAuthenticated(): boolean;
     getToken(): string | null;
     getCurrentUser(): User | null;
@@ -156,7 +199,7 @@ declare class AuthService {
     verify(data: VerifyData): Promise<AuthResponse>;
     verifyEmailToken(token: string): Promise<AuthResponse>;
     logout(): Promise<void>;
-    getProfile(): Promise<User>;
+    getProfile(forceRefresh?: boolean): Promise<User>;
     updateProfile(data: UpdateUserData): Promise<AuthResponse>;
     getAllUsers(): Promise<User[]>;
     getUserById(id: string): Promise<User>;
@@ -187,6 +230,14 @@ declare class AuthService {
         success: boolean;
         logs: any[];
     }>;
+    adminCreateUser(data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }): Promise<AuthResponse & {
+        user?: User;
+    }>;
     adminVerifyUser(userId: string): Promise<AuthResponse>;
     adminForcePasswordReset(userId: string): Promise<AuthResponse>;
     adminSuspendUser(userId: string): Promise<AuthResponse>;
@@ -236,6 +287,7 @@ interface AuthContextValue {
     isLoaded: boolean;
     isSignedIn: boolean;
     loading: boolean;
+    isSocketConnected: boolean;
     signIn: (data: LoginData) => Promise<AuthResponse>;
     signUp: (data: RegisterData) => Promise<AuthResponse>;
     signOut: () => Promise<void>;

package/dist/index.next.d.ts

@@ -16,6 +16,8 @@ interface User {
     phoneNumber?: string;
     avatar?: string;
     role: string;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
     linkedAccounts?: LinkedAccount[];
     createdAt: string;
     updatedAt: string;
@@ -65,6 +67,7 @@ interface AuthConfig {
     localStorageKey?: string;
     token?: string;
     csrfEnabled?: boolean;
+    enableSocket?: boolean;
     upfilesConfig?: UpfilesConfig;
 }
 interface UpfilesConfig {
@@ -132,17 +135,57 @@ interface UseAuthReturn {
     }>;
     revokeSession: (sessionId: string) => Promise<AuthResponse>;
     revokeAllSessions: () => Promise<AuthResponse>;
+    adminCreateUser: (data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }) => Promise<AuthResponse & {
+        user?: User;
+    }>;
+    adminVerifyUser: (userId: string) => Promise<AuthResponse>;
+    adminSuspendUser: (userId: string) => Promise<AuthResponse>;
+    adminActivateUser: (userId: string) => Promise<AuthResponse>;
 }
 
+type SocketEventHandler<T = any> = (data: T) => void;
+
 declare class AuthService {
     private httpClient;
+    private socketService;
     private config;
     private token;
     private upfilesClient;
+    private cachedUser;
+    private userCacheTimestamp;
+    private readonly USER_CACHE_TTL;
     constructor(config: AuthConfig);
     private loadTokenFromStorage;
     private saveTokenToStorage;
     private removeTokenFromStorage;
+    private connectSocket;
+    private disconnectSocket;
+    onUserUpdated(handler: SocketEventHandler<{
+        user: User;
+    }>): () => void;
+    onSessionRevoked(handler: SocketEventHandler<{
+        sessionId?: string;
+    }>): () => void;
+    onAllSessionsRevoked(handler: SocketEventHandler<{}>): () => void;
+    onPasswordChanged(handler: SocketEventHandler<{}>): () => void;
+    on2FAChanged(handler: SocketEventHandler<{
+        enabled: boolean;
+    }>): () => void;
+    onSocketConnected(handler: SocketEventHandler<{}>): () => void;
+    onSocketDisconnected(handler: SocketEventHandler<{
+        reason: string;
+    }>): () => void;
+    onSocketError(handler: SocketEventHandler<{
+        error: string;
+    }>): () => void;
+    isSocketConnected(): boolean;
+    clearUserCache(): void;
+    private isCacheValid;
     isAuthenticated(): boolean;
     getToken(): string | null;
     getCurrentUser(): User | null;
@@ -156,7 +199,7 @@ declare class AuthService {
     verify(data: VerifyData): Promise<AuthResponse>;
     verifyEmailToken(token: string): Promise<AuthResponse>;
     logout(): Promise<void>;
-    getProfile(): Promise<User>;
+    getProfile(forceRefresh?: boolean): Promise<User>;
     updateProfile(data: UpdateUserData): Promise<AuthResponse>;
     getAllUsers(): Promise<User[]>;
     getUserById(id: string): Promise<User>;
@@ -187,6 +230,14 @@ declare class AuthService {
         success: boolean;
         logs: any[];
     }>;
+    adminCreateUser(data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }): Promise<AuthResponse & {
+        user?: User;
+    }>;
     adminVerifyUser(userId: string): Promise<AuthResponse>;
     adminForcePasswordReset(userId: string): Promise<AuthResponse>;
     adminSuspendUser(userId: string): Promise<AuthResponse>;
@@ -236,6 +287,7 @@ interface AuthContextValue {
     isLoaded: boolean;
     isSignedIn: boolean;
     loading: boolean;
+    isSocketConnected: boolean;
     signIn: (data: LoginData) => Promise<AuthResponse>;
     signUp: (data: RegisterData) => Promise<AuthResponse>;
     signOut: () => Promise<void>;

package/dist/index.next.js

@@ -2,6 +2,7 @@
 'use strict';
 
 var axios = require('axios');
+var socket_ioClient = require('socket.io-client');
 var upfiles = require('@thetechfossil/upfiles');
 var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -128,16 +129,134 @@ var HttpClient = class {
     }
   }
 };
+var SocketService = class {
+  constructor(config) {
+    this.socket = null;
+    this.token = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.isConnecting = false;
+    this.config = {
+      autoConnect: false,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1e3,
+      ...config
+    };
+  }
+  connect(token) {
+    if (this.socket?.connected || this.isConnecting) {
+      return;
+    }
+    this.token = token;
+    this.isConnecting = true;
+    this.socket = socket_ioClient.io(this.config.baseUrl, {
+      auth: { token },
+      autoConnect: true,
+      reconnection: this.config.reconnection,
+      reconnectionAttempts: this.config.reconnectionAttempts,
+      reconnectionDelay: this.config.reconnectionDelay,
+      transports: ["websocket", "polling"]
+    });
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    if (!this.socket) return;
+    this.socket.on("connect", () => {
+      this.isConnecting = false;
+      console.log("[Auth SDK] Socket connected");
+      this.emit("connected", {});
+    });
+    this.socket.on("disconnect", (reason) => {
+      console.log("[Auth SDK] Socket disconnected:", reason);
+      this.emit("disconnected", { reason });
+    });
+    this.socket.on("connect_error", (error) => {
+      this.isConnecting = false;
+      console.error("[Auth SDK] Socket connection error:", error.message);
+      this.emit("error", { error: error.message });
+    });
+    this.socket.on("user:updated", (data) => {
+      this.emit("user:updated", data);
+    });
+    this.socket.on("session:revoked", (data) => {
+      this.emit("session:revoked", data);
+    });
+    this.socket.on("session:all-revoked", () => {
+      this.emit("session:all-revoked", {});
+    });
+    this.socket.on("auth:password-changed", () => {
+      this.emit("auth:password-changed", {});
+    });
+    this.socket.on("auth:2fa-changed", (data) => {
+      this.emit("auth:2fa-changed", data);
+    });
+    this.socket.on("user:refresh", () => {
+      this.emit("user:refresh", {});
+    });
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+      this.token = null;
+      this.isConnecting = false;
+    }
+  }
+  isConnected() {
+    return this.socket?.connected ?? false;
+  }
+  // Event subscription
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => {
+      this.eventHandlers.get(event)?.delete(handler);
+    };
+  }
+  off(event, handler) {
+    if (handler) {
+      this.eventHandlers.get(event)?.delete(handler);
+    } else {
+      this.eventHandlers.delete(event);
+    }
+  }
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`[Auth SDK] Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  // Request fresh user data from server
+  requestUserRefresh() {
+    if (this.socket?.connected) {
+      this.socket.emit("request:user");
+    }
+  }
+};
 var AuthService = class {
+  // 5 minutes cache
   constructor(config) {
     this.token = null;
     this.upfilesClient = null;
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
+    this.USER_CACHE_TTL = 5 * 60 * 1e3;
     this.config = {
       localStorageKey: "auth_token",
       csrfEnabled: true,
+      enableSocket: true,
       ...config
     };
     this.httpClient = new HttpClient(this.config.baseUrl);
+    this.socketService = new SocketService({ baseUrl: this.config.baseUrl });
     this.loadTokenFromStorage();
     if (this.config.upfilesConfig) {
       this.upfilesClient = new upfiles.UpfilesClient({
@@ -154,6 +273,9 @@ var AuthService = class {
         this.httpClient.setFrontendBaseUrl(frontendBaseUrl);
       }
     }
+    if (this.token && this.config.enableSocket !== false) {
+      this.connectSocket();
+    }
   }
   loadTokenFromStorage() {
     if (typeof window !== "undefined" && this.config.localStorageKey) {
@@ -186,6 +308,57 @@ var AuthService = class {
       }
     }
   }
+  // Socket connection management
+  connectSocket() {
+    if (this.token && this.config.enableSocket !== false && typeof window !== "undefined") {
+      this.socketService.connect(this.token);
+    }
+  }
+  disconnectSocket() {
+    this.socketService.disconnect();
+  }
+  // Socket event subscription
+  onUserUpdated(handler) {
+    return this.socketService.on("user:updated", (data) => {
+      if (data.user) {
+        this.cachedUser = data.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      handler(data);
+    });
+  }
+  onSessionRevoked(handler) {
+    return this.socketService.on("session:revoked", handler);
+  }
+  onAllSessionsRevoked(handler) {
+    return this.socketService.on("session:all-revoked", handler);
+  }
+  onPasswordChanged(handler) {
+    return this.socketService.on("auth:password-changed", handler);
+  }
+  on2FAChanged(handler) {
+    return this.socketService.on("auth:2fa-changed", handler);
+  }
+  onSocketConnected(handler) {
+    return this.socketService.on("connected", handler);
+  }
+  onSocketDisconnected(handler) {
+    return this.socketService.on("disconnected", handler);
+  }
+  onSocketError(handler) {
+    return this.socketService.on("error", handler);
+  }
+  isSocketConnected() {
+    return this.socketService.isConnected();
+  }
+  // Cache management
+  clearUserCache() {
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
+  }
+  isCacheValid() {
+    return this.cachedUser !== null && Date.now() - this.userCacheTimestamp < this.USER_CACHE_TTL;
+  }
   isAuthenticated() {
     return !!this.token;
   }
@@ -251,6 +424,11 @@ var AuthService = class {
       this.token = response.token;
       this.httpClient.setAuthToken(response.token);
       this.saveTokenToStorage(response.token);
+      if (response.user) {
+        this.cachedUser = response.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      this.connectSocket();
       return response;
     }
     if (response.success && (response.message === "OTP sent to your email." || response.message === "OTP sent to your phone number.")) {
@@ -260,6 +438,11 @@ var AuthService = class {
       this.token = response.token;
       this.httpClient.setAuthToken(response.token);
       this.saveTokenToStorage(response.token);
+      if (response.user) {
+        this.cachedUser = response.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      this.connectSocket();
       return response;
     }
     throw new Error(response.message || "Login failed");
@@ -303,21 +486,29 @@ var AuthService = class {
     }
   }
   async logout() {
+    this.disconnectSocket();
     try {
       await this.httpClient.post("/api/v1/auth/logout", {});
     } catch (error) {
       console.warn("Failed to call logout endpoint:", error);
     }
     this.token = null;
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
     this.httpClient.removeAuthToken();
     this.httpClient.removeCsrfToken();
     this.removeTokenFromStorage();
   }
-  async getProfile() {
+  async getProfile(forceRefresh = false) {
     if (!this.token) {
       throw new Error("Not authenticated");
     }
+    if (!forceRefresh && this.isCacheValid() && this.cachedUser) {
+      return this.cachedUser;
+    }
     const response = await this.httpClient.get("/api/v1/user/me");
+    this.cachedUser = response.user;
+    this.userCacheTimestamp = Date.now();
     return response.user;
   }
   async updateProfile(data) {
@@ -481,6 +672,16 @@ var AuthService = class {
     );
     return response;
   }
+  async adminCreateUser(data) {
+    if (!this.token) {
+      throw new Error("Not authenticated");
+    }
+    const response = await this.httpClient.post(
+      "/api/v1/admin/create-user",
+      data
+    );
+    return response;
+  }
   async adminVerifyUser(userId) {
     if (!this.token) {
       throw new Error("Not authenticated");
@@ -716,21 +917,49 @@ var AuthProvider = ({ children, config }) => {
   const [user, setUser] = React.useState(null);
   const [isLoaded, setIsLoaded] = React.useState(false);
   const [loading, setLoading] = React.useState(false);
-  const checkAuthStatus = React.useCallback(async () => {
+  const [isSocketConnected, setIsSocketConnected] = React.useState(false);
+  React.useEffect(() => {
+    const unsubUserUpdated = authService.onUserUpdated(({ user: updatedUser }) => {
+      if (updatedUser) {
+        setUser(updatedUser);
+      }
+    });
+    const unsubSessionRevoked = authService.onSessionRevoked(() => {
+      authService.logout().then(() => {
+        setUser(null);
+      });
+    });
+    const unsubAllSessionsRevoked = authService.onAllSessionsRevoked(() => {
+      authService.logout().then(() => {
+        setUser(null);
+      });
+    });
+    const unsubPasswordChanged = authService.onPasswordChanged(() => {
+      authService.logout().then(() => {
+        setUser(null);
+      });
+    });
+    const unsubConnected = authService.onSocketConnected(() => {
+      setIsSocketConnected(true);
+    });
+    const unsubDisconnected = authService.onSocketDisconnected(() => {
+      setIsSocketConnected(false);
+    });
+    return () => {
+      unsubUserUpdated();
+      unsubSessionRevoked();
+      unsubAllSessionsRevoked();
+      unsubPasswordChanged();
+      unsubConnected();
+      unsubDisconnected();
+    };
+  }, [authService]);
+  React.useEffect(() => {
     const authenticated = authService.isAuthenticated();
     if (authenticated) {
-      try {
-        const freshUser = await authService.getProfile();
-        setUser(freshUser);
-      } catch (error) {
-        console.error("Failed to fetch fresh user profile, falling back to token:", error);
-        try {
-          const currentUser = authService.getCurrentUser();
-          setUser(currentUser);
-        } catch (fallbackError) {
-          console.error("Failed to get current user from token:", fallbackError);
-          setUser(null);
-        }
+      const currentUser = authService.getCurrentUser();
+      if (currentUser) {
+        setUser(currentUser);
       }
     } else {
       setUser(null);
@@ -738,8 +967,21 @@ var AuthProvider = ({ children, config }) => {
     setIsLoaded(true);
   }, [authService]);
   React.useEffect(() => {
-    checkAuthStatus();
-  }, [checkAuthStatus]);
+    if (!isLoaded) return;
+    const authenticated = authService.isAuthenticated();
+    if (!authenticated) return;
+    const fetchFreshUser = async () => {
+      try {
+        const freshUser = await authService.getProfile();
+        setUser(freshUser);
+      } catch (error) {
+        console.warn("[Auth SDK] Failed to fetch fresh user profile:", error);
+      }
+    };
+    if (isSocketConnected) {
+      fetchFreshUser();
+    }
+  }, [authService, isLoaded, isSocketConnected]);
   const signIn = React.useCallback(async (data) => {
     setLoading(true);
     try {
@@ -961,6 +1203,7 @@ var AuthProvider = ({ children, config }) => {
     isLoaded,
     isSignedIn: !!user,
     loading,
+    isSocketConnected,
     signIn,
     signUp,
     signOut,
@@ -4469,11 +4712,11 @@ var ChangePassword = ({ onSuccess, appearance }) => {
 
 // src/react/components/utils/injectModalStyles.ts
 var injectModalStyles = () => {
-  if (document.getElementById("ttf-auth-modal-styles")) {
+  if (document.getElementById("ktw-auth-modal-styles")) {
     return;
   }
   const styleElement = document.createElement("style");
-  styleElement.id = "ttf-auth-modal-styles";
+  styleElement.id = "ktw-auth-modal-styles";
   styleElement.textContent = `
     /* ImageManager Modal Styles - Critical for proper modal display */
     /* Radix UI Dialog styles - Force visibility */