@squidcloud/client 1.0.147 → 1.0.148

package/dist/cjs/index.js

@@ -36764,7 +36764,7 @@ function serialization_normalizeJsonAsString(json) {
 }
 function serialization_serializeObj(obj) {
     if (obj === undefined)
-        return null;
+        return null; // TODO: change method signature.
     const objWithReplacedDates = lodash.cloneDeepWith(obj, value => {
         return lodash.isDate(value) ? { $date: value.toISOString() } : undefined;
     });
@@ -36813,9 +36813,6 @@ function decodeValueForMapping(encodedString) {
     }
     return deserializeObj(decodedValue);
 }
-function recodeValue(value) {
-    return decodeValueForMapping(encodeValueForMapping(value));
-}
 
 ;// CONCATENATED MODULE: ../common/src/query.types.ts
 
@@ -42178,24 +42175,37 @@ class DataManager {
          * change, it will not apply it in the document store but the query will still be notified.
          */
         let someDocumentsWereOutdated = false;
-        const squidIds = new Set();
+        const updatedDocIds = new Set();
+        const staleDocIds = new Set();
         for (const [squidDocId, incomingUpdateItem] of Object.entries(squidDocIdToNewData)) {
             const existingPendingIncomingUpdate = this.pendingIncomingUpdates.get(squidDocId);
             const timestampMetadata = this.docIdToServerTimestamp.get(squidDocId);
             if (existingPendingIncomingUpdate && existingPendingIncomingUpdate.timestamp > incomingUpdateItem.timestamp) {
-                /** There is a pending update with later timestamp fo the document - skip notifying this query. */
+                /** There is a pending update with later timestamp for the document - skip notifying this query. */
                 someDocumentsWereOutdated = true;
+                continue;
             }
-            else if (!(timestampMetadata && timestampMetadata.timestamp > incomingUpdateItem.timestamp)) {
-                /** If the client knows of a later timestamp for this document, there is no need to apply the update. */
+            if (!(timestampMetadata && timestampMetadata.timestamp > incomingUpdateItem.timestamp)) {
+                /** If the client does not know of a later timestamp for this document, apply the update. */
                 this.pendingIncomingUpdates.set(squidDocId, incomingUpdateItem);
-                squidIds.add(squidDocId);
+                updatedDocIds.add(squidDocId);
+            }
+            else {
+                /**
+                 * If the client knows of a later timestamp for this document, consider the incoming update as stale.
+                 * Since the ClientRequestId -> SquidDocId mapping may have been cleared before the updated, we still
+                 * need to refresh the map of ongoing queries to local documents.
+                 */
+                staleDocIds.add(squidDocId);
             }
         }
         this.runInTransactionSync(() => {
-            for (const squidDocId of squidIds) {
+            for (const squidDocId of updatedDocIds) {
                 this.maybeApplyIncomingUpdate(squidDocId);
             }
+            for (const squidDocId of staleDocIds) {
+                this.refreshQueryMapping(squidDocId);
+            }
         }, transactionId).then();
         return someDocumentsWereOutdated;
     }
@@ -42212,7 +42222,11 @@ class DataManager {
         this.docIdToLocalTimestamp.set(squidDocId, incomingUpdate.timestamp);
         /** The incomingUpdate was applied locally - remove it from pendingIncomingUpdates. */
         this.pendingIncomingUpdates.delete(squidDocId);
-        const allClientRequestIds = this.querySubscriptionManager.setClientRequestIdsForLocalDoc(squidDocId, incomingUpdate.properties);
+        this.refreshQueryMapping(squidDocId);
+    }
+    refreshQueryMapping(squidDocId) {
+        const doc = this.documentStore.getDocumentOrUndefined(squidDocId);
+        const allClientRequestIds = this.querySubscriptionManager.setClientRequestIdsForLocalDoc(squidDocId, doc);
         allClientRequestIds.forEach(clientRequestId => {
             this.batchClientRequestIds.add(clientRequestId);
         });
@@ -42220,8 +42234,8 @@ class DataManager {
          * If the document was not deleted but there are no longer ongoing queries that will keep this document up-to-date,
          * we consider the document "forgotten" and mark the docIdToServerTimestamp with expireTimestamp.
          */
-        if (incomingUpdate.properties) {
-            if (!this.querySubscriptionManager.findQueriesForDocument(incomingUpdate.properties, squidDocId).length) {
+        if (doc) {
+            if (!this.querySubscriptionManager.findQueriesForDocument(doc, squidDocId).length) {
                 this.forgetDocument(squidDocId);
             }
         }
@@ -56303,25 +56317,26 @@ class QuerySubscriptionManager {
         return (0,dist.truthy)(this.ongoingQueries.get(clientRequestId), 'UNKNOWN_QUERY').query;
     }
     /**
-     * A query receives updates from two different sources:
+     * A query receives updates from three different sources:
      * 1 - An initial snapshot from the server or from a parent query
      * 2 - Incremental updates from the server (or from a parent query before the query is registered)
+     * 3 - A new snapshot if the query is refreshed after connection has been lost.
      *
      * If an incremental update is received before the snapshot was received, we cannot process it for this query.
      * This boolean indicates whether the initial snapshot was received.
      */
     setGotInitialResult(clientRequestId) {
         const ongoingQuery = this.ongoingQueries.get(clientRequestId);
-        /** If this query already got initial result from the server, it means that the query is able to accept incremental
-         *  updates. In this case we should clear the mapping we have for this clientRequestId
-         * since new updated mapping will be created.
+        /**
+         * If this query already got initial result from the server, it means that the query is able to accept incremental
+         * updates. In this case we should clear the mapping we have for this clientRequestId since a new updated mapping
+         * will be created when applying the update.
          */
-        if (!ongoingQuery || ongoingQuery.gotInitialResponse) {
-            this.removeClientRequestIdMapping(clientRequestId);
-            return;
+        this.removeClientRequestIdMapping(clientRequestId);
+        if (ongoingQuery) {
+            ongoingQuery.gotInitialResponse = true;
+            ongoingQuery.isInFlight = false;
         }
-        ongoingQuery.gotInitialResponse = true;
-        ongoingQuery.isInFlight = false;
     }
     /** Given a document, returns all the queries that should be notified with the new document properties. */
     findQueriesForDocument(doc, squidDocId) {
@@ -57258,7 +57273,7 @@ class RpcManager {
                 }
             }
             catch (e) {
-                if (e instanceof external_axios_namespaceObject.AxiosError) {
+                if (e === null || e === void 0 ? void 0 : e.isAxiosError) {
                     const response = e.response;
                     if (!response)
                         throw e;
@@ -57890,6 +57905,21 @@ class Squid {
     constructor(options) {
         this.options = options;
         this.destructManager = new DestructManager();
+        // Note: The following methods are bound using arrow functions to ensure that if a user accesses the methods via
+        // destructuring (i.e. `{ setAuthProvider } = squid`) then `this` will still be bound to the Squid class.
+        /**
+         * Sets the authorization access token (OAuth2.0) provider that will be sent to the server and will be used for
+         * providing the `auth` object to the security rules.
+         *
+         * @param authProvider The OAuth2.0 access token provider invoked for every backend request by Squid.
+         *    When the provider returns undefined, no authorization information is sent.
+         *    When a new provider is set, all future Squid backend requests will use the new token provider, and exising
+         *    in-flight requests won't be affected.
+         * @returns void.
+         */
+        this.setAuthProvider = (authProvider) => {
+            this.authManager.setAuthProvider(authProvider);
+        };
         /**
          * Returns a reference to the collection in the provided integration.
          *
@@ -58127,21 +58157,6 @@ class Squid {
     static getInstances() {
         return Object.values(Squid.squidInstancesMap);
     }
-    // Note: The following methods are bound using arrow functions to ensure that if a user accesses the methods via
-    // destructuring (i.e. `{ setAuthProvider } = squid`) then `this` will still be bound to the Squid class.
-    /**
-     * Sets the authorization access token (OAuth2.0) provider that will be sent to the server and will be used for
-     * providing the `auth` object to the security rules.
-     *
-     * @param authProvider The OAuth2.0 access token provider invoked for every backend request by Squid.
-     *    When the provider returns undefined, no authorization information is sent.
-     *    When a new provider is set, all future Squid backend requests will use the new token provider, and exising
-     *    in-flight requests won't be affected.
-     * @returns void
-     */
-    setAuthProvider(authProvider) {
-        this.authManager.setAuthProvider(authProvider);
-    }
     get secrets() {
         return (() => {
             return this.secretClient;

package/dist/common/src/utils/serialization.d.ts

@@ -1,6 +1,5 @@
 export declare function normalizeJsonAsString(json: any): string;
-export declare function serializeObj(obj: any): string;
+export declare function serializeObj(obj: unknown): string;
 export declare function deserializeObj<T = any>(str: string): T;
 export declare function encodeValueForMapping(value: any): string;
 export declare function decodeValueForMapping(encodedString: string): any;
-export declare function recodeValue(value: any): any;

package/dist/typescript-client/src/backend-function.manager.d.ts

@@ -5,5 +5,5 @@ export declare class BackendFunctionManager {
     private readonly clientIdService;
     private readonly rpcManager;
     constructor(clientIdService: ClientIdService, rpcManager: RpcManager);
-    executeFunctionAndSubscribe<T>(functionName: string, ...params: any[]): Observable<T>;
+    executeFunctionAndSubscribe<T>(functionName: string, ...params: unknown[]): Observable<T>;
 }

package/dist/typescript-client/src/data.manager.d.ts

@@ -1,10 +1,10 @@
 import { DocTimestamp, LockManager, Mutation, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { QuerySender } from './query/query-sender';
 import { DestructManager } from './destruct.manager';
 import DocumentIdentityService from './document-identity.service';
 import { DocumentStore } from './document-store';
 import { MutationSender } from './mutation/mutation-sender';
 import { QueryBuilderFactory } from './query/query-builder.factory';
+import { QuerySender } from './query/query-sender';
 import { QuerySubscriptionManager } from './query/query-subscription.manager';
 import { SocketManager } from './socket.manager';
 import { TransactionId } from './types';
@@ -117,6 +117,7 @@ export declare class DataManager {
      */
     private applyIncomingUpdates;
     private maybeApplyIncomingUpdate;
+    private refreshQueryMapping;
     private destruct;
     private stopDeleteExpiredTimestampsJob;
     /**

package/dist/typescript-client/src/query/query-subscription.manager.d.ts

@@ -48,9 +48,10 @@ export declare class QuerySubscriptionManager {
      */
     getQuery(clientRequestId: ClientRequestId): Query;
     /**
-     * A query receives updates from two different sources:
+     * A query receives updates from three different sources:
      * 1 - An initial snapshot from the server or from a parent query
      * 2 - Incremental updates from the server (or from a parent query before the query is registered)
+     * 3 - A new snapshot if the query is refreshed after connection has been lost.
      *
      * If an incremental update is received before the snapshot was received, we cannot process it for this query.
      * This boolean indicates whether the initial snapshot was received.

package/dist/typescript-client/src/squid.d.ts

@@ -129,9 +129,9 @@ export declare class Squid {
      *    When the provider returns undefined, no authorization information is sent.
      *    When a new provider is set, all future Squid backend requests will use the new token provider, and exising
      *    in-flight requests won't be affected.
-     * @returns void
+     * @returns void.
      */
-    setAuthProvider(authProvider: SquidAuthProvider): void;
+    setAuthProvider: (authProvider: SquidAuthProvider) => void;
     /**
      * Returns a reference to the collection in the provided integration.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.147",
+  "version": "1.0.148",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",
@@ -13,6 +13,7 @@
     "build:dev": "webpack --mode=development",
     "build:prod": "webpack --mode=production",
     "watch": "webpack --watch",
+    "lint": "eslint . --ext .ts",
     "test": "jest --detectOpenHandles",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
@@ -32,7 +33,7 @@
   "license": "ISC",
   "dependencies": {
     "@apollo/client": "^3.7.4",
-    "@squidcloud/common": "1.0.147",
+    "@squidcloud/common": "1.0.148",
     "@supercharge/promise-pool": "^2.3.2",
     "axios": "^1.6.2",
     "cross-fetch": "^3.1.5",