@thetechfossil/auth2 1.2.19 → 1.2.21

package/dist/index.node.d.ts

@@ -14,6 +14,8 @@ interface User {
     phoneNumber?: string;
     avatar?: string;
     role: string;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
     linkedAccounts?: LinkedAccount[];
     createdAt: string;
     updatedAt: string;
@@ -63,6 +65,7 @@ interface AuthConfig {
     localStorageKey?: string;
     token?: string;
     csrfEnabled?: boolean;
+    enableSocket?: boolean;
     upfilesConfig?: UpfilesConfig;
 }
 interface UpfilesConfig {
@@ -130,17 +133,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;
@@ -154,7 +197,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>;
@@ -185,6 +228,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>;
@@ -197,6 +248,7 @@ declare class HttpClient {
     private frontendBaseUrl;
     private baseUrl;
     constructor(baseUrl: string, defaultHeaders?: Record<string, string>);
+    private createUserFriendlyError;
     get<T>(endpoint: string, headers?: Record<string, string>): Promise<T>;
     post<T>(endpoint: string, data?: any, headers?: Record<string, string>): Promise<T>;
     put<T>(endpoint: string, data?: any, headers?: Record<string, string>): Promise<T>;
@@ -224,4 +276,31 @@ declare class AuthClient extends AuthService {
     getAllUsers(): Promise<User[]>;
 }
 
-export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData };
+interface TokenVerifierConfig {
+    authServiceUrl: string;
+    cacheTTL?: number;
+    cacheEnabled?: boolean;
+}
+declare class TokenVerifier {
+    private config;
+    private cache;
+    private cleanupInterval;
+    constructor(config: TokenVerifierConfig);
+    verifyToken(token: string): Promise<User | null>;
+    invalidateToken(token: string): void;
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        enabled: boolean;
+        ttl: number;
+    };
+    destroy(): void;
+    private getFromCache;
+    private setCache;
+    private startCleanup;
+}
+declare function createTokenVerifier(config: TokenVerifierConfig): TokenVerifier;
+declare function getTokenVerifier(): TokenVerifier;
+declare function verifyToken(token: string): Promise<User | null>;
+
+export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, TokenVerifier, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData, createTokenVerifier, getTokenVerifier, verifyToken };

package/dist/index.node.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var axios = require('axios');
+var socket_ioClient = require('socket.io-client');
 var upfiles = require('@thetechfossil/upfiles');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -8,6 +9,16 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 
 // src/core/http-client.ts
+var ERROR_MESSAGES = {
+  NETWORK_ERROR: "Unable to connect to the server. Please check your internet connection and try again.",
+  TIMEOUT: "The request took too long. Please try again.",
+  SERVER_ERROR: "Something went wrong on our end. Please try again later.",
+  UNAUTHORIZED: "Your session has expired. Please log in again.",
+  FORBIDDEN: "You do not have permission to perform this action.",
+  NOT_FOUND: "The requested resource was not found.",
+  RATE_LIMITED: "Too many requests. Please wait a moment and try again.",
+  UNKNOWN: "An unexpected error occurred. Please try again."
+};
 var HttpClient = class {
   constructor(baseUrl, defaultHeaders = {}) {
     this.csrfToken = null;
@@ -42,7 +53,7 @@ var HttpClient = class {
         }
         return config;
       },
-      (error) => Promise.reject(error)
+      (error) => Promise.reject(this.createUserFriendlyError(error))
     );
     this.axiosInstance.interceptors.response.use(
       (response) => response,
@@ -57,18 +68,71 @@ var HttpClient = class {
             }
             return this.axiosInstance(originalRequest);
           } catch (refreshError) {
-            return Promise.reject(refreshError);
+            return Promise.reject(this.createUserFriendlyError(refreshError));
           }
         }
-        if (error.response && error.response.data && error.response.data.message) {
-          const customError = new Error(error.response.data.message);
-          customError.response = error.response;
-          return Promise.reject(customError);
-        }
-        return Promise.reject(error);
+        return Promise.reject(this.createUserFriendlyError(error));
       }
     );
   }
+  /**
+   * Creates a user-friendly error message from an Axios error
+   */
+  createUserFriendlyError(error) {
+    if (error instanceof Error && !error.isAxiosError) {
+      return error;
+    }
+    let message;
+    let statusCode;
+    if (axios__default.default.isAxiosError(error)) {
+      statusCode = error.response?.status;
+      const responseData = error.response?.data;
+      if (responseData?.message) {
+        message = responseData.message;
+      } else if (!error.response) {
+        if (error.code === "ECONNABORTED" || error.message.includes("timeout")) {
+          message = ERROR_MESSAGES.TIMEOUT;
+        } else if (error.code === "ERR_NETWORK" || error.message === "Network Error") {
+          message = ERROR_MESSAGES.NETWORK_ERROR;
+        } else {
+          message = ERROR_MESSAGES.NETWORK_ERROR;
+        }
+      } else {
+        switch (statusCode) {
+          case 400:
+            message = responseData?.message || "Invalid request. Please check your input.";
+            break;
+          case 401:
+            message = responseData?.message || ERROR_MESSAGES.UNAUTHORIZED;
+            break;
+          case 403:
+            message = responseData?.message || ERROR_MESSAGES.FORBIDDEN;
+            break;
+          case 404:
+            message = responseData?.message || ERROR_MESSAGES.NOT_FOUND;
+            break;
+          case 429:
+            message = ERROR_MESSAGES.RATE_LIMITED;
+            break;
+          case 500:
+          case 502:
+          case 503:
+          case 504:
+            message = ERROR_MESSAGES.SERVER_ERROR;
+            break;
+          default:
+            message = responseData?.message || ERROR_MESSAGES.UNKNOWN;
+        }
+      }
+    } else {
+      message = error?.message || ERROR_MESSAGES.UNKNOWN;
+    }
+    const customError = new Error(message);
+    customError.response = error?.response;
+    customError.statusCode = statusCode;
+    customError.originalError = error;
+    return customError;
+  }
   async get(endpoint, headers) {
     const response = await this.axiosInstance.get(endpoint, { headers });
     return response.data;
@@ -119,16 +183,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({
@@ -145,6 +327,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) {
@@ -177,6 +362,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;
   }
@@ -242,6 +478,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.")) {
@@ -251,6 +492,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");
@@ -294,21 +540,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) {
@@ -472,6 +726,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");
@@ -580,8 +844,141 @@ var AuthClient = class extends AuthService {
   }
 };
 
+// src/node/token-verifier.ts
+var TokenVerifier = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupInterval = null;
+    this.config = {
+      cacheTTL: 6e4,
+      // 1 minute default
+      cacheEnabled: true,
+      ...config
+    };
+    if (this.config.cacheEnabled) {
+      this.startCleanup();
+    }
+  }
+  /**
+   * Verify a JWT token and get user data
+   * Returns cached user if available and valid
+   */
+  async verifyToken(token) {
+    if (!token) {
+      return null;
+    }
+    if (this.config.cacheEnabled) {
+      const cached = this.getFromCache(token);
+      if (cached) {
+        return cached;
+      }
+    }
+    try {
+      const response = await fetch(`${this.config.authServiceUrl}/api/v1/user/me`, {
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        this.cache.delete(token);
+        return null;
+      }
+      const data = await response.json();
+      const user = data.user || null;
+      if (user && this.config.cacheEnabled) {
+        this.setCache(token, user);
+      }
+      return user;
+    } catch (error) {
+      console.error("[TokenVerifier] Auth service verification failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Invalidate cache for a specific token
+   */
+  invalidateToken(token) {
+    this.cache.delete(token);
+  }
+  /**
+   * Clear all cached tokens
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      enabled: this.config.cacheEnabled,
+      ttl: this.config.cacheTTL
+    };
+  }
+  /**
+   * Stop the cleanup interval (call when shutting down)
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.cache.clear();
+  }
+  getFromCache(token) {
+    const entry = this.cache.get(token);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(token);
+      return null;
+    }
+    return entry.user;
+  }
+  setCache(token, user) {
+    this.cache.set(token, {
+      user,
+      expiresAt: Date.now() + this.config.cacheTTL
+    });
+  }
+  startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [token, entry] of this.cache.entries()) {
+        if (now > entry.expiresAt) {
+          this.cache.delete(token);
+        }
+      }
+    }, 6e4);
+    if (this.cleanupInterval && this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+};
+var defaultVerifier = null;
+function createTokenVerifier(config) {
+  defaultVerifier = new TokenVerifier(config);
+  return defaultVerifier;
+}
+function getTokenVerifier() {
+  if (!defaultVerifier) {
+    throw new Error("TokenVerifier not initialized. Call createTokenVerifier() first.");
+  }
+  return defaultVerifier;
+}
+async function verifyToken(token) {
+  return getTokenVerifier().verifyToken(token);
+}
+
 exports.AuthClient = AuthClient;
 exports.AuthService = AuthService;
 exports.HttpClient = HttpClient;
+exports.TokenVerifier = TokenVerifier;
+exports.createTokenVerifier = createTokenVerifier;
+exports.getTokenVerifier = getTokenVerifier;
+exports.verifyToken = verifyToken;
 //# sourceMappingURL=index.node.js.map
 //# sourceMappingURL=index.node.js.map