@nocios/crudify-ui 1.0.80 → 1.0.82

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 export * from '@nocios/crudify-browser';
 export { default as crudify } from '@nocios/crudify-browser';
-import React from 'react';
+import React, { ReactNode } from 'react';
 
 type BoxScreenType = "login" | "signUp" | "forgotPassword" | "resetPassword" | "checkCode";
 interface CrudifyLoginConfig {
@@ -18,11 +18,19 @@ interface CrudifyLoginConfig {
 interface CrudifyLoginTranslations {
     [key: string]: string | CrudifyLoginTranslations;
 }
+interface UserLoginData {
+    token: string;
+    username?: string;
+    email?: string;
+    userId?: string;
+    profile?: any;
+    [key: string]: any;
+}
 interface CrudifyLoginProps {
     config?: CrudifyLoginConfig;
     onScreenChange?: (screen: BoxScreenType, params?: Record<string, string>) => void;
     onExternalNavigate?: (path: string) => void;
-    onLoginSuccess?: (token: string, redirectUrl?: string) => void;
+    onLoginSuccess?: (userData: UserLoginData, redirectUrl?: string) => void;
     onError?: (error: string) => void;
     initialScreen?: BoxScreenType;
     redirectUrl?: string;
@@ -34,6 +42,13 @@ interface CrudifyLoginProps {
 
 declare const CrudifyLogin: React.FC<CrudifyLoginProps>;
 
+interface UserProfileDisplayProps {
+    showExtendedData?: boolean;
+    showProfileCard?: boolean;
+    autoRefresh?: boolean;
+}
+declare const UserProfileDisplay: React.FC<UserProfileDisplayProps>;
+
 interface CrudifyApiResponse<T = unknown> {
     success: boolean;
     data?: T;
@@ -115,6 +130,619 @@ interface ValidationError {
     code: string;
 }
 
+/**
+ * Configuration interface for CrudifyDataProvider
+ * Supports multi-tenant configurations via environment variables, cookies, or direct props
+ */
+interface CrudifyConfig {
+    env?: "dev" | "stg" | "prod";
+    publicApiKey?: string;
+    loginActions?: string[];
+    appName?: string;
+    logo?: string;
+    colors?: Record<string, string>;
+}
+/**
+ * Source of configuration values for debugging and validation
+ */
+type ConfigSource = "props" | "env" | "cookies" | "default";
+/**
+ * Detailed configuration with source tracking for debugging
+ */
+interface ResolvedConfig extends Required<CrudifyConfig> {
+    configSource: Record<keyof CrudifyConfig, ConfigSource>;
+    rawConfig: Record<string, any>;
+}
+/**
+ * Configuration Manager for CrudifyDataProvider
+ *
+ * Handles configuration priority:
+ * 1. Props passed explicitly to the Provider
+ * 2. Environment variables (VITE_TEST_*)
+ * 3. Cookies (for multi-tenant)
+ * 4. Default values or error if required fields missing
+ *
+ * This ensures compatibility with both crudia-ui (cookie-based) and crudify-ui (env-based)
+ */
+declare class ConfigurationManager {
+    private static instance;
+    private resolvedConfig;
+    private configError;
+    /**
+     * Singleton pattern to ensure consistent configuration across the app
+     */
+    static getInstance(): ConfigurationManager;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    private constructor();
+    /**
+     * Resolve configuration from all sources with proper priority
+     */
+    resolveConfig(propsConfig?: Partial<CrudifyConfig>): ResolvedConfig;
+    /**
+     * Check if current configuration is still valid for the given props
+     */
+    private isConfigStillValid;
+    /**
+     * Resolve a single config value with priority and source tracking
+     */
+    private resolveValue;
+    /**
+     * Get configuration from environment variables
+     */
+    private getEnvConfig;
+    /**
+     * Get configuration from cookies (multi-tenant support)
+     */
+    private getCookieConfig;
+    /**
+     * Get the current resolved configuration
+     */
+    getConfig(): ResolvedConfig | null;
+    /**
+     * Get any configuration errors
+     */
+    getConfigError(): string | null;
+    /**
+     * Check if configuration is valid (no errors and has required fields)
+     */
+    isConfigured(): boolean;
+    /**
+     * Clear the current configuration (useful for testing or reconfiguration)
+     */
+    clearConfig(): void;
+}
+/**
+ * Singleton instance for easy access
+ */
+declare const configurationManager: ConfigurationManager;
+
+/**
+ * CrudifyInitializer handles the critical task of initializing the crudify library
+ * exactly once, preventing the "Crudify: Not initialized" and double initialization errors
+ * that occur when both crudia-ui and crudify-ui try to initialize crudify independently.
+ *
+ * This is a singleton that ensures:
+ * 1. Only one initialization attempt at a time
+ * 2. Subsequent calls wait for the first initialization to complete
+ * 3. Proper error handling and recovery
+ * 4. Verification that crudify methods are available after initialization
+ * 5. Thread-safe initialization in React's concurrent mode
+ */
+declare class CrudifyInitializer {
+    private static instance;
+    private state;
+    /**
+     * Singleton pattern to ensure global initialization coordination
+     */
+    static getInstance(): CrudifyInitializer;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    private constructor();
+    /**
+     * Initialize crudify with the given configuration
+     * This method is idempotent and thread-safe
+     */
+    initialize(config: CrudifyConfig): Promise<void>;
+    /**
+     * Perform the actual initialization process
+     */
+    private performInitialization;
+    /**
+     * Verify that crudify is properly initialized by checking core methods
+     */
+    private verifyInitialization;
+    /**
+     * Check if the given configuration is the same as the current one
+     */
+    private isConfigurationSame;
+    /**
+     * Reset the initialization state (useful for testing or configuration changes)
+     */
+    reset(): void;
+    /**
+     * Get the current initialization status
+     */
+    getStatus(): {
+        isInitialized: boolean;
+        isInitializing: boolean;
+        initializationError: string | null;
+        config: CrudifyConfig | null;
+    };
+    /**
+     * Check if crudify is ready to use
+     */
+    isReady(): boolean;
+    /**
+     * Get the current initialization error, if any
+     */
+    getError(): string | null;
+    /**
+     * Force re-initialization (useful when configuration changes)
+     */
+    reinitialize(config: CrudifyConfig): Promise<void>;
+    /**
+     * Check if initialization is currently in progress
+     */
+    isInitializing(): boolean;
+    /**
+     * Wait for any ongoing initialization to complete
+     */
+    waitForInitialization(): Promise<void>;
+}
+/**
+ * Singleton instance for easy access
+ */
+declare const crudifyInitializer: CrudifyInitializer;
+
+/**
+ * Enhanced JWT payload interface with Cognito-specific fields
+ */
+interface JWTPayload$1 extends JwtPayload {
+    "cognito:username"?: string;
+}
+/**
+ * TokenManager handles all JWT token operations with automatic synchronization
+ * between storage and crudify library. It maintains 100% compatibility with
+ * the existing crudia-ui storage patterns while providing enhanced functionality.
+ *
+ * Key features:
+ * - Automatic storage <-> crudify synchronization
+ * - Token validation and expiration checking
+ * - Migration support from localStorage to sessionStorage
+ * - Backward compatibility with existing token storage keys
+ * - Automatic cleanup of expired tokens
+ */
+declare class TokenManager {
+    private static instance;
+    private readonly TOKEN_KEY;
+    private tokenCache;
+    private parsedTokenCache;
+    private expirationCheckInterval;
+    private storageEventListener;
+    /**
+     * Singleton pattern to ensure consistent token management
+     */
+    static getInstance(): TokenManager;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    private constructor();
+    /**
+     * Initialize the token manager with storage synchronization
+     */
+    private initializeTokenManager;
+    /**
+     * Migrate tokens from localStorage to sessionStorage for better security
+     * This ensures compatibility with older implementations
+     */
+    private migrateFromLocalStorage;
+    /**
+     * Load token from storage and synchronize with crudify
+     */
+    private loadTokenFromStorage;
+    /**
+     * Set up automatic token expiration checking
+     */
+    private setupExpirationCheck;
+    /**
+     * Set up storage event listener for cross-tab synchronization
+     */
+    private setupStorageListener;
+    /**
+     * Set a new JWT token with automatic synchronization
+     */
+    setToken(token: string | null): void;
+    /**
+     * Get the current JWT token
+     */
+    getToken(): string | null;
+    /**
+     * Parse the current JWT token
+     */
+    parseToken(token?: string | null): JWTPayload$1 | null;
+    /**
+     * Check if a token is valid (properly formatted and not expired)
+     */
+    isTokenValid(token?: string | null): boolean;
+    /**
+     * Get token expiration time as Date object
+     */
+    getTokenExpiration(): Date | null;
+    /**
+     * Clear the current token from all storages and crudify
+     */
+    clearToken(): void;
+    /**
+     * Synchronize token with crudify library
+     */
+    private syncTokenWithCrudify;
+    /**
+     * Refresh token (placeholder for future implementation)
+     */
+    refreshToken(): Promise<void>;
+    /**
+     * Get user information from the current token
+     */
+    getUserInfo(): {
+        email: string | null;
+        userId: string | null;
+        userIdentifier: string | null;
+        username: string | null;
+    };
+    /**
+     * Check if user is currently authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get time until token expires in minutes
+     */
+    getTimeUntilExpiration(): number | null;
+    /**
+     * Cleanup resources (call when the component unmounts)
+     */
+    cleanup(): void;
+    /**
+     * Get debug information about the current token state
+     */
+    getDebugInfo(): {
+        hasToken: boolean;
+        tokenLength: number;
+        isValid: boolean;
+        isAuthenticated: boolean;
+        expiration: string | null;
+        minutesUntilExpiry: number | null;
+        userInfo: {
+            email: string | null;
+            userId: string | null;
+            userIdentifier: string | null;
+            username: string | null;
+        };
+        parsedTokenKeys: string[];
+    };
+}
+/**
+ * Singleton instance for easy access
+ */
+declare const tokenManager: TokenManager;
+
+/**
+ * Context state interface for CrudifyDataProvider
+ */
+interface CrudifyDataContextState {
+    config: ResolvedConfig | null;
+    isConfigured: boolean;
+    configError: string | null;
+    configSource: string;
+    isInitialized: boolean;
+    isInitializing: boolean;
+    initializationError: string | null;
+    isAuthenticated: boolean;
+    token: string | null;
+    user: JWTPayload$1 | null;
+    tokenExpiration: Date | null;
+    setToken: (token: string | null) => void;
+    logout: () => void;
+    refreshConfig: () => void;
+    reinitialize: () => Promise<void>;
+    getDebugInfo: () => Record<string, any>;
+}
+/**
+ * Props for CrudifyDataProvider
+ */
+interface CrudifyDataProviderProps {
+    children: ReactNode;
+    env?: "dev" | "stg" | "prod";
+    publicApiKey?: string;
+    loginActions?: string[];
+    appName?: string;
+    logo?: string;
+    colors?: Record<string, string>;
+}
+/**
+ * CrudifyDataProvider - The unified provider that encapsulates all crudify functionality
+ *
+ * This provider replaces the fragmented implementations in both crudia-ui and crudify-ui
+ * with a single, robust solution that handles:
+ *
+ * 1. Configuration management (props > env vars > cookies)
+ * 2. Crudify initialization (single, thread-safe initialization)
+ * 3. JWT token management (compatible with existing storage patterns)
+ * 4. Error handling and recovery
+ * 5. Cross-tab synchronization
+ *
+ * It maintains 100% backward compatibility with crudia-ui while providing
+ * enhanced functionality for crudify-ui.
+ */
+declare const CrudifyDataProvider: React.FC<CrudifyDataProviderProps>;
+/**
+ * Hook to use the CrudifyDataProvider context
+ */
+declare const useCrudifyDataContext: () => CrudifyDataContextState;
+
+/**
+ * Return type for useCrudifyAuth hook
+ */
+interface UseCrudifyAuthReturn {
+    isAuthenticated: boolean;
+    loading: boolean;
+    error: string | null;
+    token: string | null;
+    user: JWTPayload$1 | null;
+    tokenExpiration: Date | null;
+    setToken: (token: string | null) => void;
+    logout: () => void;
+    refreshToken?: () => Promise<void>;
+}
+/**
+ * useCrudifyAuth - Simplified hook for authentication state management
+ *
+ * This hook provides a clean interface for managing authentication state
+ * within the CrudifyDataProvider system. It abstracts away the complexity
+ * of token management, storage synchronization, and crudify integration.
+ *
+ * Features:
+ * - Real-time authentication status
+ * - Automatic token validation
+ * - Cross-tab synchronization
+ * - Simple login/logout actions
+ * - JWT payload access
+ *
+ * @example
+ * ```tsx
+ * function LoginComponent() {
+ *   const { isAuthenticated, login, logout, user } = useCrudifyAuth();
+ *
+ *   if (isAuthenticated) {
+ *     return (
+ *       <div>
+ *         Welcome {user?.email}!
+ *         <button onClick={logout}>Logout</button>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return <LoginForm onLogin={login} />;
+ * }
+ * ```
+ */
+declare const useCrudifyAuth: () => UseCrudifyAuthReturn;
+
+/**
+ * Extended user data with formatted information
+ */
+interface ExtendedUserData {
+    fullProfile: UserProfile | null;
+    totalFields: number;
+    displayData: Record<string, any>;
+}
+/**
+ * Return type for useCrudifyUser hook
+ */
+interface UseCrudifyUserReturn {
+    userEmail: string | null;
+    userId: string | null;
+    userIdentifier: string | null;
+    userProfile: UserProfile | null;
+    profileLoading: boolean;
+    profileError: string | null;
+    extendedData: ExtendedUserData;
+    refreshProfile: () => Promise<void>;
+    clearProfile: () => void;
+}
+/**
+ * Options for useCrudifyUser hook
+ */
+interface UseCrudifyUserOptions {
+    autoFetch?: boolean;
+    retryOnError?: boolean;
+    maxRetries?: number;
+}
+/**
+ * useCrudifyUser - Comprehensive user data management hook
+ *
+ * This hook provides complete user data management by combining:
+ * 1. JWT token data (basic user information)
+ * 2. Database profile data (complete user profile)
+ * 3. Extended formatted data for display
+ *
+ * It automatically fetches user profile data from the database when
+ * the user is authenticated and provides intelligent caching,
+ * error handling, and retry mechanisms.
+ *
+ * Features:
+ * - Automatic profile fetching when authenticated
+ * - Intelligent caching and deduplication
+ * - Retry mechanism for network errors
+ * - Cross-tab synchronization
+ * - Extended data formatting for easy display
+ * - Proper cleanup and memory management
+ *
+ * @example
+ * ```tsx
+ * function UserProfilePage() {
+ *   const {
+ *     userEmail,
+ *     userProfile,
+ *     profileLoading,
+ *     extendedData,
+ *     refreshProfile
+ *   } = useCrudifyUser({ autoFetch: true });
+ *
+ *   if (profileLoading) return <LoadingSpinner />;
+ *
+ *   return (
+ *     <div>
+ *       <h1>Welcome {userProfile?.fullName || userEmail}</h1>
+ *       <p>Total fields: {extendedData.totalFields}</p>
+ *       <button onClick={refreshProfile}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useCrudifyUser: (options?: UseCrudifyUserOptions) => UseCrudifyUserReturn;
+
+/**
+ * Return type for useCrudifyData hook
+ */
+interface UseCrudifyDataReturn {
+    readItems: (moduleKey: string, filter?: object, options?: any) => Promise<CrudifyApiResponse>;
+    readItem: (moduleKey: string, filter: object, options?: any) => Promise<CrudifyApiResponse>;
+    createItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
+    updateItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
+    deleteItem: (moduleKey: string, id: string, options?: any) => Promise<CrudifyApiResponse>;
+    transaction: (operations: any[], options?: any) => Promise<CrudifyApiResponse>;
+    login: (email: string, password: string) => Promise<CrudifyApiResponse>;
+    isInitialized: boolean;
+    isInitializing: boolean;
+    initializationError: string | null;
+    isReady: () => boolean;
+    waitForReady: () => Promise<void>;
+}
+/**
+ * useCrudifyData - Comprehensive hook for crudify operations
+ *
+ * This hook provides a clean interface for all crudify database operations
+ * with automatic initialization checking, error handling, and loading states.
+ * It ensures that all operations are only executed when crudify is properly
+ * initialized and configured.
+ *
+ * Features:
+ * - Automatic initialization checking
+ * - Type-safe CRUD operations
+ * - Transaction support
+ * - Login operations
+ * - Ready state management
+ * - Proper error handling
+ *
+ * All operations will throw an error if crudify is not properly initialized,
+ * ensuring data integrity and preventing silent failures.
+ *
+ * @example
+ * ```tsx
+ * function DataComponent() {
+ *   const {
+ *     readItems,
+ *     createItem,
+ *     isInitialized,
+ *     isReady
+ *   } = useCrudifyData();
+ *
+ *   const loadUsers = async () => {
+ *     if (!isReady()) {
+ *       console.warn("Crudify not ready yet");
+ *       return;
+ *     }
+ *
+ *     try {
+ *       const response = await readItems("users", { limit: 10 });
+ *       if (response.success) {
+ *         console.log("Users:", response.data);
+ *       }
+ *     } catch (error) {
+ *       console.error("Error loading users:", error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={loadUsers} disabled={!isInitialized}>
+ *         Load Users
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useCrudifyData: () => UseCrudifyDataReturn;
+
+/**
+ * Return type for useCrudifyConfig hook
+ */
+interface UseCrudifyConfigReturn {
+    config: ResolvedConfig | null;
+    isConfigured: boolean;
+    configError: string | null;
+    configSource: string;
+    rawConfig: Record<string, any>;
+    refreshConfig: () => void;
+    getDebugInfo: () => Record<string, any>;
+}
+/**
+ * useCrudifyConfig - Configuration access and debugging hook
+ *
+ * This hook provides access to the current crudify configuration,
+ * including source tracking for debugging and configuration validation.
+ * It's particularly useful for development and troubleshooting
+ * configuration issues across different environments.
+ *
+ * Features:
+ * - Current configuration access
+ * - Source tracking (props, env, cookies, defaults)
+ * - Configuration validation status
+ * - Debug information for troubleshooting
+ * - Configuration refresh capability
+ *
+ * @example
+ * ```tsx
+ * function ConfigDebugComponent() {
+ *   const {
+ *     config,
+ *     isConfigured,
+ *     configError,
+ *     configSource,
+ *     getDebugInfo
+ *   } = useCrudifyConfig();
+ *
+ *   if (!isConfigured) {
+ *     return (
+ *       <div>
+ *         <h3>Configuration Error</h3>
+ *         <p>{configError}</p>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h3>Current Configuration</h3>
+ *       <p>Environment: {config?.env}</p>
+ *       <p>App Name: {config?.appName}</p>
+ *       <p>Source: {configSource}</p>
+ *       <pre>{JSON.stringify(getDebugInfo(), null, 2)}</pre>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useCrudifyConfig: () => UseCrudifyConfigReturn;
+
 interface UseUserProfileOptions {
     autoFetch?: boolean;
     retryOnError?: boolean;
@@ -124,6 +752,7 @@ interface UseUserProfileReturn {
     userProfile: UserProfile | null;
     loading: boolean;
     error: string | null;
+    extendedData: Record<string, any>;
     refreshProfile: () => Promise<void>;
     clearProfile: () => void;
 }
@@ -218,4 +847,4 @@ declare function parseJavaScriptError(error: unknown): ParsedError;
  */
 declare function handleCrudifyError(error: unknown): ParsedError[];
 
-export { type ApiError, type BoxScreenType, type CrudifyApiResponse, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, type CrudifyLoginTranslations, type CrudifyTransactionResponse, ERROR_CODES, ERROR_SEVERITY_MAP, type ErrorCode, type ErrorSeverity, type ForgotPasswordRequest, type JwtPayload, type LoginRequest, type LoginResponse, type ParsedError, type ResetPasswordRequest, type TransactionResponseData, type UserProfile, type ValidateCodeRequest, type ValidationError, decodeJwtSafely, getCookie, getCurrentUserEmail, getErrorMessage, handleCrudifyError, isTokenExpired, parseApiError, parseJavaScriptError, parseTransactionError, secureLocalStorage, secureSessionStorage, useCrudifyLogin, useUserProfile };
+export { type ApiError, type BoxScreenType, type CrudifyApiResponse, type CrudifyConfig, type CrudifyDataContextState, CrudifyDataProvider, type CrudifyDataProviderProps, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, type CrudifyLoginTranslations, type CrudifyTransactionResponse, ERROR_CODES, ERROR_SEVERITY_MAP, type ErrorCode, type ErrorSeverity, type ExtendedUserData, type ForgotPasswordRequest, type JWTPayload$1 as JWTPayload, type JwtPayload, type LoginRequest, type LoginResponse, type ParsedError, type ResetPasswordRequest, type ResolvedConfig, type TransactionResponseData, type UseCrudifyAuthReturn, type UseCrudifyConfigReturn, type UseCrudifyDataReturn, type UseCrudifyUserOptions, type UseCrudifyUserReturn, type UserProfile, UserProfileDisplay, type ValidateCodeRequest, type ValidationError, configurationManager, crudifyInitializer, decodeJwtSafely, getCookie, getCurrentUserEmail, getErrorMessage, handleCrudifyError, isTokenExpired, parseApiError, parseJavaScriptError, parseTransactionError, secureLocalStorage, secureSessionStorage, tokenManager, useCrudifyAuth, useCrudifyConfig, useCrudifyData, useCrudifyDataContext, useCrudifyLogin, useCrudifyUser, useUserProfile };