@quiltt/core 4.5.1 → 5.0.1

package/dist/index.js

@@ -1,371 +1,8 @@
-import { ApolloLink, ApolloClient } from '@apollo/client/core/index.js';
-export { gql } from '@apollo/client/core/index.js';
-import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth, b as endpointRest } from './SubscriptionLink-12s-B8qxyDXC.js';
-export { L as LocalStorage, M as MemoryStorage, O as Observable, g as Storage, c as cdnBase, f as endpointWebsockets } from './SubscriptionLink-12s-B8qxyDXC.js';
-import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
-import crossfetch from 'cross-fetch';
-import { onError } from '@apollo/client/link/error/index.js';
-import { HttpLink as HttpLink$1 } from '@apollo/client/link/http/index.js';
-import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
-export { InMemoryCache } from '@apollo/client/cache/index.js';
-export { useMutation, useQuery, useSubscription } from '@apollo/client/react/hooks/index.js';
-
-/**
- * Enum representing the different types of events emitted by the Connector.
- */ var ConnectorSDKEventType = /*#__PURE__*/ function(ConnectorSDKEventType) {
-    /** The Connector modal has been opened */ ConnectorSDKEventType["Open"] = "opened";
-    /** The Connector has loaded successfully */ ConnectorSDKEventType["Load"] = "loaded";
-    /** The end-user successfully completed the flow */ ConnectorSDKEventType["ExitSuccess"] = "exited.successful";
-    /** The end-user exited the Connector before completing the flow */ ConnectorSDKEventType["ExitAbort"] = "exited.aborted";
-    /** The end-user experienced an error during the flow */ ConnectorSDKEventType["ExitError"] = "exited.errored";
-    return ConnectorSDKEventType;
-}({});
-
-/**
- * unauthorizedCallback only triggers in the event the token is present, and
- * returns the token; This allows sessions to be forgotten without race conditions
- * causing null sessions to kill valid sessions, or invalid sessions for killing
- * valid sessions during rotation and networking weirdness.
- */ class AuthLink extends ApolloLink {
-    request(operation, forward) {
-        const token = GlobalStorage.get('session');
-        if (!token) {
-            console.warn('QuilttLink attempted to send an unauthenticated Query');
-            return null;
-        }
-        operation.setContext(({ headers = {} })=>({
-                headers: {
-                    ...headers,
-                    authorization: `Bearer ${token}`
-                }
-            }));
-        return forward(operation);
-    }
-}
-
-// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
-const effectiveFetch$2 = typeof fetch === 'undefined' ? crossfetch : fetch;
-const BatchHttpLink = new BatchHttpLink$1({
-    uri: endpointGraphQL,
-    fetch: effectiveFetch$2
-});
-
-const ErrorLink = onError(({ graphQLErrors, networkError })=>{
-    if (graphQLErrors) {
-        graphQLErrors.forEach(({ message, path, extensions })=>{
-            const formattedPath = Array.isArray(path) ? path.join('.') : path ?? 'N/A';
-            const parts = [
-                `[Quiltt][GraphQL Error]: ${message}`,
-                `Path: ${formattedPath}`
-            ];
-            if (extensions) {
-                if (extensions.code) parts.push(`Code: ${extensions.code}`);
-                if (extensions.errorId) parts.push(`Error ID: ${extensions.errorId}`);
-            }
-            console.warn(parts.join(' | '));
-        });
-    }
-    if (networkError) {
-        if (networkError.statusCode === 401) {
-            console.warn('[Quiltt][Authentication Error]:', networkError);
-            GlobalStorage.set('session', null);
-        } else {
-            console.warn('[Quiltt][Network Error]:', networkError);
-        }
-    }
-});
-
-const ForwardableLink = new ApolloLink((operation, forward)=>forward(operation));
-
-// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
-const effectiveFetch$1 = typeof fetch === 'undefined' ? crossfetch : fetch;
-const HttpLink = new HttpLink$1({
-    uri: endpointGraphQL,
-    fetch: effectiveFetch$1
-});
-
-const RetryLink = new RetryLink$1({
-    attempts: {
-        retryIf: (error, _operation)=>!!error && (!error.statusCode || error.statusCode >= 500)
-    }
-});
-
-const TerminatingLink = new ApolloLink(()=>null);
-
-const VersionLink = new ApolloLink((operation, forward)=>{
-    operation.setContext(({ headers = {} })=>({
-            headers: {
-                ...headers,
-                'Quiltt-Client-Version': version
-            }
-        }));
-    return forward(operation);
-});
-
-class QuilttClient extends ApolloClient {
-    constructor(options){
-        const finalOptions = {
-            ...options,
-            devtools: {
-                enabled: options.devtools?.enabled ?? debugging
-            }
-        };
-        const initialLinks = options.customLinks ? [
-            ...options.customLinks
-        ] : [];
-        const isOperationDefinition = (def)=>def.kind === 'OperationDefinition';
-        const isSubscriptionOperation = (operation)=>{
-            return operation.query.definitions.some((definition)=>isOperationDefinition(definition) && definition.operation === 'subscription');
-        };
-        const isBatchable = (operation)=>{
-            return operation.getContext().batchable ?? true;
-        };
-        const authLink = new AuthLink();
-        const subscriptionsLink = new SubscriptionLink();
-        const quilttLink = ApolloLink.from([
-            ...initialLinks,
-            VersionLink,
-            authLink,
-            ErrorLink,
-            RetryLink
-        ]).split(isSubscriptionOperation, subscriptionsLink, ForwardableLink).split(isBatchable, BatchHttpLink, HttpLink);
-        super({
-            link: quilttLink,
-            ...finalOptions
-        });
-    }
-}
-
-// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
-const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch;
-const RETRY_DELAY = 150 // ms
-;
-const RETRIES = 10 // 150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500 = 8.250s
-;
-/**
- * A wrapper around the native `fetch` function that adds automatic retries on failure, including network errors and HTTP 429 responses.
- * Now treats any response with status < 500 as valid.
- */ const fetchWithRetry = async (url, options = {
-    retry: false
-})=>{
-    const { retry, retriesRemaining, validateStatus = (status)=>status >= 200 && status < 300, ...fetchOptions } = options;
-    try {
-        const response = await effectiveFetch(url, fetchOptions);
-        const isResponseOk = validateStatus(response.status);
-        if (isResponseOk) {
-            return {
-                data: await response.json().catch(()=>null),
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                ok: isResponseOk
-            };
-        }
-        // If validateStatus fails, and retry is enabled, prepare to retry for eligible status codes
-        if (retry && (response.status >= 500 || response.status === 429)) {
-            throw new Error('Retryable failure');
-        }
-        throw new Error(`HTTP error with status ${response.status}`);
-    } catch (error) {
-        if (retry) {
-            const currentRetriesRemaining = retriesRemaining !== undefined ? retriesRemaining : RETRIES;
-            if (currentRetriesRemaining > 0) {
-                const delayTime = RETRY_DELAY * (RETRIES - currentRetriesRemaining);
-                await new Promise((resolve)=>setTimeout(resolve, delayTime));
-                return fetchWithRetry(url, {
-                    ...options,
-                    retriesRemaining: currentRetriesRemaining - 1
-                });
-            }
-        }
-        return Promise.reject(error);
-    }
-};
-
-var AuthStrategies = /*#__PURE__*/ function(AuthStrategies) {
-    AuthStrategies["Email"] = "email";
-    AuthStrategies["Phone"] = "phone";
-    return AuthStrategies;
-}({});
-// https://www.quiltt.dev/api-reference/auth
-class AuthAPI {
-    constructor(clientId){
-        /**
-   * Response Statuses:
-   *  - 200: OK           -> Session is Valid
-   *  - 401: Unauthorized -> Session is Invalid
-   */ this.ping = async (token)=>{
-            const response = await fetchWithRetry(endpointAuth, {
-                method: 'GET',
-                ...this.config(token)
-            });
-            return response;
-        };
-        /**
-   * Response Statuses:
-   *  - 201: Created              -> Profile Created, New Session Returned
-   *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
-   *  - 422: Unprocessable Entity -> Invalid Payload
-   */ this.identify = async (payload)=>{
-            const response = await fetchWithRetry(endpointAuth, {
-                method: 'POST',
-                body: JSON.stringify(this.body(payload)),
-                ...this.config()
-            });
-            return response;
-        };
-        /**
-   * Response Statuses:
-   *  - 201: Created              -> MFA Validated, New Session Returned
-   *  - 401: Unauthorized         -> MFA Invalid
-   *  - 422: Unprocessable Entity -> Invalid Payload
-   */ this.authenticate = async (payload)=>{
-            const response = await fetchWithRetry(endpointAuth, {
-                method: 'PUT',
-                body: JSON.stringify(this.body(payload)),
-                ...this.config()
-            });
-            return response;
-        };
-        /**
-   * Response Statuses:
-   *  - 204: No Content   -> Session Revoked
-   *  - 401: Unauthorized -> Session Not Found
-   */ this.revoke = async (token)=>{
-            const response = await fetchWithRetry(endpointAuth, {
-                method: 'DELETE',
-                ...this.config(token)
-            });
-            return response;
-        };
-        this.config = (token)=>{
-            const headers = new Headers();
-            headers.set('Content-Type', 'application/json');
-            headers.set('Accept', 'application/json');
-            if (token) {
-                headers.set('Authorization', `Bearer ${token}`);
-            }
-            return {
-                headers,
-                validateStatus: this.validateStatus,
-                retry: true
-            };
-        };
-        this.validateStatus = (status)=>status < 500 && status !== 429;
-        this.body = (payload)=>{
-            if (!this.clientId) {
-                console.error('Quiltt Client ID is not set. Unable to identify & authenticate');
-            }
-            return {
-                session: {
-                    clientId: this.clientId,
-                    ...payload
-                }
-            };
-        };
-        this.clientId = clientId;
-    }
-}
-
-class ConnectorsAPI {
-    constructor(clientId, agent = 'web'){
-        /**
-   * Response Statuses:
-   *  - 200: OK           -> Institutions Found
-   *  - 401: Unauthorized -> Invalid Token
-   *  - 403: Forbidden    -> Unsupported SDK
-   *  - 400: Bad Request  -> Invalid Request
-   */ this.searchInstitutions = async (token, connectorId, term, signal)=>{
-            const params = new URLSearchParams();
-            params.append('term', term);
-            const response = await fetchWithRetry(`${endpointRest}/sdk/connectors/${connectorId}/institutions?${params}`, {
-                method: 'GET',
-                signal,
-                ...this.config(token)
-            });
-            return response;
-        };
-        /**
-   * Response Statuses:
-   *  - 200: OK           -> Provider API ID is resolvable or not
-   *  - 401: Unauthorized -> Invalid Token
-   *  - 403: Forbidden    -> Unsupported SDK
-   *  - 400: Bad Request  -> Missing provider API ID parameter
-   *  - 404: Not Found    -> Connector not found
-   */ this.checkResolvable = async (token, connectorId, providerId, signal)=>{
-            const params = new URLSearchParams();
-            const providerKey = Object.keys(providerId)[0];
-            if (providerKey && providerId[providerKey]) {
-                params.append(providerKey, providerId[providerKey]);
-            }
-            const response = await fetchWithRetry(`${endpointRest}/sdk/connectors/${connectorId}/resolvable?${params}`, {
-                method: 'GET',
-                signal,
-                ...this.config(token)
-            });
-            return response;
-        };
-        this.config = (token)=>{
-            const headers = new Headers();
-            headers.set('Content-Type', 'application/json');
-            headers.set('Accept', 'application/json');
-            headers.set('Quiltt-SDK-Agent', this.agent);
-            headers.set('Authorization', `Bearer ${token}`);
-            return {
-                headers,
-                validateStatus: this.validateStatus,
-                retry: true
-            };
-        };
-        this.validateStatus = (status)=>status < 500 && status !== 429;
-        this.clientId = clientId;
-        this.agent = agent;
-    }
-}
-
-const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
-const JsonWebTokenParse = (token)=>{
-    if (typeof token === 'undefined' || token === null) return token;
-    if (!MATCHER.test(token)) {
-        console.error(`Invalid Session Token: ${token}`);
-        return;
-    }
-    const [_header, payload, _signature] = token.split('.');
-    try {
-        return {
-            token,
-            claims: JSON.parse(atob(payload))
-        };
-    } catch (error) {
-        console.error(`Invalid Session Token: ${error}`);
-    }
-};
-
-/**
- * This is designed to support singletons to timeouts that can broadcast
- * to any observers, preventing race conditions with multiple timeouts.
- */ class Timeoutable {
-    constructor(){
-        this.observers = [];
-        this.set = (callback, delay)=>{
-            if (this.timeout) {
-                clearTimeout(this.timeout);
-            }
-            // Replace all observers with the new one
-            this.observers = [
-                callback
-            ];
-            this.timeout = setTimeout(this.broadcast.bind(this), delay);
-        };
-        this.clear = (observer)=>{
-            this.observers = this.observers.filter((callback)=>callback !== observer);
-        };
-        // Only sends to the 1st listener, but ensures that someone is notified
-        this.broadcast = ()=>{
-            if (this.observers.length === 0) return;
-            this.observers[0](undefined);
-        };
-    }
-}
-
-export { AuthAPI, AuthLink, AuthStrategies, BatchHttpLink, ConnectorSDKEventType, ConnectorsAPI, ErrorLink, ForwardableLink, GlobalStorage, HttpLink, JsonWebTokenParse, QuilttClient, RetryLink, SubscriptionLink, TerminatingLink, Timeoutable, VersionLink, debugging, endpointAuth, endpointGraphQL, endpointRest, version };
+export * from './api/index.js';
+export * from './auth/index.js';
+export * from './config/index.js';
+export * from './observables/index.js';
+export * from './storage/index.js';
+export * from './timing/index.js';
+export * from './types.js';
+export * from './utils/index.js';

package/dist/observables/index.cjs

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * This is designed to support singletons to share the memory states across all
+ * instance of hooks to ensure that updates only process once, by storing a value
+ * then notifying all subscribers when it's updated.
+ */ class Observable {
+    constructor(initialState){
+        this.observers = [];
+        this.get = ()=>{
+            return this.state;
+        };
+        this.set = (nextState)=>{
+            if (this.state === nextState) return;
+            this.state = nextState;
+            this.observers.forEach((update)=>{
+                update(nextState);
+            });
+        };
+        this.subscribe = (observer)=>{
+            this.observers.push(observer);
+        };
+        this.unsubscribe = (observer)=>{
+            this.observers = this.observers.filter((update)=>update !== observer);
+        };
+        this.state = initialState;
+    }
+}
+
+exports.Observable = Observable;

package/dist/observables/index.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch, SetStateAction } from 'react';
+import { Maybe } from '../types.js';
+
+type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
+/**
+ * This is designed to support singletons to share the memory states across all
+ * instance of hooks to ensure that updates only process once, by storing a value
+ * then notifying all subscribers when it's updated.
+ */
+declare class Observable<T> {
+    private state?;
+    private observers;
+    constructor(initialState?: Maybe<T>);
+    get: () => Maybe<T> | undefined;
+    set: (nextState: Maybe<T> | undefined) => void;
+    subscribe: (observer: Observer<T>) => void;
+    unsubscribe: (observer: Observer<T>) => void;
+}
+
+export { Observable };
+export type { Observer };

package/dist/observables/index.js

@@ -0,0 +1,28 @@
+/**
+ * This is designed to support singletons to share the memory states across all
+ * instance of hooks to ensure that updates only process once, by storing a value
+ * then notifying all subscribers when it's updated.
+ */ class Observable {
+    constructor(initialState){
+        this.observers = [];
+        this.get = ()=>{
+            return this.state;
+        };
+        this.set = (nextState)=>{
+            if (this.state === nextState) return;
+            this.state = nextState;
+            this.observers.forEach((update)=>{
+                update(nextState);
+            });
+        };
+        this.subscribe = (observer)=>{
+            this.observers.push(observer);
+        };
+        this.unsubscribe = (observer)=>{
+            this.observers = this.observers.filter((update)=>update !== observer);
+        };
+        this.state = initialState;
+    }
+}
+
+export { Observable };