How universal-connect-project/universal-connect-widget works
Main architectural areas
• Frontend / Client
• This includes the widget UI and other consumer‐facing elements.
• In the “application/src”, you see many React components, Redux store files and hooks. Also note the mobile-specific directories under “application/android” and “application/ios” that use Capacitor.
• Backend / Server
• The “application/server” directory shows an Express‐based Node.js backend that provides API endpoints (connectApiExpress.js, server.js) and routes requests from the widget.
• The server code also contains middleware and utilities (infra, logger, utils) to support routing, error handling, and connection setup.
• Integration / Service Clients
• Look at “application/server/serviceClients” – each subfolder (e.g., akoyaClient, finicityClient, mxClient, etc.) implements a client for a third‐party provider.
• In “application/server/providers”, integration “adapters” for each provider are implemented. These abstract the underlying APIs so that which provider is used can be transparently switched based on performance, cost, or availability.
• Shared / Reusable Components
• The “application/shared” directory holds common elements used by both frontend and backend (for example, shared contracts, connection procedures, and utilities).
• API Specification / Documentation
• The “openapi” directory contains the API definitions and component contracts which are important for the integration point and communication standards.
• Example / Quick Integration
• The “example” directory is used to show how to embed the widget into an application, which can be highlighted as an “integration sample” component.
Out the relationships and data flows
• A User or a third-party application embeds the Universal Connect Widget (Frontend) into their website or mobile app.
• The Widget (running primarily in the browser or inside a mobile container) communicates with the backend API (Node server) via HTTP(s) calls.
• The backend API processes the requests, and based on the client’s data and performance needs, it calls one or more service clients.
• The Service Clients communicate with external data providers (MX, Finicity, Sophtron, Akoya, etc.) to retrieve, process, and relay financial data (accounts, transactions, etc.).
• Both frontend and backend share common data contracts (using Verifiable Credentials and FDX standards as noted in the README) ensuring data is formatted consistently regardless of provider.
• The API uses asynchronous flows, error handling (with fallback or reroute for fault tolerance), and logging/monitoring to maintain performance and reliability.
Important architectural patterns and principles
• Separation of concerns – clearly separated layers between client (UI), server (API), and integration (service clients).
• Modularity – each third-party provider is handled by its own module (see separate directories under “providers” and “serviceClients”).
• Platform versatility – separate configurations and implementations exist for Android and iOS in addition to the web-based widget.
• Resiliency and Performance – built-in routing (even at connection selection level) and fault tolerance to select the fastest/cheapest provider.
• Use of standards – implementation of the WC3 Verifiable Credentials and data models ensures consistent, secure data handling.