@ethlete/query 6.0.0-next.1 → 6.0.0-next.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ethlete/query
 
+## 6.0.0-next.3
+
+### Patch Changes
+
+- [#2926](https://github.com/ethlete-io/ethdk/pull/2926) [`801d112`](https://github.com/ethlete-io/ethdk/commit/801d1122b55d24762b9e656d3a8ed70c561ec06f) Thanks [@github-actions](https://github.com/apps/github-actions)! - Fix query form emitting twice if a sort field gets cleared
+
+## 6.0.0-next.2
+
+### Minor Changes
+
+- [`252fb8f`](https://github.com/ethlete-io/ethdk/commit/252fb8fe498a129b2f2dbf8f196aec4e1f2327a3) Thanks [@TomTomB](https://github.com/TomTomB)! - Report `leaderStatusChange` and `leaderInstanceCountChange` events in bearer auth tracking feature
+
+### Patch Changes
+
+- [#2923](https://github.com/ethlete-io/ethdk/pull/2923) [`62bd4ae`](https://github.com/ethlete-io/ethdk/commit/62bd4ae092ad931fc8706ba7518cd26e17ef82a9) Thanks [@github-actions](https://github.com/apps/github-actions)! - Remove useless queryKey field from auth provider tracking events
+
 ## 6.0.0-next.1
 
 ### Patch Changes

package/fesm2022/ethlete-query.mjs

@@ -5165,6 +5165,9 @@ const setupLeaderElection = () => {
     const storageKey = 'ethlete-auth-leader-heartbeat';
     const tabId = `tab-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     const isLeader = signal(false, ...(ngDevMode ? [{ debugName: "isLeader" }] : []));
+    const instanceCount = signal(1, ...(ngDevMode ? [{ debugName: "instanceCount" }] : []));
+    const knownTabs = new Map();
+    knownTabs.set(tabId, Date.now());
     let channel = null;
     let heartbeatIntervalId = null;
     let leaderCheckIntervalId = null;
@@ -5172,6 +5175,7 @@ const setupLeaderElection = () => {
         isLeader.set(true);
         return {
             isLeader: isLeader.asReadonly(),
+            instanceCount: instanceCount.asReadonly(),
             becomeLeader: () => {
                 /* no-op */
             },
@@ -5181,6 +5185,7 @@ const setupLeaderElection = () => {
         };
     }
     channel = new BroadcastChannel(channelName);
+    channel.postMessage({ type: 'instance-register', tabId });
     const updateLeaderHeartbeat = (newTabId = tabId) => {
         try {
             localStorage.setItem(storageKey, JSON.stringify({ tabId: newTabId, timestamp: Date.now() }));
@@ -5227,48 +5232,60 @@ const setupLeaderElection = () => {
         const heartbeat = getLeaderHeartbeat();
         const now = Date.now();
         if (!heartbeat || now - heartbeat.timestamp > leaderTimeout) {
-            // No leader or leader is dead
             if (!isLeader()) {
                 becomeLeader();
             }
         }
         else if (heartbeat.tabId === tabId) {
-            // We are the leader, update heartbeat
             if (!isLeader()) {
                 isLeader.set(true);
             }
             updateLeaderHeartbeat();
         }
         else {
-            // Another tab is leader
             if (isLeader()) {
                 isLeader.set(false);
             }
         }
     };
-    // Handle messages from other tabs
     channel.onmessage = (event) => {
         const message = event.data;
         if (message.type === 'heartbeat') {
+            if (message.tabId !== tabId) {
+                knownTabs.set(message.tabId, Date.now());
+            }
             if (message.tabId !== tabId && isLeader()) {
-                // Another tab claims to be leader, resolve conflict
                 const heartbeat = getLeaderHeartbeat();
                 if (heartbeat && heartbeat.tabId === message.tabId) {
-                    // Other tab is legitimate leader
                     releaseLeadership();
                 }
             }
         }
+        else if (message.type === 'tab-heartbeat') {
+            if (message.tabId !== tabId) {
+                knownTabs.set(message.tabId, Date.now());
+            }
+        }
+        else if (message.type === 'instance-register') {
+            if (message.tabId !== tabId) {
+                knownTabs.set(message.tabId, Date.now());
+                instanceCount.set(knownTabs.size);
+                channel?.postMessage({ type: 'tab-heartbeat', tabId });
+            }
+        }
+        else if (message.type === 'instance-unregister') {
+            if (message.tabId !== tabId) {
+                knownTabs.delete(message.tabId);
+                instanceCount.set(knownTabs.size);
+            }
+        }
         else if (message.type === 'leader-claim') {
             if (message.tabId !== tabId && isLeader()) {
-                // Conflict: both tabs think they're leader
-                // Let the tab with earlier heartbeat win
                 const heartbeat = getLeaderHeartbeat();
                 if (heartbeat && heartbeat.tabId === message.tabId) {
                     releaseLeadership();
                 }
                 else {
-                    // We were leader first, send heartbeat to assert dominance
                     const assertMessage = {
                         type: 'heartbeat',
                         tabId,
@@ -5279,35 +5296,40 @@ const setupLeaderElection = () => {
         }
         else if (message.type === 'leader-release') {
             if (message.tabId !== tabId) {
-                // Leader released, try to become new leader
                 setTimeout(() => checkLeaderStatus(), 100);
             }
         }
     };
-    // Try to become leader on startup
     checkLeaderStatus();
-    // Send heartbeat periodically if we're the leader
     heartbeatIntervalId = setInterval(() => {
+        knownTabs.set(tabId, Date.now());
         if (isLeader()) {
             updateLeaderHeartbeat();
-            const message = {
-                type: 'heartbeat',
-                tabId,
-            };
-            channel?.postMessage(message);
+            channel?.postMessage({ type: 'heartbeat', tabId });
+        }
+        else {
+            channel?.postMessage({ type: 'tab-heartbeat', tabId });
+        }
+        const now = Date.now();
+        let changed = false;
+        for (const [id, lastSeen] of knownTabs) {
+            if (id !== tabId && now - lastSeen > leaderTimeout) {
+                knownTabs.delete(id);
+                changed = true;
+            }
+        }
+        if (changed) {
+            instanceCount.set(knownTabs.size);
         }
     }, heartbeatInterval);
-    // Check leader status periodically
     leaderCheckIntervalId = setInterval(() => {
         checkLeaderStatus();
     }, heartbeatInterval);
-    // Handle tab visibility changes
     const handleVisibilityChange = () => {
         if (document.hidden && isLeader()) {
             // Tab is hidden but we're leader - keep leadership but other tabs will take over if we die
         }
         else if (!document.hidden && !isLeader()) {
-            // Tab became visible and we're not leader - check if we should become leader
             checkLeaderStatus();
         }
     };
@@ -5319,10 +5341,10 @@ const setupLeaderElection = () => {
         if (leaderCheckIntervalId) {
             clearInterval(leaderCheckIntervalId);
         }
+        channel?.postMessage({ type: 'instance-unregister', tabId });
         releaseLeadership();
         document.removeEventListener('visibilitychange', handleVisibilityChange);
         channel?.close();
-        // Clean up storage if we were the leader
         const heartbeat = getLeaderHeartbeat();
         if (heartbeat?.tabId === tabId) {
             try {
@@ -5336,6 +5358,7 @@ const setupLeaderElection = () => {
     destroyRef.onDestroy(cleanup);
     return {
         isLeader: isLeader.asReadonly(),
+        instanceCount: instanceCount.asReadonly(),
         becomeLeader,
         cleanup,
     };
@@ -5602,10 +5625,15 @@ const createLeaderElection = (config) => {
     const leaderElectionEnabled = multiTabSyncEnabled &&
         (typeof multiTabSyncConfig === 'object' ? (multiTabSyncConfig?.leaderElection ?? true) : true);
     const leaderElection = leaderElectionEnabled ? setupLeaderElection() : null;
-    return () => (leaderElectionEnabled ? (leaderElection?.isLeader() ?? true) : true);
+    const isLeaderFn = () => (leaderElectionEnabled ? (leaderElection?.isLeader() ?? true) : true);
+    const leaderElectionContext = leaderElection
+        ? { isLeader: leaderElection.isLeader, instanceCount: leaderElection.instanceCount }
+        : undefined;
+    return { isLeaderFn, leaderElectionContext };
 };
 const createBearerAuthProviderImpl = (config) => {
     const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
     const queryClient = config.queryClientRef[1]();
     const accessToken = signal(null, ...(ngDevMode ? [{ debugName: "accessToken" }] : []));
     const refreshToken = signal(null, ...(ngDevMode ? [{ debugName: "refreshToken" }] : []));
@@ -5645,7 +5673,7 @@ const createBearerAuthProviderImpl = (config) => {
         bearerDecryptFn: config.bearerDecryptFn,
         queryClient,
         repository: queryClient.repository,
-        isLeader,
+        isLeader: isLeader.isLeaderFn,
         afterTokenRefresh$,
         queries: queries,
     };
@@ -5658,8 +5686,10 @@ const createBearerAuthProviderImpl = (config) => {
         bearerData,
         logout,
         injector,
+        destroyRef,
         setTokens,
-        isLeader,
+        isLeader: isLeader.isLeaderFn,
+        leaderElection: isLeader.leaderElectionContext,
         afterTokenRefresh$,
         queries: queries,
     };
@@ -6074,7 +6104,7 @@ const createTrackingFeature = (context, config) => {
             }
         }
     };
-    const emit = (event, data) => {
+    const fireHandlers = (event, data) => {
         const eventHandlers = handlers.get(event);
         if (eventHandlers) {
             eventHandlers.forEach((handler) => {
@@ -6087,6 +6117,27 @@ const createTrackingFeature = (context, config) => {
             });
         }
     };
+    const forwardingChannel = context.leaderElection && typeof BroadcastChannel !== 'undefined'
+        ? new BroadcastChannel('ethlete-auth-tracking')
+        : null;
+    if (forwardingChannel) {
+        forwardingChannel.onmessage = (messageEvent) => {
+            if (context.isLeader()) {
+                fireHandlers(messageEvent.data.event, messageEvent.data.data);
+            }
+        };
+        context.destroyRef.onDestroy(() => forwardingChannel.close());
+    }
+    const emit = (event, data) => {
+        if (forwardingChannel && !context.isLeader()) {
+            forwardingChannel.postMessage({ event, data });
+            return;
+        }
+        fireHandlers(event, data);
+    };
+    const emitDirect = (event, data) => {
+        fireHandlers(event, data);
+    };
     const trackedQueries = new Map();
     Object.entries(context.queries).forEach(([key, queryEntry]) => {
         const query = queryEntry; // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -6103,17 +6154,11 @@ const createTrackingFeature = (context, config) => {
             const prevState = trackedQueries.get(key);
             if (response && !loading && !error && prevState?.lastResult !== 'success') {
                 trackedQueries.set(key, { loading: false, lastResult: 'success' });
-                emit(`${key}Success`, {
-                    queryKey: key,
-                    snapshot,
-                });
+                emit(`${key}Success`, { snapshot });
             }
             if (error && !loading && prevState?.lastResult !== 'error') {
                 trackedQueries.set(key, { loading: false, lastResult: 'error' });
-                emit(`${key}Failure`, {
-                    queryKey: key,
-                    error,
-                });
+                emit(`${key}Failure`, { error });
             }
             if (loading) {
                 trackedQueries.set(key, { loading: true, lastResult: null });
@@ -6143,6 +6188,17 @@ const createTrackingFeature = (context, config) => {
             }
         });
     }
+    if (context.leaderElection) {
+        const { isLeader: isLeaderSignal, instanceCount: instanceCountSignal } = context.leaderElection;
+        effect(() => {
+            emitDirect('leaderStatusChange', { isLeader: isLeaderSignal() });
+        });
+        effect(() => {
+            emitDirect('leaderInstanceCountChange', {
+                count: instanceCountSignal(),
+            });
+        });
+    }
     return {
         on,
         off,
@@ -6966,8 +7022,11 @@ class QueryForm {
                 continue;
             const valueGotRemoved = value === ET_PROPERTY_REMOVED;
             if (valueGotRemoved) {
-                field.control.setValue(this._getDefaultValue(key), { emitEvent: false });
-                didValueChanges = true;
+                const defaultValue = this._getDefaultValue(key);
+                if (!equal(field.control.value, defaultValue)) {
+                    field.control.setValue(defaultValue, { emitEvent: false });
+                    didValueChanges = true;
+                }
                 continue;
             }
             let deserializedValue = value;
@@ -7139,6 +7198,21 @@ class QueryForm {
         });
     }
     _handleFormChange(forceOverwrite = false) {
+        // Normalize values that have a valueToQueryParamTransformFn returning null/undefined to their
+        // field default before capturing the new value. This prevents intermediate "empty object" states
+        // (e.g. Sort emitting { active: '', direction: '' } when cleared) from being
+        // emitted as distinct form values.
+        for (const [key, field] of Object.entries(this._fields)) {
+            if (!field.data.valueToQueryParamTransformFn)
+                continue;
+            const rawValue = this._formValue[key];
+            if (this._isDefaultValue(key, rawValue))
+                continue;
+            const serialized = field.data.valueToQueryParamTransformFn(rawValue);
+            if (serialized !== null && serialized !== undefined)
+                continue;
+            this.form.controls[key]?.setValue(this._getDefaultValue(key), { emitEvent: false });
+        }
         const currentVal = clone(this._currentFormValue$.value);
         const newVal = clone(this._formValue);
         if (equal(currentVal, newVal)) {