@pagamio/frontend-commons-lib 0.8.175 → 0.8.183

package/lib/auth/services/LogoutService.d.ts

@@ -0,0 +1,27 @@
+interface LogoutOptions {
+    clearStorage?: boolean;
+    invalidateSession?: boolean;
+    onLogoutSuccess?: () => void;
+    onLogoutError?: (error: Error) => void;
+    logoutEndpoint?: string;
+    storageKeys?: string[];
+    customCleanup?: () => Promise<void> | void;
+}
+interface LogoutServiceConfig {
+    baseUrl: string;
+    refreshEndpoint: string;
+    logoutEndpoint?: string;
+    storageKeys?: string[];
+}
+export declare class LogoutService {
+    private readonly tokenManager;
+    private readonly options;
+    private readonly baseUrl;
+    constructor(config: LogoutServiceConfig);
+    logout(options?: Partial<LogoutOptions>): Promise<boolean>;
+    private invalidateServerSession;
+    private clearBrowserCache;
+}
+declare const createLogoutService: (config: LogoutServiceConfig) => LogoutService;
+export { createLogoutService };
+export type { LogoutOptions, LogoutServiceConfig };

package/lib/auth/services/LogoutService.js

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Logout service that handles cleanup operations during user logout
+ */
+import { removeLocalStorageItems } from '../../shared';
+import { TokenManager } from '../utils';
+const defaultLogoutOptions = {
+    clearStorage: true,
+    invalidateSession: true,
+    logoutEndpoint: '/api/auth/logout',
+    storageKeys: ['user', 'rememberMe'],
+};
+export class LogoutService {
+    tokenManager;
+    options;
+    baseUrl;
+    constructor(config) {
+        this.baseUrl = config.baseUrl;
+        this.tokenManager = new TokenManager({
+            baseUrl: this.baseUrl,
+            refreshEndpoint: '/auth/refresh', // Default refresh endpoint
+        });
+        this.options = {
+            ...defaultLogoutOptions,
+            logoutEndpoint: config.logoutEndpoint ?? defaultLogoutOptions.logoutEndpoint,
+            storageKeys: config.storageKeys ?? defaultLogoutOptions.storageKeys,
+        };
+    }
+    async logout(options) {
+        const currentOptions = { ...this.options, ...options };
+        const { clearStorage, invalidateSession, logoutEndpoint, storageKeys, onLogoutSuccess, onLogoutError, customCleanup, } = currentOptions;
+        try {
+            const cleanupTasks = [];
+            // Clear tokens
+            this.tokenManager.clearAllTokens();
+            // Clear localStorage
+            if (clearStorage && storageKeys?.length) {
+                removeLocalStorageItems(storageKeys);
+            }
+            // Invalidate server session
+            if (invalidateSession && logoutEndpoint) {
+                const { token } = this.tokenManager.getAccessToken();
+                if (token) {
+                    cleanupTasks.push(this.invalidateServerSession(logoutEndpoint, token));
+                }
+            }
+            // Run custom cleanup if provided
+            if (customCleanup) {
+                const cleanup = customCleanup();
+                if (cleanup instanceof Promise) {
+                    cleanupTasks.push(cleanup);
+                }
+            }
+            // Clear browser cache
+            cleanupTasks.push(this.clearBrowserCache());
+            await Promise.all(cleanupTasks);
+            onLogoutSuccess?.();
+            return true;
+        }
+        catch (error) {
+            const logoutError = error instanceof Error ? error : new Error('Logout failed');
+            onLogoutError?.(logoutError);
+            throw logoutError;
+        }
+    }
+    async invalidateServerSession(endpoint, token) {
+        const fullEndpoint = endpoint.startsWith('http') ? endpoint : `${this.baseUrl}${endpoint}`;
+        const response = await fetch(fullEndpoint, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to invalidate session: ${response.statusText}`);
+        }
+    }
+    async clearBrowserCache() {
+        if (typeof window === 'undefined')
+            return;
+        // Clear service worker registrations
+        if ('serviceWorker' in navigator) {
+            const registrations = await navigator.serviceWorker.getRegistrations();
+            await Promise.all(registrations.map((registration) => registration.unregister()));
+        }
+        // Clear browser cache
+        if ('caches' in window) {
+            const keys = await caches.keys();
+            await Promise.all(keys.map((key) => caches.delete(key)));
+        }
+    }
+}
+// Create default instance with baseUrl from window.location.origin
+const createLogoutService = (config) => {
+    return new LogoutService(config);
+};
+// Export the create function and types
+export { createLogoutService };

package/lib/auth/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AuthService';
+export * from './LogoutService';

package/lib/auth/services/index.js

@@ -0,0 +1,2 @@
+export * from './AuthService';
+export * from './LogoutService';

package/lib/auth/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './layout';

package/lib/auth/shared/index.js

@@ -0,0 +1 @@
+export * from './layout';

package/lib/auth/shared/layout/AuthPageLayout.d.ts

@@ -0,0 +1,10 @@
+interface AuthPageLayoutProps {
+    title: string;
+    subtitle: string;
+    errorMessage: string | null;
+    showLogo?: boolean;
+    renderInAppLayout?: boolean;
+    children: React.ReactNode;
+}
+declare const AuthPageLayout: React.FC<AuthPageLayoutProps>;
+export default AuthPageLayout;

package/lib/auth/shared/layout/AuthPageLayout.js

@@ -0,0 +1,16 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Card } from 'flowbite-react';
+const AuthPageLayout = ({ title, subtitle, errorMessage, showLogo = true, renderInAppLayout = false, children, }) => {
+    return (_jsxs("div", { className: `mx-auto flex w-full max-w-[640px] flex-col items-center justify-center px-4 py-8 sm:px-6 ${renderInAppLayout ? 'h-[calc(100vh-64px)]' : 'min-h-screen md:h-screen'}`, children: [showLogo && (_jsx("img", { alt: "Pagamio Logo", src: "/images/pagamio-full-colored-logo.svg", width: 280, height: 250, className: "mb-[2.5em]" })), _jsxs(Card, { horizontal: true, className: "w-full p-2 sm:p-3", theme: {
+                    root: {
+                        children: 'my-auto w-full gap-0 space-y-6 p-4 sm:p-6 lg:p-12',
+                    },
+                    img: {
+                        horizontal: {
+                            on: 'hidden w-2/3 rounded-l-lg md:w-96 md:p-0 lg:block',
+                        },
+                    },
+                }, children: [_jsxs("div", { className: "space-y-2", children: [_jsx("h2", { className: "text-[1.5em] sm:text-[1.875em] font-bold text-gray-900 dark:text-white", children: title }), _jsx("p", { className: "text-[1em] font-medium text-gray-600 dark:text-white", children: subtitle })] }), errorMessage && (_jsx("div", { className: "mt-4 rounded border border-red-400 bg-red-100 p-2 text-red-700", children: errorMessage })), children] })] }));
+};
+export default AuthPageLayout;

package/lib/auth/shared/layout/index.d.ts

@@ -0,0 +1 @@
+export { default as AuthLayout } from './AuthPageLayout';

package/lib/auth/shared/layout/index.js

@@ -0,0 +1 @@
+export { default as AuthLayout } from './AuthPageLayout';

package/lib/auth/types/auth.types.d.ts

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Core type definitions for the authentication system.
+ * This file contains all the base types and interfaces that can be extended
+ * for specific authentication implementations.
+ */
+declare enum RoleNameProps {
+    ROLE_ADMIN = "ROLE_ADMIN",
+    ROLE_VENDOR = "ROLE_VENDOR",
+    ROLE_MERCHANT = "ROLE_MERCHANT",
+    ROLE_PROMOTER = "ROLE_PROMOTER",
+    ROLE_ARTIST = "ROLE_ARTIST"
+}
+/**
+ * Generic token structure containing essential token information
+ */
+export interface BaseTokenInfo {
+    token: string;
+    expiresIn: number;
+    [key: string]: unknown;
+}
+/**
+ * Generic user properties that should be present in all implementations
+ */
+export interface BaseUserInfo {
+    id: number | string;
+    userName: string;
+    [key: string]: unknown;
+}
+/**
+ * Generic authentication credentials interface
+ * Can be extended to include specific credential requirements
+ */
+export interface BaseAuthCredentials {
+    username?: string;
+    password?: string;
+    [key: string]: unknown;
+}
+/**
+ * Core authentication state interface
+ */
+export interface BaseAuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Generic error structure for authentication errors
+ */
+export interface BaseAuthError {
+    code: string;
+    message: string;
+    [key: string]: unknown;
+}
+/**
+ * Customizable type generator for specific authentication implementations
+ * @template TRole - Role type extending BaseRole
+ * @template TPermission - Permission type extending BasePermission
+ * @template TPermission - Permission type extending string
+ * @template TErrorCode - Error code type extending string
+ * @template TTokenInfo - Token info type extending BaseTokenInfo
+ * @template TCredentials - Credentials type extending BaseAuthCredentials
+ * @template TError - Error type extending BaseAuthError
+ */
+export type CustomAuthConfig<TRole extends string = string, TPermission extends string = string, TErrorCode extends string = string, TUserInfo extends BaseUserInfo = BaseUserInfo, TTokenInfo extends BaseTokenInfo = BaseTokenInfo, TCredentials extends BaseAuthCredentials = BaseAuthCredentials, TError extends BaseAuthError = BaseAuthError> = {
+    UserInfo: TUserInfo;
+    TokenInfo: TTokenInfo;
+    Credentials: TCredentials;
+    Error: TError;
+    Role: TRole;
+    Permission: TPermission;
+    ErrorCode: TErrorCode;
+};
+/**
+ * Type generator for authentication response
+ * @template T - CustomAuthConfig type
+ */
+export type AuthResponse<T extends CustomAuthConfig> = {
+    user: T['UserInfo'];
+    auth: {
+        accessToken: T['TokenInfo'];
+        refreshToken?: T['TokenInfo'];
+    };
+    [key: string]: unknown;
+};
+export type ExtractUserInfo<T extends CustomAuthConfig> = T['UserInfo'];
+export type ExtractAuthError<T extends CustomAuthConfig> = T['Error'];
+export type PartialAuthConfig<T extends CustomAuthConfig> = {
+    [K in keyof T]?: Partial<T[K]>;
+};
+/**
+ * Generic transformer interface for handling different authentication API response formats.
+ * Implements the Strategy pattern to allow multiple response format handlers.
+ *
+ * @template T - Type extending CustomAuthConfig that defines the shape of user info, token info, and credentials
+ *
+ * @example
+ * ```typescript
+ * class MyApiTransformer implements ApiResponseTransformer<MyAuthConfig> {
+ *   canHandle(response: any): boolean {
+ *     return response.hasOwnProperty('mySpecificField');
+ *   }
+ *
+ *   transform(response: any): AuthResponse<MyAuthConfig> {
+ *     // Transform API response to AuthResponse format
+ *     return {
+ *       user: { ... },
+ *       auth: { ... }
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export interface ApiResponseTransformer<T extends CustomAuthConfig> {
+    /**
+     * Transforms raw API response into standardized AuthResponse format
+     * @param response - Raw API response data
+     * @param remember
+     * @returns Standardized auth response matching the generic type T
+     */
+    transform(response: any, remember?: boolean): AuthResponse<T>;
+    /**
+     * Determines if this transformer can handle the given response format
+     * @param response - Raw API response data to check
+     * @returns True if this transformer can handle the response format
+     */
+    canHandle(response: any): boolean;
+}
+/**
+ * Authentication configuration for the Events application.
+ * Defines the structure of user information, token data, and login credentials
+ * specific to the Events app authentication flow.
+ *
+ * @example
+ * ```typescript
+ * const authService = createAuthService<EventsAppAuthConfig>({
+ *   baseUrl: 'https://api.events.example.com',
+ *   endpoints: {
+ *     login: '/auth/login',
+ *     // ...other endpoints
+ *   }
+ * });
+ * ```
+ */
+export interface EventsAppAuthConfig extends CustomAuthConfig {
+    /** User information structure for Events app */
+    UserInfo: {
+        /** Unique identifier for the user */
+        id: string;
+        /** Username used for authentication */
+        userName: string;
+        /** User's first name */
+        firstName: string;
+        /** User's last name */
+        lastName: string;
+        /** Array of role identifiers assigned to the user */
+        roles: string[];
+        /** Primary role name */
+        roleName: RoleNameProps;
+        /** Description of the user's role */
+        roleDesc: string;
+        /** Associated vendor identifier */
+        vendorId: number;
+        /** Optional promoter identifier */
+        promoterId: number | null;
+        /** Company name associated with the user */
+        company: string;
+        /** IQ Retail access flag */
+        hasIQRetailAccess?: boolean;
+    };
+    /** Token information structure */
+    TokenInfo: {
+        /** JWT or other authentication token */
+        token: string;
+        /** Token expiration time in seconds */
+        expiresIn: number;
+    };
+    /** Login credentials structure */
+    Credentials: {
+        /** Username for authentication */
+        username: string;
+        /** User's password */
+        password: string;
+    };
+}
+/**
+ * Authentication configuration for the VAS (Value Added Services) application.
+ * Defines the structure of user information, token data, and login credentials
+ * specific to the VAS app authentication flow.
+ *
+ * @example
+ * ```typescript
+ * const authService = createAuthService<VasAppAuthConfig>({
+ *   baseUrl: 'https://api.vas.example.com',
+ *   endpoints: {
+ *     login: '/auth/login',
+ *     // ...other endpoints
+ *   }
+ * });
+ * ```
+ */
+export interface VasAppAuthConfig extends CustomAuthConfig {
+    /** User information structure for VAS app */
+    UserInfo: {
+        /** Numeric user identifier */
+        id: number;
+        /** Username used for authentication */
+        userName: string;
+        /** Array of role identifiers assigned to the user */
+        roles: string[];
+        /** Secondary user identifier */
+        userId: number;
+        /** User type (e.g., PARTNER_USER, VENDOR_USER) */
+        userType: string;
+        /** User type identifier from backend */
+        userTypeId: string;
+        /** Flag indicating if the user has an associated wallet */
+        hasWallet: boolean;
+    };
+    /** Token information structure */
+    TokenInfo: {
+        /** JWT or other authentication token */
+        token: string;
+        /** Token expiration time in seconds */
+        expiresIn: number;
+    };
+    /** Login credentials structure */
+    Credentials: {
+        /** Username for authentication */
+        username: string;
+        /** User's password */
+        password: string;
+    };
+}
+export {};

package/lib/auth/types/auth.types.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Core type definitions for the authentication system.
+ * This file contains all the base types and interfaces that can be extended
+ * for specific authentication implementations.
+ */
+var RoleNameProps;
+(function (RoleNameProps) {
+    RoleNameProps["ROLE_ADMIN"] = "ROLE_ADMIN";
+    RoleNameProps["ROLE_VENDOR"] = "ROLE_VENDOR";
+    RoleNameProps["ROLE_MERCHANT"] = "ROLE_MERCHANT";
+    RoleNameProps["ROLE_PROMOTER"] = "ROLE_PROMOTER";
+    RoleNameProps["ROLE_ARTIST"] = "ROLE_ARTIST";
+})(RoleNameProps || (RoleNameProps = {}));
+export {};

package/lib/auth/types/index.d.ts

@@ -0,0 +1 @@
+export * from './auth.types';

package/lib/auth/types/index.js

@@ -0,0 +1 @@
+export * from './auth.types';

package/lib/auth/utils/TokenManager.d.ts

@@ -0,0 +1,43 @@
+import { type CustomAuthConfig } from '../types';
+interface CookieOptions {
+    expires?: number;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    domain?: string;
+}
+interface TokenManagerConfig {
+    baseUrl: string;
+    refreshEndpoint: string;
+    cookieOptions?: Partial<CookieOptions>;
+}
+export declare class TokenManager<T extends CustomAuthConfig> {
+    private readonly cookieOptions;
+    private readonly baseUrl;
+    private readonly refreshEndpoint;
+    constructor(config: TokenManagerConfig);
+    setAccessToken(tokenInfo: T['TokenInfo']): void;
+    getAccessToken(): {
+        token: string | undefined;
+        expiresAt: number | null;
+    };
+    setRefreshToken(tokenInfo: T['TokenInfo']): void;
+    getRefreshToken(): string | undefined;
+    refreshTokens(): Promise<boolean>;
+    /**
+     * Handles setting both access and refresh tokens with proper expiry
+     */
+    handleSetAccessAndRefreshTokens(accessToken: string, refreshToken: string | undefined, accessTokenExpiresIn: number, refreshTokenExpiresIn?: number): void;
+    clearAllTokens(): void;
+    isAccessTokenExpired(): boolean;
+    handleAuthTokens(authResponse: {
+        accessToken: T['TokenInfo'];
+        refreshToken?: T['TokenInfo'];
+    }): void;
+    private setCookie;
+    private getCookie;
+    private removeCookie;
+}
+export declare const createTokenManager: <T extends CustomAuthConfig>(config: TokenManagerConfig) => TokenManager<T>;
+export declare const useTokenManager: <T extends CustomAuthConfig>(config: TokenManagerConfig) => TokenManager<T>;
+export {};

package/lib/auth/utils/TokenManager.js

@@ -0,0 +1,171 @@
+/**
+ * @fileoverview Token management utility for handling authentication tokens
+ */
+import Cookies from 'js-cookie';
+import { useMemo } from 'react';
+const TOKEN_CONFIG = {
+    ACCESS_TOKEN: {
+        name: 'accessToken',
+        defaultExpiry: 1 / 24,
+        path: '/',
+        secure: true,
+        sameSite: 'strict',
+    },
+    REFRESH_TOKEN: {
+        name: 'refreshToken',
+        defaultExpiry: 7,
+        path: '/',
+        secure: true,
+        sameSite: 'strict',
+    },
+};
+export class TokenManager {
+    cookieOptions;
+    baseUrl;
+    refreshEndpoint;
+    constructor(config) {
+        this.cookieOptions = {
+            secure: true,
+            sameSite: 'strict',
+            path: '/',
+            ...config.cookieOptions,
+        };
+        this.baseUrl = config.baseUrl;
+        this.refreshEndpoint = config.refreshEndpoint;
+    }
+    setAccessToken(tokenInfo) {
+        const expiryInDays = tokenInfo.expiresIn / (24 * 3600);
+        this.setCookie(TOKEN_CONFIG.ACCESS_TOKEN.name, tokenInfo.token, {
+            expires: expiryInDays,
+        });
+        const expiresAt = Date.now() + tokenInfo.expiresIn * 1000;
+        this.setCookie(`${TOKEN_CONFIG.ACCESS_TOKEN.name}ExpiresAt`, String(expiresAt), {
+            expires: expiryInDays,
+        });
+    }
+    getAccessToken() {
+        const token = this.getCookie(TOKEN_CONFIG.ACCESS_TOKEN.name);
+        const expiresAtStr = this.getCookie(`${TOKEN_CONFIG.ACCESS_TOKEN.name}ExpiresAt`);
+        const expiresAt = expiresAtStr ? parseInt(expiresAtStr, 10) : null;
+        return { token, expiresAt };
+    }
+    setRefreshToken(tokenInfo) {
+        const expiryInDays = tokenInfo.expiresIn / (24 * 3600);
+        this.setCookie(TOKEN_CONFIG.REFRESH_TOKEN.name, tokenInfo.token, {
+            expires: expiryInDays,
+        });
+    }
+    getRefreshToken() {
+        return this.getCookie(TOKEN_CONFIG.REFRESH_TOKEN.name);
+    }
+    async refreshTokens() {
+        try {
+            const oldRefreshToken = this.getRefreshToken();
+            if (!oldRefreshToken) {
+                this.clearAllTokens();
+                throw new Error('No refresh token available');
+            }
+            const response = await fetch(`${this.baseUrl}${this.refreshEndpoint}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ refreshToken: oldRefreshToken }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new Error(data.error || 'Failed to refresh token');
+            }
+            const { accessToken, refreshToken: newRefreshToken, accessTokenExpiresIn, refreshTokenExpiresIn } = data;
+            this.handleAuthTokens({
+                accessToken: {
+                    token: accessToken,
+                    expiresIn: accessTokenExpiresIn,
+                },
+                ...(newRefreshToken && refreshTokenExpiresIn
+                    ? {
+                        refreshToken: {
+                            token: newRefreshToken,
+                            expiresIn: refreshTokenExpiresIn,
+                        },
+                    }
+                    : {}),
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('Token refresh failed:', error);
+            this.clearAllTokens();
+            return false;
+        }
+    }
+    /**
+     * Handles setting both access and refresh tokens with proper expiry
+     */
+    handleSetAccessAndRefreshTokens(accessToken, refreshToken, accessTokenExpiresIn, refreshTokenExpiresIn) {
+        // Set access token
+        this.handleAuthTokens({
+            accessToken: {
+                token: accessToken,
+                expiresIn: accessTokenExpiresIn,
+            },
+            ...(refreshToken && refreshTokenExpiresIn
+                ? {
+                    refreshToken: {
+                        token: refreshToken,
+                        expiresIn: refreshTokenExpiresIn,
+                    },
+                }
+                : {}),
+        });
+    }
+    clearAllTokens() {
+        this.removeCookie(TOKEN_CONFIG.ACCESS_TOKEN.name);
+        this.removeCookie(`${TOKEN_CONFIG.ACCESS_TOKEN.name}ExpiresAt`);
+        this.removeCookie(TOKEN_CONFIG.REFRESH_TOKEN.name);
+    }
+    isAccessTokenExpired() {
+        const { expiresAt } = this.getAccessToken();
+        if (!expiresAt)
+            return true;
+        return Date.now() >= expiresAt - 30000;
+    }
+    handleAuthTokens(authResponse) {
+        this.setAccessToken(authResponse.accessToken);
+        if (authResponse.refreshToken) {
+            this.setRefreshToken(authResponse.refreshToken);
+        }
+    }
+    setCookie(name, value, options = {}) {
+        if (typeof window === 'undefined')
+            return;
+        const finalOptions = {
+            ...this.cookieOptions,
+            ...options,
+        };
+        try {
+            Cookies.set(name, value, finalOptions);
+        }
+        catch (error) {
+            console.error(`Error setting cookie ${name}:`, error);
+        }
+    }
+    getCookie(name) {
+        if (typeof window === 'undefined')
+            return undefined;
+        return Cookies.get(name);
+    }
+    removeCookie(name, options = {}) {
+        if (typeof window === 'undefined')
+            return;
+        Cookies.remove(name, { ...this.cookieOptions, ...options });
+    }
+}
+// Standalone token manager instance creation
+export const createTokenManager = (config) => {
+    return new TokenManager(config);
+};
+// React hook for using token manager
+export const useTokenManager = (config) => {
+    return useMemo(() => new TokenManager(config), [config]);
+};