@pagamio/frontend-commons-lib 0.8.175 → 0.8.183

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

@@ -0,0 +1,158 @@
+import type { ApiResponseTransformer, AuthResponse, EventsAppAuthConfig, VasAppAuthConfig } from '../types';
+/**
+ * Transforms authentication responses from the Events App API format into a standardized AuthResponse.
+ * This transformer handles responses that include a single token and role-based user information.
+ *
+ * Expected API response format:
+ * ```typescript
+ * {
+ *   token: string;
+ *   firstName: string;
+ *   lastName: string;
+ *   username: string;
+ *   roles: string[] | null;
+ *   roleName: string;
+ *   roleDesc: string;
+ *   vendorId: number;
+ *   promoterId: number | null;
+ *   company: string;
+ * }
+ * ```
+ *
+ * @implements {ApiResponseTransformer<EventsAppAuthConfig>}
+ *
+ * @example
+ * ```typescript
+ * const transformer = new EventsAppResponseTransformer();
+ * const response = {
+ *   token: "jwt.token.here",
+ *   firstName: "John",
+ *   lastName: "Doe",
+ *   username: "john.doe",
+ *   roleName: "ADMIN"
+ *   // ... other fields
+ * };
+ *
+ * if (transformer.canHandle(response)) {
+ *   const authResponse = transformer.transform(response);
+ *   // Use transformed response
+ * }
+ * ```
+ */
+export declare class EventsAppResponseTransformer implements ApiResponseTransformer<EventsAppAuthConfig> {
+    /**
+     * Checks if the given response matches the Event App API format.
+     * Verifies the presence of required fields specific to Event App responses.
+     *
+     * @param response - The raw API response to check
+     * @returns True if the response contains 'token' and 'roleName' fields
+     */
+    canHandle(response: any): boolean;
+    /**
+     * Transforms a Event App API response into the standardized AuthResponse format.
+     * Maps API-specific fields to the common auth response structure.
+     *
+     * @param response - The raw API response to transform
+     * @param remember
+     * @returns Standardized auth response with user and token information
+     * @throws Error if required fields are missing from the response
+     */
+    transform(response: any, remember?: boolean): AuthResponse<EventsAppAuthConfig>;
+}
+/**
+ * Transforms authentication responses from the Vas App API format into a standardized AuthResponse.
+ * This transformer handles responses that include both access and refresh tokens.
+ *
+ * Expected API response format:
+ * ```typescript
+ * {
+ *   accessToken: string;
+ *   refreshToken: string;
+ *   accessTokenExpiresIn: number;
+ *   refreshTokenExpiresIn: number;
+ *   username: string;
+ *   roles: string[];
+ *   userId: number;
+ * }
+ * ```
+ *
+ * @implements {ApiResponseTransformer<VasAppAuthConfig>}
+ *
+ * @example
+ * ```typescript
+ * const transformer = new VasAppResponseTransformer();
+ * const response = {
+ *   accessToken: "access.token.here",
+ *   refreshToken: "refresh.token.here",
+ *   accessTokenExpiresIn: 3600,
+ *   username: "vendor_user"
+ *   // ... other fields
+ * };
+ *
+ * if (transformer.canHandle(response)) {
+ *   const authResponse = transformer.transform(response);
+ *   // Use transformed response
+ * }
+ * ```
+ */
+export declare class VasAppResponseTransformer implements ApiResponseTransformer<VasAppAuthConfig> {
+    /**
+     * Checks if the given response matches the Vas App API format.
+     * Verifies the presence of required fields specific to Vendor responses.
+     *
+     * @param response - The raw API response to check
+     * @returns True if the response contains both 'accessToken' and 'refreshToken' fields
+     */
+    canHandle(response: any): boolean;
+    /**
+     * Transforms a Vas App API response into the standardized AuthResponse format.
+     * Maps API-specific fields to the common auth response structure.
+     *
+     * @param response - The raw API response to transform
+     * @param remember
+     * @returns Standardized auth response with user and token information
+     * @throws Error if required fields are missing from the response
+     */
+    transform(response: any, remember?: boolean): AuthResponse<VasAppAuthConfig>;
+}
+/**
+ * Factory class for creating and managing response transformers.
+ * Implements the Factory pattern to dynamically select the appropriate transformer
+ * based on the API response format.
+ *
+ * @example
+ * ```typescript
+ * const apiResponse = await fetchFromApi();
+ * const transformer = ResponseTransformerFactory.getTransformer(apiResponse);
+ * const authResponse = transformer.transform(apiResponse);
+ * ```
+ */
+export declare class ResponseTransformerFactory {
+    /**
+     * Collection of available transformers.
+     * Add new transformer instances here to support additional API response formats.
+     *
+     * @private
+     * @static
+     */
+    private static readonly transformers;
+    /**
+     * Gets the appropriate transformer for the given API response.
+     * Iterates through available transformers and returns the first one that can handle the response.
+     *
+     * @param response - The raw API response to find a transformer for
+     * @returns The first transformer that can handle the response format
+     * @throws Error if no suitable transformer is found
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const transformer = ResponseTransformerFactory.getTransformer(apiResponse);
+     *   const authResponse = transformer.transform(apiResponse);
+     * } catch (error) {
+     *   console.error('No suitable transformer found:', error);
+     * }
+     * ```
+     */
+    static getTransformer(response: any): ApiResponseTransformer<any>;
+}

package/lib/auth/utils/Transformers.js

@@ -0,0 +1,263 @@
+import { jwtDecode } from 'jwt-decode';
+/**
+ * Transforms authentication responses from the Events App API format into a standardized AuthResponse.
+ * This transformer handles responses that include a single token and role-based user information.
+ *
+ * Expected API response format:
+ * ```typescript
+ * {
+ *   token: string;
+ *   firstName: string;
+ *   lastName: string;
+ *   username: string;
+ *   roles: string[] | null;
+ *   roleName: string;
+ *   roleDesc: string;
+ *   vendorId: number;
+ *   promoterId: number | null;
+ *   company: string;
+ * }
+ * ```
+ *
+ * @implements {ApiResponseTransformer<EventsAppAuthConfig>}
+ *
+ * @example
+ * ```typescript
+ * const transformer = new EventsAppResponseTransformer();
+ * const response = {
+ *   token: "jwt.token.here",
+ *   firstName: "John",
+ *   lastName: "Doe",
+ *   username: "john.doe",
+ *   roleName: "ADMIN"
+ *   // ... other fields
+ * };
+ *
+ * if (transformer.canHandle(response)) {
+ *   const authResponse = transformer.transform(response);
+ *   // Use transformed response
+ * }
+ * ```
+ */
+export class EventsAppResponseTransformer {
+    /**
+     * Checks if the given response matches the Event App API format.
+     * Verifies the presence of required fields specific to Event App responses.
+     *
+     * @param response - The raw API response to check
+     * @returns True if the response contains 'token' and 'roleName' fields
+     */
+    canHandle(response) {
+        return response.hasOwnProperty('token') && response.hasOwnProperty('roleName');
+    }
+    /**
+     * Transforms a Event App API response into the standardized AuthResponse format.
+     * Maps API-specific fields to the common auth response structure.
+     *
+     * @param response - The raw API response to transform
+     * @param remember
+     * @returns Standardized auth response with user and token information
+     * @throws Error if required fields are missing from the response
+     */
+    transform(response, remember) {
+        // Decode the token using jwt-decode
+        let decodedToken;
+        try {
+            decodedToken = jwtDecode(response.token);
+        }
+        catch (error) {
+            console.error('Error decoding JWT token:', error);
+            throw new Error('Failed to decode JWT token. Please check the token format.');
+        }
+        if (!decodedToken.exp) {
+            throw new Error('Token does not contain an expiry time (exp claim)');
+        }
+        let expiresIn;
+        if (remember) {
+            // 7 days in seconds
+            expiresIn = 7 * 24 * 60 * 60;
+        }
+        else {
+            // 30 minutes in seconds
+            expiresIn = 30 * 60;
+        }
+        if (expiresIn <= 0) {
+            throw new Error('Token has already expired');
+        }
+        return {
+            user: {
+                id: response.userId,
+                userName: response.username,
+                firstName: response.firstName,
+                lastName: response.lastName,
+                roles: response.roles,
+                roleName: response.roleName,
+                roleDesc: response.roleDesc,
+                vendorId: response.vendorId,
+                promoterId: response.promoterId,
+                company: response.company,
+                hasIQRetailAccess: response.hasIQRetailAccess ?? false,
+            },
+            auth: {
+                accessToken: {
+                    token: response.token,
+                    expiresIn: expiresIn ?? 36000000,
+                },
+            },
+        };
+    }
+}
+/**
+ * Transforms authentication responses from the Vas App API format into a standardized AuthResponse.
+ * This transformer handles responses that include both access and refresh tokens.
+ *
+ * Expected API response format:
+ * ```typescript
+ * {
+ *   accessToken: string;
+ *   refreshToken: string;
+ *   accessTokenExpiresIn: number;
+ *   refreshTokenExpiresIn: number;
+ *   username: string;
+ *   roles: string[];
+ *   userId: number;
+ * }
+ * ```
+ *
+ * @implements {ApiResponseTransformer<VasAppAuthConfig>}
+ *
+ * @example
+ * ```typescript
+ * const transformer = new VasAppResponseTransformer();
+ * const response = {
+ *   accessToken: "access.token.here",
+ *   refreshToken: "refresh.token.here",
+ *   accessTokenExpiresIn: 3600,
+ *   username: "vendor_user"
+ *   // ... other fields
+ * };
+ *
+ * if (transformer.canHandle(response)) {
+ *   const authResponse = transformer.transform(response);
+ *   // Use transformed response
+ * }
+ * ```
+ */
+export class VasAppResponseTransformer {
+    /**
+     * Checks if the given response matches the Vas App API format.
+     * Verifies the presence of required fields specific to Vendor responses.
+     *
+     * @param response - The raw API response to check
+     * @returns True if the response contains both 'accessToken' and 'refreshToken' fields
+     */
+    canHandle(response) {
+        return response.hasOwnProperty('accessToken') && response.hasOwnProperty('refreshToken');
+    }
+    /**
+     * Transforms a Vas App API response into the standardized AuthResponse format.
+     * Maps API-specific fields to the common auth response structure.
+     *
+     * @param response - The raw API response to transform
+     * @param remember
+     * @returns Standardized auth response with user and token information
+     * @throws Error if required fields are missing from the response
+     */
+    transform(response, remember) {
+        let decodedToken;
+        try {
+            decodedToken = jwtDecode(response.accessToken);
+        }
+        catch (error) {
+            console.error('Error decoding JWT access token:', error);
+            throw new Error('Failed to decode JWT access token. Please check the token format.');
+        }
+        if (!decodedToken.exp) {
+            throw new Error('Access token does not contain an expiry time (exp claim)');
+        }
+        let accessExpiresIn;
+        if (remember) {
+            // 7 days in seconds
+            accessExpiresIn = 7 * 24 * 60 * 60;
+        }
+        else {
+            // 30 minutes in seconds
+            accessExpiresIn = 30 * 60;
+        }
+        if (accessExpiresIn <= 0) {
+            throw new Error('Access token has already expired');
+        }
+        const refreshExpiresIn = remember ? 30 * 24 * 60 * 60 : 24 * 60 * 60; // 30 days or 1 day
+        return {
+            user: {
+                id: response.userId,
+                userName: response.username,
+                roles: response.roles,
+                userId: response.userId,
+                userType: response.userType,
+                userTypeId: response.userTypeId,
+                hasWallet: response.hasWallet ?? false,
+            },
+            auth: {
+                accessToken: {
+                    token: response.accessToken,
+                    expiresIn: accessExpiresIn,
+                },
+                refreshToken: {
+                    token: response.refreshToken,
+                    expiresIn: refreshExpiresIn,
+                },
+            },
+        };
+    }
+}
+/**
+ * Factory class for creating and managing response transformers.
+ * Implements the Factory pattern to dynamically select the appropriate transformer
+ * based on the API response format.
+ *
+ * @example
+ * ```typescript
+ * const apiResponse = await fetchFromApi();
+ * const transformer = ResponseTransformerFactory.getTransformer(apiResponse);
+ * const authResponse = transformer.transform(apiResponse);
+ * ```
+ */
+export class ResponseTransformerFactory {
+    /**
+     * Collection of available transformers.
+     * Add new transformer instances here to support additional API response formats.
+     *
+     * @private
+     * @static
+     */
+    static transformers = [
+        new EventsAppResponseTransformer(),
+        new VasAppResponseTransformer(),
+    ];
+    /**
+     * Gets the appropriate transformer for the given API response.
+     * Iterates through available transformers and returns the first one that can handle the response.
+     *
+     * @param response - The raw API response to find a transformer for
+     * @returns The first transformer that can handle the response format
+     * @throws Error if no suitable transformer is found
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const transformer = ResponseTransformerFactory.getTransformer(apiResponse);
+     *   const authResponse = transformer.transform(apiResponse);
+     * } catch (error) {
+     *   console.error('No suitable transformer found:', error);
+     * }
+     * ```
+     */
+    static getTransformer(response) {
+        const transformer = this.transformers.find((t) => t.canHandle(response));
+        if (!transformer) {
+            throw new Error('No suitable transformer found for response format');
+        }
+        return transformer;
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Different types of errors that can occur during authentication
+ */
+export declare enum AuthErrorType {
+    NETWORK = "NETWORK",
+    AUTHENTICATION = "AUTHENTICATION",
+    SERVER = "SERVER",
+    VALIDATION = "VALIDATION",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Structured error information
+ */
+export interface AuthErrorInfo {
+    type: AuthErrorType;
+    message: string;
+    originalError?: Error;
+}
+/**
+ * Detects the type of error and returns appropriate user-friendly message
+ */
+export declare function detectErrorType(error: unknown): AuthErrorInfo;

package/lib/auth/utils/errorDetection.js

@@ -0,0 +1,190 @@
+/**
+ * Different types of errors that can occur during authentication
+ */
+export var AuthErrorType;
+(function (AuthErrorType) {
+    AuthErrorType["NETWORK"] = "NETWORK";
+    AuthErrorType["AUTHENTICATION"] = "AUTHENTICATION";
+    AuthErrorType["SERVER"] = "SERVER";
+    AuthErrorType["VALIDATION"] = "VALIDATION";
+    AuthErrorType["UNKNOWN"] = "UNKNOWN";
+})(AuthErrorType || (AuthErrorType = {}));
+/**
+ * Network error indicators
+ */
+const NETWORK_ERROR_INDICATORS = {
+    ERROR_MESSAGES: ['NetworkError', 'Failed to fetch', 'ERR_NETWORK', 'ERR_INTERNET_DISCONNECTED'],
+    STRING_INDICATORS: [
+        'network error',
+        'connection failed',
+        'timeout',
+        'unreachable',
+        'no internet',
+        'connection refused',
+    ],
+};
+/**
+ * Authentication error indicators
+ */
+const AUTH_ERROR_INDICATORS = ['invalid credentials', 'invalid username', 'invalid password', 'unauthorized'];
+/**
+ * Common network error message
+ */
+const NETWORK_ERROR_MESSAGE = 'Unable to connect. Please check your internet connection and try again.';
+/**
+ * Checks if the error is a network-related error
+ */
+function isNetworkError(error) {
+    // Handle fetch/network errors
+    if (error instanceof TypeError && error.message.includes('fetch')) {
+        return {
+            type: AuthErrorType.NETWORK,
+            message: NETWORK_ERROR_MESSAGE,
+            originalError: error,
+        };
+    }
+    // Handle network timeout
+    if (error instanceof Error && error.name === 'AbortError') {
+        return {
+            type: AuthErrorType.NETWORK,
+            message: 'Connection timed out. Please check your internet connection and try again.',
+            originalError: error,
+        };
+    }
+    // Handle offline detection
+    if (!navigator.onLine) {
+        return {
+            type: AuthErrorType.NETWORK,
+            message: 'You appear to be offline. Please check your internet connection and try again.',
+            originalError: error instanceof Error ? error : undefined,
+        };
+    }
+    // Handle Error objects with network indicators
+    if (error instanceof Error) {
+        const hasNetworkIndicator = NETWORK_ERROR_INDICATORS.ERROR_MESSAGES.some((indicator) => error.message.includes(indicator));
+        if (hasNetworkIndicator) {
+            return {
+                type: AuthErrorType.NETWORK,
+                message: NETWORK_ERROR_MESSAGE,
+                originalError: error,
+            };
+        }
+    }
+    // Handle string errors with network indicators
+    if (typeof error === 'string') {
+        const lowercaseError = error.toLowerCase();
+        const hasNetworkIndicator = NETWORK_ERROR_INDICATORS.STRING_INDICATORS.some((indicator) => lowercaseError.includes(indicator));
+        if (hasNetworkIndicator) {
+            return {
+                type: AuthErrorType.NETWORK,
+                message: NETWORK_ERROR_MESSAGE,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Checks if the error is an authentication-related custom error
+ */
+function isCustomAuthError(customError) {
+    if (customError.code !== 'UNKNOWN_ERROR') {
+        return false;
+    }
+    const message = customError.message.toLowerCase();
+    return AUTH_ERROR_INDICATORS.some((indicator) => message.includes(indicator));
+}
+/**
+ * Creates error info object
+ */
+function createErrorInfo(type, message, originalError) {
+    return {
+        type,
+        message,
+        originalError: originalError instanceof Error ? originalError : undefined,
+    };
+}
+/**
+ * Handles custom server error format
+ */
+function handleCustomError(error) {
+    // Handle authentication errors
+    if (isCustomAuthError(error)) {
+        return createErrorInfo(AuthErrorType.AUTHENTICATION, 'Invalid credentials. Please check your username and password.', error);
+    }
+    // Handle validation errors
+    if (error.code === 'VALIDATION_ERROR') {
+        return createErrorInfo(AuthErrorType.VALIDATION, error.message || 'Please check your input and try again.', error);
+    }
+    // For other custom errors, use the server message
+    return createErrorInfo(AuthErrorType.UNKNOWN, error.message || 'An error occurred. Please try again.', error);
+}
+/**
+ * Maps HTTP status to error type and message
+ */
+function getHttpErrorMapping(status) {
+    if (status === 401 || status === 403) {
+        return {
+            type: AuthErrorType.AUTHENTICATION,
+            message: 'Invalid credentials. Please check your username and password.',
+        };
+    }
+    if (status === 422) {
+        return {
+            type: AuthErrorType.VALIDATION,
+            message: 'Please check your input and try again.',
+        };
+    }
+    if (status === 500 || status === 502 || status === 503) {
+        return {
+            type: AuthErrorType.SERVER,
+            message: 'Server is temporarily unavailable. Please try again later.',
+        };
+    }
+    if (status >= 500) {
+        return {
+            type: AuthErrorType.SERVER,
+            message: 'Server error occurred. Please try again later.',
+        };
+    }
+    return null;
+}
+/**
+ * Handles HTTP status code errors
+ */
+function handleHttpError(httpError) {
+    const mapping = getHttpErrorMapping(httpError.status);
+    if (!mapping) {
+        return null;
+    }
+    const message = httpError.status === 422 && httpError.message ? httpError.message : mapping.message;
+    return createErrorInfo(mapping.type, message, httpError);
+}
+/**
+ * Detects the type of error and returns appropriate user-friendly message
+ */
+export function detectErrorType(error) {
+    // Check for network errors first
+    const networkError = isNetworkError(error);
+    if (networkError) {
+        return networkError;
+    }
+    // Handle custom error format
+    if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
+        const customError = error;
+        return handleCustomError(customError);
+    }
+    // Handle HTTP errors
+    if (error && typeof error === 'object' && 'status' in error) {
+        const httpError = error;
+        const httpResult = handleHttpError(httpError);
+        if (httpResult) {
+            return httpResult;
+        }
+    }
+    // Handle generic Error objects
+    if (error instanceof Error) {
+        return createErrorInfo(AuthErrorType.UNKNOWN, error.message || 'An unexpected error occurred. Please try again.', error);
+    }
+    // Fallback
+    return createErrorInfo(AuthErrorType.UNKNOWN, 'An unexpected error occurred. Please try again.');
+}

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

@@ -0,0 +1,3 @@
+export * from './Transformers';
+export * from './TokenManager';
+export * from './errorDetection';

package/lib/auth/utils/index.js

@@ -0,0 +1,3 @@
+export * from './Transformers';
+export * from './TokenManager';
+export * from './errorDetection';

package/lib/components/charts/LineGraph.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface DataPoint {
+    date: string | Date;
+    value: number;
+}
+interface LineGraphProps {
+    data: DataPoint[];
+    title?: string;
+    yAxisLabel?: string;
+    color?: string;
+    className?: string;
+    loading?: boolean;
+}
+declare const LineGraph: React.FC<LineGraphProps>;
+export default LineGraph;