@finspringinnovations/fdsdk 0.0.1

package/src/components/ValidationMessage.tsx

@@ -0,0 +1,134 @@
+import React from 'react';
+import { View, Text, StyleSheet, Image } from 'react-native';
+import Icon from 'react-native-vector-icons/Ionicons';
+import { base64Images } from '../constants/strings/base64Images';
+import { useColors } from '../theme/ThemeContext';
+
+export type MessageType = 'error' | 'success' | 'loading';
+
+export interface ValidationMessageProps {
+    type: MessageType;
+    message: string;
+    visible?: boolean;
+}
+
+const ValidationMessage: React.FC<ValidationMessageProps> = ({
+    type,
+    message,
+    visible = true,
+}) => {
+    const colors = useColors();
+    const styles = createStyles(colors);
+
+    if (!visible || !message) return null;
+
+    const getIconName = (): string => {
+        switch (type) {
+            case 'error':
+                return 'warning';
+            case 'success':
+                return 'checkmark-circle';
+            case 'loading':
+                return 'time';
+            default:
+                return 'information-circle';
+        }
+    };
+
+    const getIconColor = (): string => {
+        switch (type) {
+            case 'error':
+                return colors.error;
+            case 'success':
+                return colors.success;
+            case 'loading':
+                return colors.primary;
+            default:
+                return colors.textLight;
+        }
+    };
+
+    const getTextStyle = () => {
+        switch (type) {
+            case 'error':
+                return styles.errorText;
+            case 'success':
+                return styles.successText;
+            case 'loading':
+                return styles.loadingText;
+            default:
+                return styles.defaultText;
+        }
+    };
+
+    return (
+        <View style={[styles.container, type === 'loading' && styles.loadingContainer]}>
+            {type === 'success' ? (
+                <Image
+                    source={{ uri: base64Images.greenTick }}
+                    style={styles.imageIcon}
+                    resizeMode="contain"
+                />
+            ) : type === 'error' ? (
+                <Image
+                    source={{ uri: base64Images.error }}
+                    style={styles.imageIcon}
+                    resizeMode="contain"
+                />
+            ) : (
+                <Icon
+                    name={getIconName()}
+                    size={16}
+                    color={getIconColor()}
+                    style={styles.icon}
+                />
+            )}
+            <Text style={getTextStyle()}>{message}</Text>
+        </View>
+    );
+};
+
+const createStyles = (colors: any) => StyleSheet.create({
+    container: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        marginTop: -8,
+        marginBottom: 16,
+    },
+    loadingContainer: {
+        justifyContent: 'center',
+    },
+    icon: {
+        marginRight: 6,
+    },
+    imageIcon: {
+        width: 16,
+        height: 16,
+        marginRight: 6,
+    },
+    errorText: {
+        fontSize: 12,
+        color: colors.error,
+        fontWeight: '500',
+        flex: 1,
+    },
+    successText: {
+        fontSize: 12,
+        color: colors.success,
+        fontWeight: '500',
+        flex: 1,
+    },
+    loadingText: {
+        fontSize: 12,
+        color: colors.primary,
+        fontWeight: '500',
+    },
+    defaultText: {
+        fontSize: 12,
+        color: colors.textLight,
+        fontWeight: '500',
+        flex: 1,
+    },
+});
+
+export default ValidationMessage;

package/src/components/index.tsx

@@ -0,0 +1,47 @@
+export { default as Header } from './Header';
+export { default as ActiveFDCard } from './ActiveFDCard';
+export { default as FDCard } from './FDCard';
+export { default as PendingFDBottomSheet } from './PendingFDBottomSheet';
+export { default as AmountInput } from './AmountInput';
+export { default as DropdownSelector } from './DropdownSelector';
+export { default as InterestRateCard } from './InterestRateCard';
+export { default as CheckboxOption } from './CheckboxOption';
+export { default as TrustBox } from './TrustBox';
+export { default as FAQItem } from './FAQItem';
+export { default as CompanyHeader } from './CompanyHeader';
+export { default as InfoBox } from './InfoBox';
+
+// New Aadhaar Verification Components
+export { default as AadhaarInput } from './AadhaarInput';
+export { default as OTPInput } from './OTPInput';
+export { default as ValidationMessage } from './ValidationMessage';
+export { default as ActionButton } from './ActionButton';
+export { default as ScreenHeader } from './ScreenHeader';
+
+// Reusable Form Components
+export { default as TextFieldWithLabel } from './TextFieldWithLabel';
+export type { TextFieldWithLabelProps, BaseTextFieldProps } from './TextFieldWithLabel';
+
+// Payment Components
+export { default as PaymentDetailsCard } from './PaymentDetailsCard';
+export type { PaymentDetailsCardProps } from './PaymentDetailsCard';
+
+// Form Components
+export { default as FormDropdown } from './FormDropdown';
+export type { FormDropdownProps } from './FormDropdown';
+export { default as FormSection } from './FormSection';
+export type { FormSectionProps } from './FormSection';
+
+// Status and Display Components
+export { default as StatusDisplay } from './StatusDisplay';
+export type { StatusDisplayProps } from './StatusDisplay';
+export { default as LoadingIndicator } from './LoadingIndicator';
+export type { LoadingIndicatorProps } from './LoadingIndicator';
+export { default as ErrorDisplay } from './ErrorDisplay';
+export type { ErrorDisplayProps } from './ErrorDisplay';
+export { default as EmptyState } from './EmptyState';
+export type { EmptyStateProps } from './EmptyState';
+
+// IFSC Search Components
+export { default as IFSCSearchResultCard } from './IFSCSearchResultCard';
+export type { IFSCSearchResultCardProps } from './IFSCSearchResultCard';

package/src/config/apiConfig.ts

@@ -0,0 +1,217 @@
+// API Configuration with values from main app
+import 'react-native-get-random-values';
+import { getEnvironmentData } from './appDataConfig';
+
+
+export const logEnvLoaderValues = () => {
+    // Environment values logging removed for security
+};
+
+export type Environment = 'development' | 'staging' | 'production';
+
+// Secure API configuration interface
+export interface ApiConfig {
+    baseUrl: string;
+    timeout: number;
+    retryAttempts: number;
+    enableEncryption: boolean;
+    enableLogging: boolean;
+    headers: Record<string, string>;
+    // New encryption toggle parameter
+    allowEncryptionToggle?: boolean;
+}
+
+// Environment detection - using hardcoded default
+export const getEnvironment = (): Environment => {
+    // Default to development for hardcoded configuration
+    return 'development';
+};
+
+// Common configuration shared by all environments
+const COMMON_CONFIG = {
+    timeout: 60000,
+    retryAttempts: 3,
+    enableEncryption: true,
+    enableLogging: true,
+    allowEncryptionToggle: true,
+    headersBase: {
+        'X-Client-Version': '1.0.0',
+    },
+};
+
+
+const API_ENDPOINTS = {
+    development: {
+        ...COMMON_CONFIG,
+        baseUrl: '',
+        headers: {
+            ...COMMON_CONFIG.headersBase,
+            'X-Environment': 'development',
+            'X-API-Key': '',
+        },
+    }
+} as const;
+
+// Get API configuration for current environment
+export const getApiConfig = (env?: Environment): ApiConfig => {
+    // Get environment data from main app first
+    const environmentData = getEnvironmentData();
+
+    // Use environment from EnvironmentData if available, otherwise use parameter or default
+    // const currentEnv = env || environmentData?.environment || getEnvironment();
+    const config = API_ENDPOINTS.development;
+
+    // Create a new config object to avoid read-only issues
+    let finalConfig = { ...config };
+
+    // Override configuration with values from main app if available
+    if (environmentData) {
+        // Override base URL if provided by main app
+        if (environmentData.apiBaseUrl) {
+            // finalConfig.baseUrl = environmentData.apiBaseUrl as any;
+            finalConfig = { ...finalConfig, baseUrl: environmentData.apiBaseUrl as any };
+        }
+
+        // Override API key if provided by main app
+        if (environmentData.apiKey) {
+            finalConfig.headers = { ...finalConfig.headers, 'X-API-Key': environmentData.apiKey as any };
+        }
+
+        // Override environment if provided by main app
+        if (environmentData.environment) {
+            finalConfig.headers = { ...finalConfig.headers, 'X-Environment': environmentData.environment as any };
+        }
+    }
+
+    // Use secure logger for API configuration logging
+
+    // Validate configuration
+    if (!finalConfig.baseUrl) {
+        throw new Error(`Missing API base URL `);
+    }
+
+    return {
+        ...finalConfig,
+        baseUrl: sanitizeUrl(finalConfig.baseUrl),
+    };
+};
+
+// Sanitize and validate URL
+const sanitizeUrl = (url: string): string => {
+    if (!url || typeof url !== 'string') {
+        throw new Error(`Invalid API URL: ${url}`);
+    }
+
+    // Trim leading and trailing spaces
+    let sanitized = url.trim();
+
+    // Basic URL validation - check if it starts with http:// or https://
+    if (!sanitized.match(/^https?:\/\//)) {
+        throw new Error(`Invalid API URL format: ${sanitized}`);
+    }
+
+    // Ensure HTTPS in production
+    if (getEnvironment() === 'production' && !sanitized.startsWith('https://')) {
+        throw new Error('Production API must use HTTPS');
+    }
+
+    // Remove trailing slash
+    return sanitized.replace(/\/$/, '');
+};
+
+// Get secure headers for API requests
+export const getSecureHeaders = (env?: Environment): Record<string, string> => {
+    const config = getApiConfig(env);
+    //const currentEnv = env || getEnvironment();
+
+    return {
+        ...config.headers,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': `ShriramSDK/'1.0.0'`,
+        'X-Timestamp': Date.now().toString(),
+        'X-Request-ID': generateRequestId(),
+    };
+};
+
+// Generate unique request ID
+const generateRequestId = (): string => {
+    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+};
+
+// Validate environment configuration
+export const validateApiConfig = (config: ApiConfig): boolean => {
+    const errors: string[] = [];
+
+    if (!config.baseUrl) {
+        errors.push('Base URL is required');
+    }
+
+    if (config.timeout < 5000) {
+        errors.push('Timeout should be at least 5 seconds');
+    }
+
+    if (config.retryAttempts < 0 || config.retryAttempts > 5) {
+        errors.push('Retry attempts should be between 0 and 5');
+    }
+
+    // Validate URL format without using new URL (React Native compatible)
+    if (config.baseUrl && !config.baseUrl.match(/^https?:\/\//)) {
+        errors.push('Invalid base URL format - must start with http:// or https://');
+    }
+
+    if (errors.length > 0) {
+        return false;
+    }
+
+    return true;
+};
+
+// Get environment-specific configuration
+export const getEnvironmentConfig = () => {
+    const env = getEnvironment();
+    const config = getApiConfig(env);
+
+    return {
+        environment: env,
+        config,
+        isProduction: env === 'production',
+        isDevelopment: env === 'development',
+        isStaging: env === 'staging',
+    };
+};
+
+// Debug configuration (works in all environments now)
+export const debugApiConfig = (): void => {
+    // API Configuration debug complete
+};
+
+// New utility to help clients debug 403 errors
+export const debugApiCall = (endpoint: string, method: string = 'GET') => {
+    const config = getApiConfig();
+    const headers = getSecureHeaders();
+
+    // API Call debug complete
+
+    return {
+        url: `${config.baseUrl || ''}/${endpoint}`,
+        headers,
+        environment: getEnvironment(),
+        encryptionEnabled: config.enableEncryption,
+        hasApiKey: !!headers['X-API-Key']
+    };
+};
+
+// Environment logging utility
+export const logEnvironmentInfo = (): void => {
+    // Environment logging removed for security
+};
+
+
+// Function to log environment details (can be called from anywhere)
+export const logEnvironmentDetails = () => {
+    // Environment details logging removed for security
+};
+
+// Export default configuration
+export default getApiConfig;

package/src/config/appDataConfig.ts

@@ -0,0 +1,279 @@
+// AppData Configuration - Data received from main app when SDK starts
+
+export interface EnvironmentData {
+    environment: string;
+    apiBaseUrl?: string;
+    apiKey?: string;
+    encryptionKey?: string;
+    enableLogging?: boolean;
+}
+
+export interface AppData {
+    // Required user identification fields
+    id: string; // Required: User ID from main app
+    name: string; // Required: User full name
+    dob: string; // Required: Date of birth in YYYY-MM-DD format
+    gender: string; // Required: Male, Female, Other
+    mobNo: string; // Required: Mobile number (10 digits)
+    email: string; // Required: Email address
+    panNumber: string; // Required: PAN number from main app
+
+    // Optional fields - can be collected in SDK if not provided
+    address?: string;
+    area?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    pinCode?: string;
+    accountNo?: string;
+    nameOfBank?: string;
+    ifsc?: string;
+    typeOfAccount?: string; // Optional: Savings, Current, Fixed Deposit, Recurring Deposit
+    maritalStatus?: string; // Optional: Single, Married, Divorced, Widowed
+    userReferenceId?: string; // Optional: User reference ID from main app
+    eventNotifyUrl?: string; // Optional webhook/callback URL for SDK events
+}
+
+// Global app data storage
+let globalAppData: AppData | null = null;
+
+// Global environment data storage
+let globalEnvironmentData: EnvironmentData | null = null;
+
+/**
+ * Initialize the SDK with app data from the main application
+ * This should be called when the SDK starts
+ */
+export const initializeSDK = (appData: AppData, onValidationError?: (errors: string[]) => void): void => {
+    // Validate required user identification fields
+    const requiredFields = [
+        { field: 'id', label: 'User ID' },
+        { field: 'name', label: 'User Name' },
+        { field: 'dob', label: 'Date of Birth' },
+        { field: 'gender', label: 'Gender' },
+        { field: 'mobNo', label: 'Mobile Number' },
+        { field: 'email', label: 'Email' },
+        { field: 'panNumber', label: 'PAN Number' },
+    ];
+
+    const missingFields: string[] = [];
+
+    requiredFields.forEach(({ field, label }) => {
+        const value = (appData as any)[field];
+        if (!value || (typeof value === 'string' && !value.trim())) {
+            missingFields.push(label);
+        }
+    });
+
+    // If required fields are missing, call error handler
+    if (missingFields.length > 0) {
+        const errorMessage = `Missing required user information from main app:\n${missingFields.join(', ')}`;
+
+        if (onValidationError) {
+            onValidationError(missingFields);
+        }
+
+        throw new Error(errorMessage);
+    }
+
+    // Validate all fields
+    const validation = validateAppData(appData);
+    if (!validation.isValid) {
+        if (onValidationError) {
+            onValidationError(validation.errors);
+        }
+
+        throw new Error(`App data validation failed: ${validation.errors.join(', ')}`);
+    }
+
+    globalAppData = appData;
+
+    // SDK initialization started
+    try {
+        // logging removed
+    } catch { }
+
+    // Import and call environment logging
+    import('./apiConfig').then(({ logEnvironmentInfo }) => {
+        logEnvironmentInfo();
+    });
+};
+
+/**
+ * Initialize the SDK with environment configuration from the main application
+ * This should be called to configure SDK environment settings
+ */
+export const initializeEnvironment = (environmentData: EnvironmentData): void => {
+    globalEnvironmentData = environmentData;
+
+    // Environment initialization started
+    try {
+        // logging removed
+    } catch { }
+
+    // Environment initialized
+};
+
+/**
+ * Get the current app data
+ */
+export const getAppData = (): AppData | null => {
+    return globalAppData;
+};
+
+/**
+ * Get the current environment data
+ */
+export const getEnvironmentData = (): EnvironmentData | null => {
+    return globalEnvironmentData;
+};
+
+/**
+ * Check if SDK is initialized with app data
+ */
+export const isSDKInitialized = (): boolean => {
+    return globalAppData !== null;
+};
+
+/**
+ * Check if environment is initialized
+ */
+export const isEnvironmentInitialized = (): boolean => {
+    return globalEnvironmentData !== null;
+};
+
+/**
+ * Get specific user information for API requests
+ */
+export const getUserInfoForAPI = () => {
+    if (!globalAppData) {
+        throw new Error('SDK not initialized. Call initializeSDK() first.');
+    }
+
+    return {
+        id: globalAppData.id,
+        name: globalAppData.name,
+        dob: globalAppData.dob,
+        gender: globalAppData.gender,
+        panNumber: globalAppData.panNumber,
+        mobileNumber: globalAppData.mobNo,
+        email: globalAppData.email,
+        eventNotifyUrl: globalAppData.eventNotifyUrl,
+        userReferenceId: globalAppData.id, // Use userReferenceId or fallback to id
+        address: {
+            line1: globalAppData.address,
+            area: globalAppData.area,
+            city: globalAppData.city,
+            state: globalAppData.state,
+            country: globalAppData.country,
+            pinCode: globalAppData.pinCode,
+        },
+        bankDetails: {
+            accountNumber: globalAppData.accountNo,
+            bankName: globalAppData.nameOfBank,
+            ifsc: globalAppData.ifsc,
+            accountType: globalAppData.typeOfAccount,
+        },
+        maritalStatus: globalAppData.maritalStatus,
+    };
+};
+
+/**
+ * Get user demographics for interest rate calculations
+ */
+export const getUserDemographics = () => {
+    if (!globalAppData) {
+        throw new Error('SDK not initialized. Call initializeSDK() first.');
+    }
+
+    // Calculate age from DOB
+    const calculateAge = (dob: string): number => {
+        const today = new Date();
+        const birthDate = new Date(dob);
+        let age = today.getFullYear() - birthDate.getFullYear();
+        const monthDiff = today.getMonth() - birthDate.getMonth();
+
+        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
+            age--;
+        }
+
+        return age;
+    };
+
+    const age = calculateAge(globalAppData.dob);
+    const isSeniorCitizen = age >= 60;
+    const isWomenDepositor = globalAppData.gender === 'Female' || globalAppData.gender === 'female';
+
+    return {
+        age,
+        isSeniorCitizen,
+        isWomenDepositor,
+        gender: globalAppData.gender,
+        maritalStatus: globalAppData.maritalStatus,
+        dob: globalAppData.dob,
+    };
+};
+
+/**
+ * Validate app data
+ */
+export const validateAppData = (appData: AppData): { isValid: boolean; errors: string[] } => {
+    const errors: string[] = [];
+
+    // Required fields validation
+    if (!appData.id?.trim()) errors.push('ID is required');
+    if (!appData.name?.trim()) errors.push('Name is required');
+    if (!appData.dob?.trim()) errors.push('Date of birth is required');
+    if (!appData.gender) errors.push('Gender is required');
+    if (!appData.mobNo?.trim()) errors.push('Mobile number is required');
+    if (!appData.email?.trim()) errors.push('Email is required');
+    if (!appData.panNumber?.trim()) errors.push('PAN number is required');
+
+    // Format validation (only if fields are provided)
+    if (appData.dob && !/^\d{4}-\d{2}-\d{2}$/.test(appData.dob)) {
+        errors.push('Date of birth must be in YYYY-MM-DD format');
+    }
+
+    if (appData.panNumber && !/^[A-Z]{5}[0-9]{4}[A-Z]{1}$/.test(appData.panNumber)) {
+        errors.push('PAN number must be in valid format (e.g., ABCDE1234F)');
+    }
+
+    if (appData.mobNo && !/^[6-9]\d{9}$/.test(appData.mobNo)) {
+        errors.push('Mobile number must be 10 digits starting with 6-9');
+    }
+
+    if (appData.email && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(appData.email)) {
+        errors.push('Email must be in valid format');
+    }
+
+    if (appData.ifsc && appData.ifsc.trim() && !/^[A-Z]{4}0[A-Z0-9]{6}$/.test(appData.ifsc)) {
+        errors.push('IFSC code must be in valid format (e.g., SBIN0001234)');
+    }
+
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+};
+
+/**
+ * Clear app data (for testing or logout scenarios)
+ */
+export const clearAppData = (): void => {
+    globalAppData = null;
+};
+
+/**
+ * Clear environment data (for testing or logout scenarios)
+ */
+export const clearEnvironmentData = (): void => {
+    globalEnvironmentData = null;
+};
+
+/**
+ * Clear all data (app data and environment data)
+ */
+export const clearAllData = (): void => {
+    globalAppData = null;
+    globalEnvironmentData = null;
+};