@quiltt/core 4.2.3 → 4.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @quiltt/core
 
+## 4.3.1
+
+### Patch Changes
+
+- [#366](https://github.com/quiltt/quiltt-js/pull/366) [`dc376b5`](https://github.com/quiltt/quiltt-js/commit/dc376b52dd824d7867ca74677bbfd5c54eff5cdc) Thanks [@sirwolfgang](https://github.com/sirwolfgang)! - Warn if useQuilttConnector is unmounted while in use
+
+## 4.3.0
+
+### Minor Changes
+
+- [#363](https://github.com/quiltt/quiltt-js/pull/363) [`641d766`](https://github.com/quiltt/quiltt-js/commit/641d76620ffbb99bc80fdc9998ac936883fe1d06) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Upgrade rails/actioncable to v8
+
 ## 4.2.3
 
 ### Patch Changes

package/dist/{SubscriptionLink-client-BNmSIP63.js → SubscriptionLink-12s-C9j_SmFl.js}

@@ -4,75 +4,196 @@ import { Observable as Observable$1 } from '@apollo/client/utilities/index.js';
 import { createConsumer } from '@rails/actioncable';
 import { print } from 'graphql';
 
+var name = "@quiltt/core";
+var version$1 = "4.3.1";
+
+const QUILTT_API_INSECURE = (()=>{
+    try {
+        return process.env.QUILTT_API_INSECURE === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const QUILTT_API_DOMAIN = (()=>{
+    try {
+        return process.env.QUILTT_API_DOMAIN;
+    } catch  {
+        return undefined;
+    }
+})();
+const QUILTT_DEBUG = (()=>{
+    try {
+        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const domain = QUILTT_API_DOMAIN || 'quiltt.io';
+const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
+const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
+const debugging = QUILTT_DEBUG;
+const version = `${name}: v${version$1}`;
+const cdnBase = `${protocolHttp}://cdn.${domain}`;
+const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
+const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
+const endpointRest = `${protocolHttp}://api.${domain}/v1`;
+const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
+
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */ class LocalStorage {
-    constructor(){
+    constructor(keyPrefix = 'quiltt'){
         this.observers = {};
         this.isEnabled = ()=>{
             try {
-                localStorage.setItem('quiltt.ping', 'pong');
-                localStorage.removeItem('quiltt.ping');
+                const testKey = `${this.keyPrefix}.ping`;
+                localStorage.setItem(testKey, 'pong');
+                localStorage.removeItem(testKey);
                 return true;
-            } catch (error) {
+            } catch (_error) {
                 return false;
             }
         };
         this.isDisabled = ()=>!this.isEnabled();
         this.get = (key)=>{
-            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return undefined;
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return undefined;
+            }
+            const fullKey = this.getFullKey(key);
             try {
-                const state = window.localStorage.getItem(`quiltt.${key}`);
+                const state = window.localStorage.getItem(fullKey);
                 return state ? JSON.parse(state) : null;
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+                console.warn(`localStorage Error: "${fullKey}"`, error);
                 return undefined;
             }
         };
         this.set = (key, state)=>{
             if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
             try {
-                if (state) {
-                    window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state));
+                if (state !== null && state !== undefined) {
+                    window.localStorage.setItem(fullKey, JSON.stringify(state));
                 } else {
-                    window.localStorage.removeItem(`quiltt.${key}`);
+                    window.localStorage.removeItem(fullKey);
                 }
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+                console.warn(`localStorage Error: "${fullKey}"`, error);
             }
         };
         this.remove = (key)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
+            try {
+                window.localStorage.removeItem(fullKey);
+            } catch (error) {
+                console.warn(`localStorage Error: "${fullKey}"`, error);
+            }
+        };
+        this.has = (key)=>{
+            return this.get(key) !== null && this.get(key) !== undefined;
+        };
+        this.clear = ()=>{
             if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
             try {
-                window.localStorage.removeItem(`quiltt.${key}`);
+                const keysToRemove = [];
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach((key)=>{
+                    localStorage.removeItem(key);
+                });
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}">`, error);
+                console.warn(`localStorage Error during clear`, error);
             }
         };
         this.subscribe = (key, observer)=>{
-            if (!this.observers[key]) this.observers[key] = [];
-            this.observers[key].push(observer);
+            const fullKey = this.getFullKey(key);
+            if (!this.observers[fullKey]) {
+                this.observers[fullKey] = [];
+            }
+            this.observers[fullKey].push(observer);
+            // Return unsubscribe function
+            return ()=>this.unsubscribe(key, observer);
         };
         this.unsubscribe = (key, observer)=>{
-            this.observers[key] = this.observers[key]?.filter((update)=>update !== observer);
+            const fullKey = this.getFullKey(key);
+            if (this.observers[fullKey]) {
+                this.observers[fullKey] = this.observers[fullKey].filter((update)=>update !== observer);
+                // Clean up empty observer arrays
+                if (this.observers[fullKey].length === 0) {
+                    delete this.observers[fullKey];
+                }
+            }
         };
-        // if there is a key, then trigger the related updates. If there is not key
-        // it means that a record has been removed and everything needs to be rechecked.
-        this.handleStorageEvent = (event)=>{
-            if (event.key?.includes('quiltt.')) {
-                const newState = event.newValue ? JSON.parse(event.newValue) : null;
+        // Get all keys that match quiltt prefix
+        this.keys = ()=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return [];
+            }
+            const keys = [];
+            try {
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keys.push(key.replace(`${this.keyPrefix}.`, ''));
+                    }
+                }
+            } catch (error) {
+                console.warn('localStorage Error getting keys', error);
+            }
+            return keys;
+        };
+        this.getFullKey = (key)=>{
+            return `${this.keyPrefix}.${key}`;
+        };
+        /**
+   * Handle storage events from other windows/tabs
+   * If there is a key, then trigger the related updates. If there is no key
+   * it means that a record has been removed and everything needs to be rechecked.
+   */ this.handleStorageEvent = (event)=>{
+            const isQuilttKey = event.key?.startsWith(`${this.keyPrefix}.`);
+            if (isQuilttKey && event.key) {
+                // Parse the new value safely
+                let newState = null;
+                try {
+                    newState = event.newValue ? JSON.parse(event.newValue) : null;
+                } catch (error) {
+                    console.warn(`Failed to parse storage event value for ${event.key}`, error);
+                    return;
+                }
                 if (this.observers[event.key]) {
-                    this.observers[event.key].forEach((update)=>update(newState));
+                    this.observers[event.key].forEach((observer)=>{
+                        try {
+                            observer(newState);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${event.key}`, error);
+                        }
+                    });
                 }
-            } else {
-                Object.entries(this.observers).forEach(([key, observers])=>{
-                    observers.forEach((update)=>update(this.get(key)));
+            } else if (!event.key) {
+                // Storage was cleared or changed in a way that doesn't specify a key
+                // Re-check all observed keys
+                Object.entries(this.observers).forEach(([fullKey, observers])=>{
+                    const shortKey = fullKey.replace(`${this.keyPrefix}.`, '');
+                    const currentValue = this.get(shortKey);
+                    observers.forEach((observer)=>{
+                        try {
+                            observer(currentValue);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${fullKey}`, error);
+                        }
+                    });
                 });
             }
         };
+        this.keyPrefix = keyPrefix;
         if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
             window.addEventListener('storage', this.handleStorageEvent.bind(this));
         }
@@ -84,7 +205,7 @@ import { print } from 'graphql';
  * 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(initalState){
+    constructor(initialState){
         this.observers = [];
         this.get = ()=>{
             return this.state;
@@ -92,7 +213,9 @@ import { print } from 'graphql';
         this.set = (nextState)=>{
             if (this.state === nextState) return;
             this.state = nextState;
-            this.observers.forEach((update)=>update(nextState));
+            this.observers.forEach((update)=>{
+                update(nextState);
+            });
         };
         this.subscribe = (observer)=>{
             this.observers.push(observer);
@@ -100,7 +223,7 @@ import { print } from 'graphql';
         this.unsubscribe = (observer)=>{
             this.observers = this.observers.filter((update)=>update !== observer);
         };
-        this.state = initalState;
+        this.state = initialState;
     }
 }
 
@@ -165,7 +288,9 @@ import { print } from 'graphql';
             this.monitorLocalStorageChanges(key);
             this.localStore.set(key, newState);
             this.memoryStore.set(key, newState);
-            this.observers[key]?.forEach((update)=>update(newState));
+            this.observers[key]?.forEach((update)=>{
+                update(newState);
+            });
         };
         /**
    * Allows you to subscribe to all changes in memory or local storage as a
@@ -193,7 +318,9 @@ import { print } from 'graphql';
                 const prevValue = this.memoryStore.get(key);
                 const newState = nextState instanceof Function ? nextState(prevValue) : nextState;
                 this.memoryStore.set(key, newState);
-                this.observers[key]?.forEach((update)=>update(newState));
+                this.observers[key]?.forEach((update)=>{
+                    update(newState);
+                });
             });
         };
     }
@@ -203,41 +330,6 @@ import { print } from 'graphql';
  * basically acts like shared memory when there is no localStorage.
  */ const GlobalStorage = new Storage();
 
-var name = "@quiltt/core";
-var version$1 = "4.2.3";
-
-const QUILTT_API_INSECURE = (()=>{
-    try {
-        return process.env.QUILTT_API_INSECURE === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const QUILTT_API_DOMAIN = (()=>{
-    try {
-        return process.env.QUILTT_API_DOMAIN;
-    } catch  {
-        return undefined;
-    }
-})();
-const QUILTT_DEBUG = (()=>{
-    try {
-        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const domain = QUILTT_API_DOMAIN || 'quiltt.io';
-const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
-const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
-const debugging = QUILTT_DEBUG;
-const version = `${name}: v${version$1}`;
-const cdnBase = `${protocolHttp}://cdn.${domain}`;
-const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
-const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
-const endpointRest = `${protocolHttp}://api.${domain}/v1`;
-const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
-
 class ActionCableLink extends ApolloLink {
     constructor(options){
         super();
@@ -299,4 +391,4 @@ class SubscriptionLink extends ActionCableLink {
     }
 }
 
-export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointRest as b, Storage as c, debugging as d, endpointGraphQL as e, cdnBase as f, endpointWebsockets as g, version as v };
+export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointRest as b, cdnBase as c, debugging as d, endpointGraphQL as e, endpointWebsockets as f, Storage as g, version as v };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _apollo_client_core from '@apollo/client/core';
-import { Operation, NextLink, FetchResult, ApolloClientOptions, NormalizedCacheObject } from '@apollo/client/core';
+import { ApolloClientOptions, NormalizedCacheObject, Operation, NextLink, FetchResult } from '@apollo/client/core';
 export { ApolloError, OperationVariables } from '@apollo/client/core';
 import { ApolloLink, ApolloClient } from '@apollo/client/core/index.js';
 export { gql } from '@apollo/client/core/index.js';
@@ -10,8 +10,8 @@ import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
 import { Observable as Observable$2 } from '@apollo/client/utilities/index.js';
 import { Consumer } from '@rails/actioncable';
 import { Dispatch, SetStateAction } from 'react';
-export { InMemoryCache } from '@apollo/client/cache/index.js';
 export { NormalizedCacheObject } from '@apollo/client/cache';
+export { InMemoryCache } from '@apollo/client/cache/index.js';
 export { useMutation, useQuery, useSubscription } from '@apollo/client/react/hooks/index.js';
 
 interface CallbackManager {
@@ -105,6 +105,10 @@ type ConnectorSDKCallbackMetadata = {
     profileId?: string;
     /** The ID of the Connection that was created or reconnected */
     connectionId?: string;
+    /** The Connector Session Object */
+    connectorSession?: {
+        id: string;
+    };
 };
 /**
   Options for the standard Connect flow
@@ -122,7 +126,11 @@ type ConnectorSDKReconnectOptions = ConnectorSDKCallbacks & {
     /** The ID of the Connection to reconnect */
     connectionId: string;
 };
-/** Options to initialize Connector */
+/** Options to initialize Connector
+ *
+ *  @todo: refactor into a union type - it's either or.
+ *  Union types only allow direct access to properties that exist on all branches, not properties unique to individual branches.
+ */
 type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
     /** The Institution ID or search term to connect */
     institution?: string;
@@ -132,6 +140,14 @@ type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
     nonce?: string;
 };
 
+type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'> & {
+    /** An array of initial links to inject before the default Quiltt Links */
+    customLinks?: ApolloLink[];
+};
+declare class QuilttClient extends ApolloClient<NormalizedCacheObject> {
+    constructor(options: QuilttClientOptions<NormalizedCacheObject>);
+}
+
 /**
  * unauthorizedCallback only triggers in the event the token is present, and
  * returns the token; This allows sessions to be forgotten without race conditions
@@ -179,11 +195,6 @@ declare const TerminatingLink: ApolloLink;
 
 declare const VersionLink: ApolloLink;
 
-type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'>;
-declare class QuilttClient extends ApolloClient<NormalizedCacheObject> {
-    constructor(options: QuilttClientOptions<NormalizedCacheObject>);
-}
-
 type FetchResponse<T> = {
     data: T;
     status: number;
@@ -287,9 +298,16 @@ declare class InstitutionsAPI {
     search: (token: string, connectorId: string, term: string, signal?: AbortSignal) => Promise<FetchResponse<Search>>;
     private config;
     private validateStatus;
-    private body;
 }
 
+declare const debugging: boolean;
+declare const version: string;
+declare const cdnBase: string;
+declare const endpointAuth: string;
+declare const endpointGraphQL: string;
+declare const endpointRest: string;
+declare const endpointWebsockets: string;
+
 /** Utility types to extend default TS utilities */
 type Maybe<T> = T | null;
 type InputMaybe<T> = Maybe<T>;
@@ -317,6 +335,31 @@ type DeepReadonly<T> = T extends object ? {
     [P in keyof T]: DeepReadonly<T[P]>;
 } : T;
 
+type RegisteredClaims = {
+    iss: string;
+    sub: string;
+    aud: string;
+    exp: number;
+    nbf: number;
+    iat: number;
+    jti: string;
+};
+type PrivateClaims = {
+    oid: string;
+    eid: string;
+    cid: string;
+    aid: string;
+    ver: number;
+    rol: 'basic' | 'core' | 'manager' | 'super-admin';
+};
+type Claims<T> = RegisteredClaims & T;
+type JsonWebToken<T> = {
+    token: string;
+    claims: Claims<T>;
+};
+type QuilttJWT = JsonWebToken<PrivateClaims>;
+declare const JsonWebTokenParse: <T>(token: Maybe<string> | undefined) => Maybe<JsonWebToken<T>> | undefined;
+
 type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
 /**
  * This is designed to support singletons to share the memory states across all
@@ -326,7 +369,7 @@ type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
 declare class Observable<T> {
     private state?;
     private observers;
-    constructor(initalState?: Maybe<T>);
+    constructor(initialState?: Maybe<T>);
     get: () => Maybe<T> | undefined;
     set: (nextState: Maybe<T> | undefined) => void;
     subscribe: (observer: Observer<T>) => void;
@@ -336,19 +379,29 @@ declare class Observable<T> {
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */
-declare class LocalStorage<T> {
+declare class LocalStorage<T = any> {
     private observers;
-    constructor();
+    private readonly keyPrefix;
+    constructor(keyPrefix?: string);
     isEnabled: () => boolean;
     isDisabled: () => boolean;
     get: (key: string) => Maybe<T> | undefined;
     set: (key: string, state: Maybe<T> | undefined) => void;
     remove: (key: string) => void;
-    subscribe: (key: string, observer: Observer<T>) => void;
+    has: (key: string) => boolean;
+    clear: () => void;
+    subscribe: (key: string, observer: Observer<T>) => (() => void);
     unsubscribe: (key: string, observer: Observer<T>) => void;
+    keys: () => string[];
+    private getFullKey;
+    /**
+     * Handle storage events from other windows/tabs
+     * If there is a key, then trigger the related updates. If there is no key
+     * it means that a record has been removed and everything needs to be rechecked.
+     */
     private handleStorageEvent;
 }
 
@@ -410,39 +463,6 @@ declare class Storage<T> {
  */
 declare const GlobalStorage: Storage<any>;
 
-declare const debugging: boolean;
-declare const version: string;
-declare const cdnBase: string;
-declare const endpointAuth: string;
-declare const endpointGraphQL: string;
-declare const endpointRest: string;
-declare const endpointWebsockets: string;
-
-type RegisteredClaims = {
-    iss: string;
-    sub: string;
-    aud: string;
-    exp: number;
-    nbf: number;
-    iat: number;
-    jti: string;
-};
-type PrivateClaims = {
-    oid: string;
-    eid: string;
-    cid: string;
-    aid: string;
-    ver: number;
-    rol: 'basic' | 'core' | 'manager' | 'super-admin';
-};
-type Claims<T> = RegisteredClaims & T;
-type JsonWebToken<T> = {
-    token: string;
-    claims: Claims<T>;
-};
-type QuilttJWT = JsonWebToken<PrivateClaims>;
-declare const JsonWebTokenParse: <T>(token: Maybe<string> | undefined) => Maybe<JsonWebToken<T>> | undefined;
-
 /**
  * This is designed to support singletons to timeouts that can broadcast
  * to any observers, preventing race conditions with multiple timeouts.

package/dist/index.js

@@ -1,7 +1,7 @@
 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-client-BNmSIP63.js';
-export { L as LocalStorage, M as MemoryStorage, O as Observable, c as Storage, f as cdnBase, g as endpointWebsockets } from './SubscriptionLink-client-BNmSIP63.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-C9j_SmFl.js';
+export { L as LocalStorage, M as MemoryStorage, O as Observable, g as Storage, c as cdnBase, f as endpointWebsockets } from './SubscriptionLink-12s-C9j_SmFl.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';
@@ -101,6 +101,9 @@ class QuilttClient extends ApolloClient {
                 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');
@@ -111,6 +114,7 @@ class QuilttClient extends ApolloClient {
         const authLink = new AuthLink();
         const subscriptionsLink = new SubscriptionLink();
         const quilttLink = ApolloLink.from([
+            ...initialLinks,
             VersionLink,
             authLink,
             ErrorLink,
@@ -276,7 +280,7 @@ class InstitutionsAPI {
             const headers = new Headers();
             headers.set('Content-Type', 'application/json');
             headers.set('Accept', 'application/json');
-            headers.set('X-Quiltt-SDK-Agent', this.agent);
+            headers.set('Quiltt-SDK-Agent', this.agent);
             headers.set('Authorization', `Bearer ${token}`);
             return {
                 headers,
@@ -285,17 +289,6 @@ class InstitutionsAPI {
             };
         };
         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;
         this.agent = agent;
     }
@@ -329,7 +322,10 @@ const JsonWebTokenParse = (token)=>{
             if (this.timeout) {
                 clearTimeout(this.timeout);
             }
-            this.observers.push(callback);
+            // Replace all observers with the new one
+            this.observers = [
+                callback
+            ];
             this.timeout = setTimeout(this.broadcast.bind(this), delay);
         };
         this.clear = (observer)=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quiltt/core",
-  "version": "4.2.3",
+  "version": "4.3.1",
   "description": "Javascript API client and utilities for Quiltt",
   "keywords": [
     "quiltt",
@@ -32,21 +32,21 @@
   ],
   "main": "dist/index.js",
   "dependencies": {
-    "@apollo/client": "^3.12.4",
-    "@rails/actioncable": "^7.2.201",
+    "@apollo/client": "^3.14.0",
+    "@rails/actioncable": "^8.0.300",
     "braces": "^3.0.3",
     "cross-fetch": "^4.0.0",
     "graphql": "^16.10.0",
     "graphql-ruby-client": "^1.14.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@types/node": "22.18.1",
+    "@biomejs/biome": "2.2.4",
+    "@types/node": "22.18.6",
     "@types/rails__actioncable": "6.1.11",
-    "@types/react": "18.3.20",
-    "bunchee": "6.3.4",
+    "@types/react": "18.3.23",
+    "bunchee": "6.6.0",
     "rimraf": "6.0.1",
-    "typescript": "5.8.3"
+    "typescript": "5.9.2"
   },
   "tags": [
     "quiltt"

package/src/Observable.ts

@@ -1,4 +1,5 @@
 import type { Dispatch, SetStateAction } from 'react'
+
 import type { Maybe } from './types'
 
 export type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>
@@ -12,8 +13,8 @@ export class Observable<T> {
   private state?: Maybe<T>
   private observers: Observer<T>[] = []
 
-  constructor(initalState?: Maybe<T>) {
-    this.state = initalState
+  constructor(initialState?: Maybe<T>) {
+    this.state = initialState
   }
 
   get = () => {
@@ -24,7 +25,9 @@ export class Observable<T> {
     if (this.state === nextState) return
 
     this.state = nextState
-    this.observers.forEach((update) => update(nextState))
+    this.observers.forEach((update) => {
+      update(nextState)
+    })
   }
 
   subscribe = (observer: Observer<T>) => {

package/src/Timeoutable.ts

@@ -13,7 +13,8 @@ export class Timeoutable {
       clearTimeout(this.timeout)
     }
 
-    this.observers.push(callback)
+    // Replace all observers with the new one
+    this.observers = [callback]
     this.timeout = setTimeout(this.broadcast.bind(this), delay)
   }
 

package/src/api/browser.ts

@@ -112,6 +112,10 @@ export type ConnectorSDKCallbackMetadata = {
   profileId?: string
   /** The ID of the Connection that was created or reconnected */
   connectionId?: string
+  /** The Connector Session Object */
+  connectorSession?: {
+    id: string
+  }
 }
 
 /**
@@ -132,15 +136,16 @@ export type ConnectorSDKReconnectOptions = ConnectorSDKCallbacks & {
   connectionId: string
 }
 
-/** Options to initialize Connector */
-// @todo: refactor into a union type - it's either or.
+/** Options to initialize Connector
+ *
+ *  @todo: refactor into a union type - it's either or.
+ *  Union types only allow direct access to properties that exist on all branches, not properties unique to individual branches.
+ */
 export type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
   /** The Institution ID or search term to connect */
   institution?: string
-
   /** The ID of the Connection to reconnect */
   connectionId?: string
-
   /** The nonce to use for the script tag */
   nonce?: string
 }

package/src/api/graphql/client.ts

@@ -3,6 +3,7 @@ import { ApolloClient, ApolloLink } from '@apollo/client/core/index.js'
 import type { DefinitionNode, OperationDefinitionNode } from 'graphql'
 
 import { debugging } from '@/configuration'
+
 import {
   AuthLink,
   BatchHttpLink,
@@ -14,7 +15,10 @@ import {
   VersionLink,
 } from './links'
 
-export type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'>
+export type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'> & {
+  /** An array of initial links to inject before the default Quiltt Links */
+  customLinks?: ApolloLink[]
+}
 
 export class QuilttClient extends ApolloClient<NormalizedCacheObject> {
   constructor(options: QuilttClientOptions<NormalizedCacheObject>) {
@@ -25,6 +29,8 @@ export class QuilttClient extends ApolloClient<NormalizedCacheObject> {
       },
     }
 
+    const initialLinks = options.customLinks ? [...options.customLinks] : []
+
     const isOperationDefinition = (def: DefinitionNode): def is OperationDefinitionNode =>
       def.kind === 'OperationDefinition'
 
@@ -41,7 +47,13 @@ export class QuilttClient extends ApolloClient<NormalizedCacheObject> {
     const authLink = new AuthLink()
     const subscriptionsLink = new SubscriptionLink()
 
-    const quilttLink = ApolloLink.from([VersionLink, authLink, ErrorLink, RetryLink])
+    const quilttLink = ApolloLink.from([
+      ...initialLinks,
+      VersionLink,
+      authLink,
+      ErrorLink,
+      RetryLink,
+    ])
       .split(isSubscriptionOperation, subscriptionsLink, ForwardableLink)
       .split(isBatchable, BatchHttpLink, HttpLink)
 
@@ -58,10 +70,9 @@ export class QuilttClient extends ApolloClient<NormalizedCacheObject> {
 */
 
 /** Client and Tooling */
-export { gql } from '@apollo/client/core/index.js'
+export type { NormalizedCacheObject } from '@apollo/client/cache'
 export { InMemoryCache } from '@apollo/client/cache/index.js'
 export type { ApolloError, OperationVariables } from '@apollo/client/core'
-export type { NormalizedCacheObject } from '@apollo/client/cache'
-
+export { gql } from '@apollo/client/core/index.js'
 /** React hooks used by @quiltt/react-native and @quiltt/react */
 export { useMutation, useQuery, useSubscription } from '@apollo/client/react/hooks/index.js'

package/src/api/graphql/index.ts

@@ -1,2 +1,2 @@
-export * from './links'
 export * from './client'
+export * from './links'

package/src/api/graphql/links/ActionCableLink.ts

@@ -1,9 +1,8 @@
 import type { FetchResult, NextLink, Operation } from '@apollo/client/core'
 import { ApolloLink } from '@apollo/client/core/index.js'
 import { Observable } from '@apollo/client/utilities/index.js'
-
-import { createConsumer } from '@rails/actioncable'
 import type { Consumer } from '@rails/actioncable'
+import { createConsumer } from '@rails/actioncable'
 import { print } from 'graphql'
 
 import { endpointWebsockets } from '@/configuration'

package/src/api/graphql/links/BatchHttpLink.ts

@@ -1,4 +1,4 @@
-import { BatchHttpLink as ApolloHttpLink } from '@apollo/client/link/batch-http/index.js'
+import { BatchHttpLink as ApolloBatchHttpLink } from '@apollo/client/link/batch-http/index.js'
 import crossfetch from 'cross-fetch'
 
 import { endpointGraphQL } from '@/configuration'
@@ -6,7 +6,7 @@ import { endpointGraphQL } from '@/configuration'
 // Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
 const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch
 
-export const BatchHttpLink = new ApolloHttpLink({
+export const BatchHttpLink = new ApolloBatchHttpLink({
   uri: endpointGraphQL,
   fetch: effectiveFetch,
 })

package/src/api/rest/institutions.ts

@@ -43,7 +43,7 @@ export class InstitutionsAPI {
     const headers = new Headers()
     headers.set('Content-Type', 'application/json')
     headers.set('Accept', 'application/json')
-    headers.set('X-Quiltt-SDK-Agent', this.agent)
+    headers.set('Quiltt-SDK-Agent', this.agent)
     headers.set('Authorization', `Bearer ${token}`)
 
     return {
@@ -55,16 +55,16 @@ export class InstitutionsAPI {
 
   private validateStatus = (status: number) => status < 500 && status !== 429
 
-  private body = (payload: any) => {
-    if (!this.clientId) {
-      console.error('Quiltt Client ID is not set. Unable to identify & authenticate')
-    }
+  // private body = (payload: any) => {
+  //   if (!this.clientId) {
+  //     console.error('Quiltt Client ID is not set. Unable to identify & authenticate')
+  //   }
 
-    return {
-      session: {
-        clientId: this.clientId,
-        ...payload,
-      },
-    }
-  }
+  //   return {
+  //     session: {
+  //       clientId: this.clientId,
+  //       ...payload,
+  //     },
+  //   }
+  // }
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from './api'
-export * from './storage'
 export * from './configuration'
 export * from './JsonWebToken'
 export * from './Observable'
+export * from './storage'
 export * from './Timeoutable'
 export * from './types'

package/src/storage/Local.ts

@@ -4,13 +4,16 @@ import type { Maybe } from '@/types'
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */
-export class LocalStorage<T> {
+export class LocalStorage<T = any> {
   private observers: { [key: string]: Observer<T>[] } = {}
+  private readonly keyPrefix: string
+
+  constructor(keyPrefix = 'quiltt') {
+    this.keyPrefix = keyPrefix
 
-  constructor() {
     if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
       window.addEventListener('storage', this.handleStorageEvent.bind(this))
     }
@@ -18,10 +21,11 @@ export class LocalStorage<T> {
 
   isEnabled = (): boolean => {
     try {
-      localStorage.setItem('quiltt.ping', 'pong')
-      localStorage.removeItem('quiltt.ping')
+      const testKey = `${this.keyPrefix}.ping`
+      localStorage.setItem(testKey, 'pong')
+      localStorage.removeItem(testKey)
       return true
-    } catch (error) {
+    } catch (_error) {
       return false
     }
   }
@@ -29,14 +33,16 @@ export class LocalStorage<T> {
   isDisabled = (): boolean => !this.isEnabled()
 
   get = (key: string): Maybe<T> | undefined => {
-    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined')
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
       return undefined
+    }
 
+    const fullKey = this.getFullKey(key)
     try {
-      const state = window.localStorage.getItem(`quiltt.${key}`)
+      const state = window.localStorage.getItem(fullKey)
       return state ? (JSON.parse(state) as T) : null
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}"`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
       return undefined
     }
   }
@@ -44,49 +50,143 @@ export class LocalStorage<T> {
   set = (key: string, state: Maybe<T> | undefined): void => {
     if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
 
+    const fullKey = this.getFullKey(key)
     try {
-      if (state) {
-        window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state))
+      if (state !== null && state !== undefined) {
+        window.localStorage.setItem(fullKey, JSON.stringify(state))
       } else {
-        window.localStorage.removeItem(`quiltt.${key}`)
+        window.localStorage.removeItem(fullKey)
       }
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}"`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
     }
   }
 
-  remove = (key: string) => {
+  remove = (key: string): void => {
     if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
 
+    const fullKey = this.getFullKey(key)
     try {
-      window.localStorage.removeItem(`quiltt.${key}`)
+      window.localStorage.removeItem(fullKey)
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}">`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
+    }
+  }
+
+  has = (key: string): boolean => {
+    return this.get(key) !== null && this.get(key) !== undefined
+  }
+
+  clear = (): void => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
+
+    try {
+      const keysToRemove: string[] = []
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key?.startsWith(`${this.keyPrefix}.`)) {
+          keysToRemove.push(key)
+        }
+      }
+      keysToRemove.forEach((key) => {
+        localStorage.removeItem(key)
+      })
+    } catch (error) {
+      console.warn(`localStorage Error during clear`, error)
+    }
+  }
+
+  subscribe = (key: string, observer: Observer<T>): (() => void) => {
+    const fullKey = this.getFullKey(key)
+
+    if (!this.observers[fullKey]) {
+      this.observers[fullKey] = []
     }
+
+    this.observers[fullKey].push(observer)
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(key, observer)
   }
 
-  subscribe = (key: string, observer: Observer<T>) => {
-    if (!this.observers[key]) this.observers[key] = []
+  unsubscribe = (key: string, observer: Observer<T>): void => {
+    const fullKey = this.getFullKey(key)
 
-    this.observers[key].push(observer)
+    if (this.observers[fullKey]) {
+      this.observers[fullKey] = this.observers[fullKey].filter((update) => update !== observer)
+
+      // Clean up empty observer arrays
+      if (this.observers[fullKey].length === 0) {
+        delete this.observers[fullKey]
+      }
+    }
   }
 
-  unsubscribe = (key: string, observer: Observer<T>) => {
-    this.observers[key] = this.observers[key]?.filter((update) => update !== observer)
+  // Get all keys that match quiltt prefix
+  keys = (): string[] => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+      return []
+    }
+
+    const keys: string[] = []
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key?.startsWith(`${this.keyPrefix}.`)) {
+          keys.push(key.replace(`${this.keyPrefix}.`, ''))
+        }
+      }
+    } catch (error) {
+      console.warn('localStorage Error getting keys', error)
+    }
+    return keys
+  }
+
+  private getFullKey = (key: string): string => {
+    return `${this.keyPrefix}.${key}`
   }
 
-  // if there is a key, then trigger the related updates. If there is not key
-  // it means that a record has been removed and everything needs to be rechecked.
-  private handleStorageEvent = (event: StorageEvent) => {
-    if (event.key?.includes('quiltt.')) {
-      const newState = event.newValue ? JSON.parse(event.newValue) : null
+  /**
+   * Handle storage events from other windows/tabs
+   * If there is a key, then trigger the related updates. If there is no key
+   * it means that a record has been removed and everything needs to be rechecked.
+   */
+  private handleStorageEvent = (event: StorageEvent): void => {
+    const isQuilttKey = event.key?.startsWith(`${this.keyPrefix}.`)
+
+    if (isQuilttKey && event.key) {
+      // Parse the new value safely
+      let newState: T | null = null
+      try {
+        newState = event.newValue ? JSON.parse(event.newValue) : null
+      } catch (error) {
+        console.warn(`Failed to parse storage event value for ${event.key}`, error)
+        return
+      }
 
       if (this.observers[event.key]) {
-        this.observers[event.key].forEach((update) => update(newState))
+        this.observers[event.key].forEach((observer) => {
+          try {
+            observer(newState)
+          } catch (error) {
+            console.warn(`Observer error for key ${event.key}`, error)
+          }
+        })
       }
-    } else {
-      Object.entries(this.observers).forEach(([key, observers]) => {
-        observers.forEach((update) => update(this.get(key)))
+    } else if (!event.key) {
+      // Storage was cleared or changed in a way that doesn't specify a key
+      // Re-check all observed keys
+      Object.entries(this.observers).forEach(([fullKey, observers]) => {
+        const shortKey = fullKey.replace(`${this.keyPrefix}.`, '')
+        const currentValue = this.get(shortKey)
+
+        observers.forEach((observer) => {
+          try {
+            observer(currentValue)
+          } catch (error) {
+            console.warn(`Observer error for key ${fullKey}`, error)
+          }
+        })
       })
     }
   }

package/src/storage/Memory.ts

@@ -1,5 +1,5 @@
-import { Observable } from '@/Observable'
 import type { Observer } from '@/Observable'
+import { Observable } from '@/Observable'
 import type { Maybe } from '@/types'
 
 /**

package/src/storage/Storage.ts

@@ -41,7 +41,9 @@ export class Storage<T> {
     this.localStore.set(key, newState)
     this.memoryStore.set(key, newState)
 
-    this.observers[key]?.forEach((update) => update(newState))
+    this.observers[key]?.forEach((update) => {
+      update(newState)
+    })
   }
 
   /**
@@ -77,7 +79,9 @@ export class Storage<T> {
       const newState = nextState instanceof Function ? nextState(prevValue) : nextState
 
       this.memoryStore.set(key, newState)
-      this.observers[key]?.forEach((update) => update(newState))
+      this.observers[key]?.forEach((update) => {
+        update(newState)
+      })
     })
   }
 }