saafe-redirection-flow 2.0.0 → 2.2.0

package/src/hooks/use-auto-discovery.ts

@@ -0,0 +1,226 @@
+import { useMutation } from '@tanstack/react-query'
+import { useState } from 'react'
+import { useFipStore, DiscoveredAccount } from '@/store/fip.store'
+import { useRedirectStore } from '@/store/redirect.store'
+import { useAuthStore } from '@/store/auth.store'
+import { fiTypeCategoryMap } from '@/const/fiTypeCategoryMap'
+import { accountService } from '@/services/api/account.service'
+import { ProcessedDiscoveryResult } from './use-account-discovery'
+import { getAutoDiscoveryFipIds } from '@/utils/auto-discovery'
+
+/**
+ * Hook for auto discovery - discovers accounts from all available FIPs for a category
+ */
+export function useAutoDiscovery() {
+  const { user } = useAuthStore()
+  const { groupedFips } = useFipStore()
+  const { decodedInfo } = useRedirectStore()
+  const [errorMessage, setErrorMessage] = useState<string | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+
+  const autoDiscoveryMutation = useMutation({
+    mutationFn: async (category: string): Promise<ProcessedDiscoveryResult> => {
+      if (!user?.phoneNumber) {
+        const error = new Error('Mobile number is not available')
+        setErrorMessage(error.message)
+        throw error
+      }
+
+      if (!decodedInfo?.fiuId) {
+        const error = new Error('FIU ID is not available')
+        setErrorMessage(error.message)
+        throw error
+      }
+
+      try {
+        setIsLoading(true)
+        const fiuId = decodedInfo.fiuId
+        const fiTypes = Array.isArray(decodedInfo.fiTypesRequiredForConsent)
+          ? decodedInfo.fiTypesRequiredForConsent.filter(i => 
+              fiTypeCategoryMap[category.toUpperCase()]?.includes(i)
+            )
+          : []
+
+        if (fiTypes.length === 0) {
+          // Fallback to category map if no FI types are provided
+          const categoryTypes = fiTypeCategoryMap[category.toUpperCase()]
+          if (categoryTypes) {
+            fiTypes.push(...categoryTypes)
+          }
+        }
+
+        // Get FIP IDs for auto discovery
+        const fipIds = getAutoDiscoveryFipIds(
+          category,
+          decodedInfo.fipId,
+          groupedFips
+        )
+
+        if (fipIds.length === 0) {
+          throw new Error('No FIPs available for auto discovery')
+        }
+
+        // Construct identifiers from redirect store data and FIP requirements
+        const constructIdentifiers = (fipIds: string[]) => {
+          const { decodedInfo } = useRedirectStore.getState()
+          const { fips } = useFipStore.getState()
+
+          return fipIds
+            .flatMap((fipId) => {
+              const fip = fips.find((f) => f.id === fipId)
+              return fip?.Identifiers || []
+            })
+            .reduce<{ type: string; value: string | null; categoryType: string }[]>(
+              (acc, identifier) => {
+                if (!acc.find((i) => i.type === identifier.type)) {
+                  let value: string | null = null
+                  if (identifier.type === 'PAN') {
+                    value = decodedInfo?.pan || null
+                  } else if (identifier.type === 'MOBILE') {
+                    value = decodedInfo?.phoneNumber || null
+                  } else if (identifier.type === 'DOB') {
+                    value = decodedInfo?.dob || null
+                  } else if (identifier.type === 'AADHAAR') {
+                    value = null // AADHAAR not available in decodedInfo
+                  }
+                  acc.push({ 
+                    type: identifier.type,
+                    value, 
+                    categoryType: identifier.category 
+                  })
+                }
+                return acc
+              },
+              []
+            )
+        }
+
+        const commonIdentifiers = constructIdentifiers(fipIds).filter(id => id.value !== null) as { type: string; value: string; categoryType: string; }[]
+
+        // Log the constructed identifiers for debugging
+        console.log('Auto Discovery: Constructed identifiers:', commonIdentifiers)
+
+        // Perform account discovery for all FIPs
+        const accountPromises = fipIds.map(async (fipId) => {
+          return accountService.accountDiscovery({
+            Identifiers: [...commonIdentifiers],
+            FiuId: fiuId,
+            FipId: fipId,
+            FITypes: fiTypes
+          })
+        })
+
+        // Wait for all account discovery calls to complete
+        const results = await Promise.allSettled(accountPromises)
+
+        // Process results
+        const successfulResults: { fipId: string; result: { DiscoveredAccounts: DiscoveredAccount[]; signature: string } }[] = []
+        const failedFips: string[] = []
+        const errorMessages: string[] = []
+
+        results.forEach((settledResult, index) => {
+          const fipId = fipIds[index]
+          if (settledResult.status === 'fulfilled') {
+            successfulResults.push({ fipId, result: settledResult.value })
+          } else {
+            failedFips.push(fipId)
+            const error = settledResult.reason as Error & {
+              response?: {
+                status?: number;
+                data?: { message?: string }
+              }
+            }
+            if (error?.response?.data?.message) {
+              errorMessages.push(`${fipId}: ${error.response.data.message}`)
+            } else {
+              errorMessages.push(`${fipId}: Failed to discover accounts`)
+            }
+          }
+        })
+
+        // If no successful results, throw an error
+        if (successfulResults.length === 0) {
+          const combinedError = errorMessages.join('; ')
+          setErrorMessage(combinedError)
+          throw new Error(combinedError)
+        }
+
+        // Process and merge the accounts from successful FIPs
+        const originalAccounts = successfulResults.map(({ fipId, result }) => ({
+          fipId,
+          fipName: fipId, // We'll get the actual name from the FIP data
+          DiscoveredAccounts: result.DiscoveredAccounts,
+          signature: result.signature
+        }))
+
+        // Process the accounts from successful API responses
+        const processedAccounts = originalAccounts.flatMap(fipData =>
+          fipData.DiscoveredAccounts.map((account: DiscoveredAccount) => ({
+            id: account.accRefNumber,
+            type: account.FIType,
+            maskedAccountNumber: account.maskedAccNumber,
+            bankName: fipData.fipName,
+            logoUrl: account.logoUrl,
+            isNew: false,
+            fipId: fipData.fipId
+          }))
+        )
+
+        // Group accounts by type
+        const groupedAccounts = processedAccounts.reduce((acc: ProcessedDiscoveryResult['groupedAccounts'], account) => {
+          const key = account.type
+          if (!acc[key]) {
+            acc[key] = []
+          }
+          acc[key].push(account)
+          return acc
+        }, {} as ProcessedDiscoveryResult['groupedAccounts'])
+
+        // Use the signature from the first successful result
+        const signature = successfulResults[0].result.signature
+
+        // Set partial error message if some FIPs failed
+        if (failedFips.length > 0) {
+          const partialErrorMsg = `Some providers failed to load: ${failedFips.join(', ')}`
+          setErrorMessage(partialErrorMsg)
+        } else {
+          setErrorMessage(null)
+        }
+
+        setIsLoading(false)
+        return {
+          originalAccounts,
+          accounts: processedAccounts,
+          groupedAccounts,
+          signature
+        }
+      } catch (error) {
+        setIsLoading(false)
+        const typedError = error as Error & {
+          response?: {
+            status?: number;
+            data?: { message?: string }
+          }
+        }
+
+        if (typedError.response?.status === 401) {
+          setErrorMessage('Authentication error. Please log in again.')
+        } else if (typedError.response?.status === 403) {
+          setErrorMessage("You don't have permission to discover accounts.")
+        } else if (typedError.response?.data?.message) {
+          setErrorMessage(typedError.response.data.message)
+        } else {
+          setErrorMessage('Failed to discover accounts. Please try again.')
+        }
+        throw error
+      }
+    }
+  })
+
+  return {
+    ...autoDiscoveryMutation,
+    isLoading,
+    errorMessage,
+    clearError: () => setErrorMessage(null)
+  }
+} 

package/src/index.css

@@ -50,6 +50,8 @@
 
 --surface: oklch(0.98 0.0017 247.84);
 
+--warning-primary: oklch(0.9791 0.018 78.24);
+
 }
 
 .dark {
@@ -136,6 +138,7 @@
 
 --color-surface: var(--surface);
 
+--color-warning-primary: var(--warning-primary);
 }
 
 @layer base {