@quiltt/react 4.3.3 → 4.4.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @quiltt/react
 
+## 4.4.0
+
+### Minor Changes
+
+- [#378](https://github.com/quiltt/quiltt-js/pull/378) [`0af4e66`](https://github.com/quiltt/quiltt-js/commit/0af4e6622d1542e0c0c02ac7e897e3e4f9219cbd) Thanks [@sirwolfgang](https://github.com/sirwolfgang)! - Add connector institution search and provider migration support.
+
+  ## New APIs
+
+  ### `useQuilttResolvable` Hook
+
+  Check if external provider institution IDs (e.g., Plaid) can be migrated to your connector.
+
+  ```typescript
+  import { useQuilttResolvable } from "@quiltt/react";
+  import { useEffect } from "react";
+
+  function ResolvableConnector({ plaidInstitutionId, children }) {
+    const { checkResolvable, isResolvable, isLoading } =
+      useQuilttResolvable("my-connector-id");
+
+    useEffect(() => {
+      checkResolvable({ plaid: plaidInstitutionId });
+    }, [plaidInstitutionId]);
+
+    if (isLoading) return <div>Checking...</div>;
+    if (!isResolvable) return null;
+
+    return <>{children}</>;
+  }
+
+  // Usage
+  <ResolvableConnector plaidInstitutionId="ins_3">
+    <QuilttButton connectorId="my-connector-id" />
+  </ResolvableConnector>;
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`0af4e66`](https://github.com/quiltt/quiltt-js/commit/0af4e6622d1542e0c0c02ac7e897e3e4f9219cbd)]:
+  - @quiltt/core@4.4.0
+
 ## 4.3.3
 
 ### Patch Changes

package/dist/index.d.ts

@@ -117,6 +117,20 @@ declare const useQuilttConnector: (connectorId?: string, options?: ConnectorSDKC
     open: () => void;
 };
 
+type UseQuilttResolvable = (connectorId: string, onErrorCallback?: (msg: string) => void) => {
+    checkResolvable: (providerId: {
+        plaid?: string;
+        mock?: string;
+        mx?: string;
+        finicity?: string;
+        akoya?: string;
+    }) => Promise<boolean | null>;
+    isLoading: boolean;
+    isResolvable: boolean | null;
+    error: string | null;
+};
+declare const useQuilttResolvable: UseQuilttResolvable;
+
 type UseQuilttInstitutions = (connectorId: string, onErrorCallback?: (msg: string) => void) => {
     searchTerm: string;
     searchResults: InstitutionsData;
@@ -182,5 +196,5 @@ declare const QuilttSettingsProvider: FC<QuilttSettingsProviderProps>;
 type QuilttProviderProps = QuilttSettingsProviderProps & QuilttAuthProviderProps;
 declare const QuilttProvider: FC<QuilttProviderProps>;
 
-export { QuilttAuthProvider, QuilttButton, QuilttContainer, QuilttProvider, QuilttSettingsProvider, useAuthenticateSession, useEventListener, useIdentifySession, useImportSession, useIsomorphicLayoutEffect, useQuilttClient, useQuilttConnector, useQuilttInstitutions, useQuilttSession, useQuilttSettings, useRevokeSession, useSession, useStorage };
-export type { AuthenticateSession, IdentifySession, ImportSession, QuilttAuthProviderProps, QuilttSettingsProviderProps, RevokeSession, SetSession, UseQuilttInstitutions, UseQuilttSession };
+export { QuilttAuthProvider, QuilttButton, QuilttContainer, QuilttProvider, QuilttSettingsProvider, useAuthenticateSession, useEventListener, useIdentifySession, useImportSession, useIsomorphicLayoutEffect, useQuilttClient, useQuilttConnector, useQuilttInstitutions, useQuilttResolvable, useQuilttSession, useQuilttSettings, useRevokeSession, useSession, useStorage };
+export type { AuthenticateSession, IdentifySession, ImportSession, QuilttAuthProviderProps, QuilttSettingsProviderProps, RevokeSession, SetSession, UseQuilttInstitutions, UseQuilttResolvable, UseQuilttSession };

package/dist/index.js

@@ -1,13 +1,14 @@
 export * from '@quiltt/core';
 import { jsx } from 'react/jsx-runtime';
 import { useRef, useEffect } from 'react';
-import { u as useQuilttConnector } from './useQuilttConnector-12s-DTl-EiqV.js';
+import { u as useQuilttConnector } from './useQuilttConnector-12s-BiIbmt7I.js';
 import { i as isDeepEqual, Q as QuilttAuthProvider } from './QuilttAuthProvider-12s-4hQ7iysR.js';
 export { b as useAuthenticateSession, a as useIdentifySession, u as useImportSession, c as useRevokeSession } from './QuilttAuthProvider-12s-4hQ7iysR.js';
 export { u as useEventListener } from './useEventListener-12s-D_-6QIXa.js';
 export { u as useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect-12s-DeTHOKz1.js';
 export { u as useQuilttClient } from './useQuilttClient-12s-CAAUait1.js';
-export { u as useQuilttInstitutions } from './useQuilttInstitutions-12s-Cg4OA77c.js';
+export { u as useQuilttResolvable } from './useQuilttResolvable-12s-C2mjy5zs.js';
+export { u as useQuilttInstitutions } from './useQuilttInstitutions-12s-0_y37UHg.js';
 export { u as useQuilttSession } from './useQuilttSession-12s-BCq3OL9S.js';
 export { u as useQuilttSettings } from './useQuilttSettings-12s--rCJoNHD.js';
 export { u as useSession } from './useSession-12s-7GOn4sUn.js';

package/dist/{useQuilttConnector-12s-DTl-EiqV.js → useQuilttConnector-12s-BiIbmt7I.js}

@@ -5,7 +5,7 @@ import { u as useQuilttSession } from './useQuilttSession-12s-BCq3OL9S.js';
 import { u as useScript } from './useScript-12s-JCgaTW9n.js';
 import { i as isDeepEqual } from './QuilttAuthProvider-12s-4hQ7iysR.js';
 
-var version = "4.3.3";
+var version = "4.4.0";
 
 const useQuilttConnector = (connectorId, options)=>{
     const status = useScript(`${cdnBase}/v1/connector.js?agent=react-${version}`, {

package/dist/{useQuilttInstitutions-12s-Cg4OA77c.js → useQuilttInstitutions-12s-0_y37UHg.js}

@@ -1,8 +1,8 @@
 'use client';
 import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
-import { InstitutionsAPI } from '@quiltt/core';
+import { ConnectorsAPI } from '@quiltt/core';
 import { useDebounce } from 'use-debounce';
-import { v as version } from './useQuilttConnector-12s-DTl-EiqV.js';
+import { v as version } from './useQuilttConnector-12s-BiIbmt7I.js';
 import { u as useSession } from './useSession-12s-7GOn4sUn.js';
 
 const useQuilttInstitutions = (connectorId, onErrorCallback)=>{
@@ -18,7 +18,7 @@ const useQuilttInstitutions = (connectorId, onErrorCallback)=>{
         typeof navigator !== 'undefined');
         return isReactNative ? `react-native-${version}` : `react-${version}`;
     }, []);
-    const institutionsAPI = useMemo(()=>new InstitutionsAPI(connectorId, agent), [
+    const connectorsAPI = useMemo(()=>new ConnectorsAPI(connectorId, agent), [
         connectorId,
         agent
     ]);
@@ -58,7 +58,7 @@ const useQuilttInstitutions = (connectorId, onErrorCallback)=>{
             return;
         }
         const abortController = new AbortController();
-        institutionsAPI.search(session?.token, connectorId, searchTerm, abortController.signal).then((response)=>{
+        connectorsAPI.searchInstitutions(session?.token, connectorId, searchTerm, abortController.signal).then((response)=>{
             if (!abortController.signal.aborted) {
                 if (response.status === 200) {
                     setSearchResults(response.data);
@@ -78,7 +78,7 @@ const useQuilttInstitutions = (connectorId, onErrorCallback)=>{
         session?.token,
         connectorId,
         searchTerm,
-        institutionsAPI,
+        connectorsAPI,
         handleError
     ]);
     return {

package/dist/useQuilttResolvable-12s-C2mjy5zs.js

@@ -0,0 +1,79 @@
+'use client';
+import { useMemo, useState, useCallback } from 'react';
+import { ConnectorsAPI } from '@quiltt/core';
+import { v as version } from './useQuilttConnector-12s-BiIbmt7I.js';
+import { u as useSession } from './useSession-12s-7GOn4sUn.js';
+
+const useQuilttResolvable = (connectorId, onErrorCallback)=>{
+    const agent = useMemo(()=>{
+        // Try deprecated navigator.product first (still used in some RN versions)
+        if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+            return `react-native-${version}`;
+        }
+        // Detect React Native by its unique environment characteristics
+        const isReactNative = !!// Has window (unlike Node.js)
+        (typeof window !== 'undefined' && // No document in window (unlike browsers)
+        typeof window.document === 'undefined' && // Has navigator (unlike Node.js)
+        typeof navigator !== 'undefined');
+        return isReactNative ? `react-native-${version}` : `react-${version}`;
+    }, []);
+    const connectorsAPI = useMemo(()=>new ConnectorsAPI(connectorId, agent), [
+        connectorId,
+        agent
+    ]);
+    const [session] = useSession();
+    const [isLoading, setIsLoading] = useState(false);
+    const [isResolvable, setIsResolvable] = useState(null);
+    const [error, setError] = useState(null);
+    const handleError = useCallback((message)=>{
+        const errorMessage = message || 'Unknown error occurred while checking resolvability';
+        setError(errorMessage);
+        console.error('Quiltt Connector Resolvable Error:', errorMessage);
+        if (onErrorCallback) onErrorCallback(errorMessage);
+    }, [
+        onErrorCallback
+    ]);
+    const checkResolvable = useCallback(async (providerId)=>{
+        if (!session?.token || !connectorId) {
+            handleError('Missing session token or connector ID');
+            return null;
+        }
+        const hasProviderId = Object.values(providerId).some((id)=>!!id);
+        if (!hasProviderId) {
+            handleError('No provider ID specified');
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await connectorsAPI.checkResolvable(session.token, connectorId, providerId);
+            if (response.status === 200) {
+                const result = response.data.resolvable;
+                setIsResolvable(result);
+                return result;
+            }
+            handleError(response.data.message || 'Failed to check resolvability');
+            setIsResolvable(null);
+            return null;
+        } catch (error) {
+            handleError(error?.message);
+            setIsResolvable(null);
+            return null;
+        } finally{
+            setIsLoading(false);
+        }
+    }, [
+        session?.token,
+        connectorId,
+        connectorsAPI,
+        handleError
+    ]);
+    return {
+        checkResolvable,
+        isLoading,
+        isResolvable,
+        error
+    };
+};
+
+export { useQuilttResolvable as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quiltt/react",
-  "version": "4.3.3",
+  "version": "4.4.0",
   "description": "React Components and Hooks for Quiltt Connector",
   "keywords": [
     "quiltt",
@@ -36,7 +36,7 @@
   "dependencies": {
     "@apollo/client": "^3.14.0",
     "use-debounce": "^10.0.4",
-    "@quiltt/core": "4.3.3"
+    "@quiltt/core": "4.4.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.4",

package/src/hooks/index.ts

@@ -2,6 +2,7 @@ export * from './helpers'
 export * from './session'
 export * from './useQuilttClient'
 export * from './useQuilttConnector'
+export * from './useQuilttResolvable'
 export * from './useQuilttInstitutions'
 export * from './useQuilttSession'
 export * from './useQuilttSettings'

package/src/hooks/useQuilttInstitutions.ts

@@ -3,7 +3,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 
 import type { ErrorData, InstitutionsData } from '@quiltt/core'
-import { InstitutionsAPI } from '@quiltt/core'
+import { ConnectorsAPI } from '@quiltt/core'
 import { useDebounce } from 'use-debounce'
 
 import { version } from '../version'
@@ -41,10 +41,7 @@ export const useQuilttInstitutions: UseQuilttInstitutions = (connectorId, onErro
     return isReactNative ? `react-native-${version}` : `react-${version}`
   }, [])
 
-  const institutionsAPI = useMemo(
-    () => new InstitutionsAPI(connectorId, agent),
-    [connectorId, agent]
-  )
+  const connectorsAPI = useMemo(() => new ConnectorsAPI(connectorId, agent), [connectorId, agent])
   const [session] = useSession()
 
   const [searchTermInput, setSearchTermInput] = useState('')
@@ -93,8 +90,8 @@ export const useQuilttInstitutions: UseQuilttInstitutions = (connectorId, onErro
 
     const abortController = new AbortController()
 
-    institutionsAPI
-      .search(session?.token, connectorId, searchTerm, abortController.signal)
+    connectorsAPI
+      .searchInstitutions(session?.token, connectorId, searchTerm, abortController.signal)
       .then((response) => {
         if (!abortController.signal.aborted) {
           if (response.status === 200) {
@@ -113,7 +110,7 @@ export const useQuilttInstitutions: UseQuilttInstitutions = (connectorId, onErro
       })
 
     return () => abortController.abort()
-  }, [session?.token, connectorId, searchTerm, institutionsAPI, handleError])
+  }, [session?.token, connectorId, searchTerm, connectorsAPI, handleError])
 
   return {
     searchTerm,

package/src/hooks/useQuilttResolvable.ts

@@ -0,0 +1,127 @@
+'use client'
+
+import { useCallback, useMemo, useState } from 'react'
+
+import type { ErrorData, ResolvableData } from '@quiltt/core'
+import { ConnectorsAPI } from '@quiltt/core'
+
+import { version } from '../version'
+import useSession from './useSession'
+
+export type UseQuilttResolvable = (
+  connectorId: string,
+  onErrorCallback?: (msg: string) => void,
+) => {
+  checkResolvable: (providerId: {
+    plaid?: string
+    mock?: string
+    mx?: string
+    finicity?: string
+    akoya?: string
+  }) => Promise<boolean | null>
+  isLoading: boolean
+  isResolvable: boolean | null
+  error: string | null
+}
+
+export const useQuilttResolvable: UseQuilttResolvable = (
+  connectorId,
+  onErrorCallback,
+) => {
+  const agent = useMemo(() => {
+    // Try deprecated navigator.product first (still used in some RN versions)
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+      return `react-native-${version}`
+    }
+
+    // Detect React Native by its unique environment characteristics
+    const isReactNative = !!(
+      // Has window (unlike Node.js)
+      (
+        typeof window !== 'undefined' &&
+        // No document in window (unlike browsers)
+        typeof window.document === 'undefined' &&
+        // Has navigator (unlike Node.js)
+        typeof navigator !== 'undefined'
+      )
+    )
+
+    return isReactNative ? `react-native-${version}` : `react-${version}`
+  }, [])
+
+  const connectorsAPI = useMemo(() => new ConnectorsAPI(connectorId, agent), [connectorId, agent])
+  const [session] = useSession()
+
+  const [isLoading, setIsLoading] = useState(false)
+  const [isResolvable, setIsResolvable] = useState<boolean | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleError = useCallback(
+    (message: string) => {
+      const errorMessage = message || 'Unknown error occurred while checking resolvability'
+
+      setError(errorMessage)
+      console.error('Quiltt Connector Resolvable Error:', errorMessage)
+      if (onErrorCallback) onErrorCallback(errorMessage)
+    },
+    [onErrorCallback],
+  )
+
+  const checkResolvable = useCallback(
+    async (providerId: {
+      plaid?: string
+      mock?: string
+      mx?: string
+      finicity?: string
+      akoya?: string
+    }): Promise<boolean | null> => {
+      if (!session?.token || !connectorId) {
+        handleError('Missing session token or connector ID')
+        return null
+      }
+
+      const hasProviderId = Object.values(providerId).some((id) => !!id)
+      if (!hasProviderId) {
+        handleError('No provider ID specified')
+        return null
+      }
+
+      setIsLoading(true)
+      setError(null)
+
+      try {
+        const response = await connectorsAPI.checkResolvable(
+          session.token,
+          connectorId,
+          providerId,
+        )
+
+        if (response.status === 200) {
+          const result = (response.data as ResolvableData).resolvable
+          setIsResolvable(result)
+          return result
+        }
+
+        handleError((response.data as ErrorData).message || 'Failed to check resolvability')
+        setIsResolvable(null)
+        return null
+      } catch (error: any) {
+        handleError(error?.message)
+        setIsResolvable(null)
+        return null
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [session?.token, connectorId, connectorsAPI, handleError],
+  )
+
+  return {
+    checkResolvable,
+    isLoading,
+    isResolvable,
+    error,
+  }
+}
+
+export default useQuilttResolvable