@squidcloud/client 1.0.113 → 1.0.115

package/dist/cjs/index.js

@@ -28869,33 +28869,28 @@ const ExecuteFunctionSecureAnnotations = (/* unused pure expression or super */
     'secureAiAssistantMutation',
 ]));
 /** @internal */
-function transformParams(args, executeFunctionAnnotationType) {
+function transformParams(params, executeFunctionAnnotationType) {
     switch (executeFunctionAnnotationType) {
-        case 'webhook':
-        case 'executable':
-        case 'trigger':
-        case 'transformRead':
-        case 'transformWrite':
-        case 'metadata':
-            return args;
         case 'scheduler':
             return [];
         case 'secureQuery':
-            return [new QueryContext(args[0].query)];
+            return [new QueryContext(params[0].query)];
         case 'secureMutation':
-            return [new MutationContext(args[0].mutation, args[0].beforeAndAfterDocs, args[0].serverTimestamp)];
+            return [new MutationContext(params[0].mutation, params[0].beforeAndAfterDocs, params[0].serverTimestamp)];
         case 'secureNamedQuery':
-            return [new NamedQueryContext(args[0])];
+            return [new NamedQueryContext(params[0])];
         case 'secureDistributedLock':
-            return [new DistributedLockContext(args[0].mutex, args[0].exclusive)];
+            return [new DistributedLockContext(params[0].mutex, params[0].exclusive)];
         case 'secureGraphQL':
-            return [new GraphqlContext(args[0])];
+            return [new GraphqlContext(params[0])];
         case 'secureApi':
-            return [new ApiCallContext(args[0])];
+            return [new ApiCallContext(params[0])];
         case 'secureAiAssistantChat':
-            return [new AiAssistantChatContext(args[0])];
+            return [new AiAssistantChatContext(params[0])];
         case 'secureAiAssistantMutation':
-            return [new AiAssistantMutationContext(args[0])];
+            return [new AiAssistantMutationContext(params[0])];
+        default:
+            return params;
     }
 }
 /** @internal */
@@ -29680,6 +29675,17 @@ const MessageFromClientSchema = {
     ],
 };
 
+;// CONCATENATED MODULE: ../common/src/socket.types.ts
+var ClientConnectionState;
+(function (ClientConnectionState) {
+    // The client just connected to the socket
+    ClientConnectionState["CONNECTED"] = "CONNECTED";
+    // The client disconnected from the socket but Squid still keeps the clientID in case the client reconnects
+    ClientConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    // The client disconnected from the socket and Squid removed the clientID
+    ClientConnectionState["REMOVED"] = "REMOVED";
+})(ClientConnectionState || (ClientConnectionState = {}));
+
 ;// CONCATENATED MODULE: ../common/src/time-units.ts
 /** @internal */
 const SECONDS_PER_MINUTE = 60;
@@ -32806,7 +32812,7 @@ var promise_pool_dist = __webpack_require__(3910);
 /** Two transactions cannot run in parallel - this mutex is used for blocking a second transaction. */
 const RUN_IN_TRANSACTION_MUTEX = 'dataManager_runInTransaction';
 class DataManager {
-    constructor(documentStore, mutationSender, socketManager, querySubscriptionManager, queryBuilderFactory, lockManager, destructManager, documentIdentityService) {
+    constructor(documentStore, mutationSender, socketManager, querySubscriptionManager, queryBuilderFactory, lockManager, destructManager, documentIdentityService, querySender) {
         this.documentStore = documentStore;
         this.mutationSender = mutationSender;
         this.socketManager = socketManager;
@@ -32815,6 +32821,7 @@ class DataManager {
         this.lockManager = lockManager;
         this.destructManager = destructManager;
         this.documentIdentityService = documentIdentityService;
+        this.querySender = querySender;
         this.docIdToLocalTimestamp = new Map();
         /**
          * During a batch, any update to a document that may trigger an update to a query is collected here and once the batch
@@ -32893,7 +32900,7 @@ class DataManager {
              * We  should not send queries to the server before we know that all outgoing updates were
              * applied on the server.
              */
-            this.querySubscriptionManager.safeToSendQueriesToServer.next(isEmpty);
+            this.querySender.safeToSendQueriesToServer.next(isEmpty);
         });
     }
     getProperties(squidDocId) {
@@ -32927,7 +32934,7 @@ class DataManager {
     async runInTransaction(fn, transactionId) {
         if (transactionId) {
             assert_assertTruthy(transactionId === this.currentTransactionId, 'Transaction already ended.');
-            return fn(transactionId).then((ignored) => Promise.resolve());
+            return fn(transactionId).then(() => Promise.resolve());
         }
         if (this.lockManager.canGetLock(RUN_IN_TRANSACTION_MUTEX)) {
             this.lockManager.lockSync(RUN_IN_TRANSACTION_MUTEX);
@@ -33050,12 +33057,9 @@ class DataManager {
                 this.handleIncomingMutations(notification.payload);
             });
         });
-        this.socketManager
-            .observeNotifications()
-            .pipe((0,external_rxjs_namespaceObject.filter)((notification) => notification.type === 'query'), map_map((n) => n))
-            .subscribe((notification) => {
+        this.querySubscriptionManager.observeQueryResults().subscribe((queryResult) => {
             this.outgoingMutationsEmpty.pipe((0,external_rxjs_namespaceObject.filter)(Boolean), (0,external_rxjs_namespaceObject.take)(1)).subscribe(() => {
-                this.handleIncomingQuerySnapshots(notification.payload);
+                this.handleIncomingQuerySnapshots(queryResult);
             });
         });
     }
@@ -33288,7 +33292,7 @@ class DataManager {
     async sendMutationsForIntegration(outgoingMutations, integrationId) {
         try {
             const { timestamp, idResolutionMap = {}, refreshList = [], } = await this.mutationSender.sendMutations(outgoingMutations.map((outgoingMutation) => outgoingMutation.mutation), integrationId);
-            await this.documentIdentityService.migrate(idResolutionMap);
+            this.documentIdentityService.migrate(idResolutionMap);
             refreshList.forEach((docId) => {
                 this.refreshDocIdToTimestamp.set(idResolutionMap[docId] || docId, timestamp);
             });
@@ -47024,16 +47028,16 @@ class GraphQLClientFactory {
 ;// CONCATENATED MODULE: ./src/mutation/mutation-sender.ts
 
 class MutationSender {
-    constructor(rpcManager, lockManager, querySubscriptionManager) {
+    constructor(rpcManager, lockManager, querySender) {
         this.rpcManager = rpcManager;
         this.lockManager = lockManager;
-        this.querySubscriptionManager = querySubscriptionManager;
+        this.querySender = querySender;
     }
     async sendMutations(mutations, integrationId) {
         const reducedMutations = reduceMutations(mutations);
         const mutexes = reducedMutations.map((mutation) => `sendMutation_${getSquidDocId(mutation.squidDocIdObj)}`);
         await this.lockManager.lock(...mutexes);
-        await this.querySubscriptionManager.waitForAllQueriesToFinish();
+        await this.querySender.waitForAllQueriesToFinish();
         try {
             const request = {
                 mutations: reducedMutations,
@@ -47602,36 +47606,33 @@ function getStateInPath(obj, path) {
 class SubscriptionData {
 }
 
+;// CONCATENATED MODULE: ./src/query/query.types.ts
+var LimitUnderflowState;
+(function (LimitUnderflowState) {
+    LimitUnderflowState[LimitUnderflowState["UNKNOWN"] = 0] = "UNKNOWN";
+    LimitUnderflowState[LimitUnderflowState["DISABLED"] = 1] = "DISABLED";
+    LimitUnderflowState[LimitUnderflowState["ENABLED"] = 2] = "ENABLED";
+})(LimitUnderflowState || (LimitUnderflowState = {}));
+
 ;// CONCATENATED MODULE: ./src/query/query-subscription.manager.ts
 
 
 
 
 
+
 // See limitUnderflowState below.
 // Exported only for tests
 const FETCH_BEYOND_LIMIT = 100;
 const LIMIT_UNDERFLOW_TRIGGER = 20;
-var LimitUnderflowState;
-(function (LimitUnderflowState) {
-    LimitUnderflowState[LimitUnderflowState["UNKNOWN"] = 0] = "UNKNOWN";
-    LimitUnderflowState[LimitUnderflowState["DISABLED"] = 1] = "DISABLED";
-    LimitUnderflowState[LimitUnderflowState["ENABLED"] = 2] = "ENABLED";
-})(LimitUnderflowState || (LimitUnderflowState = {}));
-/** The query mapping requires an app ID, but on the client it doesn't matter, so we use 'client' */
-const APP_ID = 'client';
 class QuerySubscriptionManager {
-    constructor(rpcManager, clientIdService, documentStore, destructManager, documentIdentityService) {
+    constructor(rpcManager, clientIdService, documentStore, destructManager, documentIdentityService, querySender) {
         this.rpcManager = rpcManager;
         this.clientIdService = clientIdService;
         this.documentStore = documentStore;
         this.destructManager = destructManager;
         this.documentIdentityService = documentIdentityService;
-        /**
-         * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
-         * preventing parallel queries and mutations simplifies the mental model.
-         */
-        this.safeToSendQueriesToServer = new external_rxjs_namespaceObject.BehaviorSubject(true);
+        this.querySender = querySender;
         /**
          * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
          * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
@@ -47640,12 +47641,6 @@ class QuerySubscriptionManager {
         this.onOrphanDocuments = new external_rxjs_namespaceObject.Subject();
         /** All the currently running queries with their full state. */
         this.ongoingQueries = new Map();
-        /**
-         * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
-         * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
-         * queries.
-         */
-        this.inflightQueriesCount = new external_rxjs_namespaceObject.BehaviorSubject(0);
         /**
          * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
          * This relation is used for determining whether a document can be safely removed.
@@ -47657,6 +47652,7 @@ class QuerySubscriptionManager {
          * queries)
          */
         this.queryMappingManager = new ClientQueryMappingManager();
+        this.queryResultsSubject = new external_rxjs_namespaceObject.Subject();
         /**
          * In the case that a document ID changed on the server, this observable will notify us about the change, and we
          * will update the mapping.
@@ -47667,9 +47663,12 @@ class QuerySubscriptionManager {
             this.refreshOngoingQueries();
         });
         this.destructManager.onPreDestruct(() => {
-            this.predestruct();
+            this.preDestruct();
         });
     }
+    observeQueryResults() {
+        return this.queryResultsSubject.asObservable();
+    }
     /**
      * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
      * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
@@ -47702,11 +47701,12 @@ class QuerySubscriptionManager {
             return;
         }
         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) {
         const { collectionName, integrationId } = parseSquidDocId(squidDocId);
-        const mapping = this.queryMappingManager.getMapping(APP_ID, collectionName, integrationId);
+        const mapping = this.queryMappingManager.getMapping(collectionName, integrationId);
         if (!mapping)
             return [];
         return findQueriesForDocumentSync(mapping, doc);
@@ -47830,10 +47830,7 @@ class QuerySubscriptionManager {
          * If the parent query has more or equal number results to the given limit - it may be that the sub-query
          * may need to see different result from what the parent sees.
          */
-        if (candidateParentQuery.dataSubject.value.length >= limit) {
-            return false;
-        }
-        return true;
+        return candidateParentQuery.dataSubject.value.length < limit;
     }
     /**
      * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
@@ -47887,7 +47884,7 @@ class QuerySubscriptionManager {
                 return this.allOngoingQueriesGotInitialResult(rootOngoingQuery);
             }), (0,external_rxjs_namespaceObject.startWith)(undefined), (0,external_rxjs_namespaceObject.pairwise)(), filter(([before, after]) => {
                 return !lodash.isEqual(before, after);
-            }), map_map(([ignored, after]) => after), 
+            }), map_map(([_ignored, after]) => after), 
             // This handles 'subscribe = false'
             subscribe ? (0,external_rxjs_namespaceObject.tap)() : (0,external_rxjs_namespaceObject.take)(1), (0,external_rxjs_namespaceObject.finalize)(() => {
                 var _a;
@@ -47930,12 +47927,6 @@ class QuerySubscriptionManager {
             this.onOrphanDocuments.next(orphanDocument);
         }
     }
-    /** Will resolve once all the in-flight queries are done. */
-    async waitForAllQueriesToFinish() {
-        return (0,external_rxjs_namespaceObject.firstValueFrom)(this.inflightQueriesCount.pipe(filter((count) => count === 0))).then(() => {
-            return undefined;
-        });
-    }
     /** Register logic for cleaning up the query when it is unsubscribed. */
     registerQueryFinalizer(ongoingQuery) {
         const clientRequestId = ongoingQuery.clientRequestId;
@@ -47945,7 +47936,7 @@ class QuerySubscriptionManager {
             if (ongoingQuery.unsubscribeBlockerCount.value > 0) {
                 await (0,external_rxjs_namespaceObject.firstValueFrom)((0,external_rxjs_namespaceObject.race)(this.destructManager.observeIsDestructing(), ongoingQuery.unsubscribeBlockerCount.pipe(filter((count) => count === 0))));
             }
-            this.queryMappingManager.removeQuery(clientRequestId, querySubscriptionId).then();
+            this.queryMappingManager.removeQuery(querySubscriptionId).then();
             this.ongoingQueries.delete(clientRequestId);
             if (ongoingQuery.subscribe) {
                 if (!ongoingQuery.isEmptyForJoin && ongoingQuery.activated) {
@@ -48162,9 +48153,7 @@ class QuerySubscriptionManager {
             supportedQuery.dataSubject.complete();
         }
     }
-    predestruct() {
-        this.safeToSendQueriesToServer.next(false);
-        this.safeToSendQueriesToServer.complete();
+    preDestruct() {
         this.unsubscribe();
     }
     unsubscribe() {
@@ -48186,7 +48175,7 @@ class QuerySubscriptionManager {
         const query = ongoingQuery.query;
         const clientRequestId = ongoingQuery.clientRequestId;
         const querySubscriptionId = getQuerySubscriptionId(this.clientIdService.getClientId(), clientRequestId);
-        this.queryMappingManager.addQuery(APP_ID, query, querySubscriptionId);
+        this.queryMappingManager.addQuery(query, querySubscriptionId);
         this.ongoingQueries.set(clientRequestId, ongoingQuery);
         const parentOngoingQuery = this.findValidParentOfOngoingQuery(ongoingQuery);
         if (parentOngoingQuery) {
@@ -48281,27 +48270,21 @@ class QuerySubscriptionManager {
             clientRequestId: ongoingQuery.clientRequestId,
             subscribe: ongoingQuery.subscribe,
         };
-        this.safeToSendQueriesToServer.pipe(filter(Boolean), (0,external_rxjs_namespaceObject.take)(1)).subscribe(() => {
-            if (ongoingQuery.done) {
-                return;
-            }
-            this.inflightQueriesCount.next(this.inflightQueriesCount.value + 1);
-            ongoingQuery.isInFlight = true;
-            this.rpcManager
-                .post('query/query', queryRequest)
-                .catch((e) => {
-                DebugLogger.debug('Query error', ongoingQuery.query, e);
-                ongoingQuery.dataSubject.error(e);
-                ongoingQuery.done = true;
-                ongoingQuery.queryRegistered.error('query failed');
-            })
-                .then(() => {
-                ongoingQuery.queryRegistered.next(true);
-            })
-                .finally(() => {
-                this.inflightQueriesCount.next(this.inflightQueriesCount.value - 1);
-                ongoingQuery.isInFlight = false;
-            });
+        ongoingQuery.isInFlight = true;
+        this.querySender
+            .sendQuery(queryRequest)
+            .then((queryResult) => {
+            ongoingQuery.queryRegistered.next(true);
+            this.queryResultsSubject.next(queryResult);
+        })
+            .catch((e) => {
+            DebugLogger.debug('Query error', ongoingQuery.query, e);
+            ongoingQuery.dataSubject.error(e);
+            ongoingQuery.done = true;
+            ongoingQuery.queryRegistered.error('query failed');
+        })
+            .finally(() => {
+            ongoingQuery.isInFlight = false;
         });
     }
     /** naive way to refresh queries/subscriptions when we have a new client id */
@@ -48384,7 +48367,7 @@ class ClientQueryMappingManager {
         this.stateService = new StateService();
         this.querySubscriptionIdToQuery = {};
     }
-    addQuery(appId, query, querySubscriptionId) {
+    addQuery(query, querySubscriptionId) {
         this.stateService.runInBatch(() => {
             let condCount = 0;
             const visitedEqualityFields = new Set();
@@ -48416,7 +48399,7 @@ class ClientQueryMappingManager {
         });
         this.querySubscriptionIdToQuery[querySubscriptionId] = query;
     }
-    async removeQuery(appId, querySubscriptionId) {
+    async removeQuery(querySubscriptionId) {
         const query = this.querySubscriptionIdToQuery[querySubscriptionId];
         if (!query)
             return;
@@ -48442,7 +48425,7 @@ class ClientQueryMappingManager {
         });
         return query;
     }
-    getMapping(appId, collectionName, integrationId) {
+    getMapping(collectionName, integrationId) {
         return this.stateService.getStateInPath([
             'queryMapping',
             collectionName,
@@ -48471,11 +48454,9 @@ class ClientQueryMappingManager {
 
 
 class RpcManager {
-    constructor(region, appId, socketManager, destructManager, headers = {}, authManager, clientIdService) {
+    constructor(region, appId, destructManager, headers = {}, authManager, clientIdService) {
         this.region = region;
         this.appId = appId;
-        this.socketManager = socketManager;
-        this.destructManager = destructManager;
         this.authManager = authManager;
         this.clientIdService = clientIdService;
         this.staticHeaders = {};
@@ -48524,8 +48505,6 @@ class RpcManager {
         return this.staticHeaders;
     }
     async ready() {
-        // Waiting for socket connection to be established before sending an RPC request
-        await (0,external_rxjs_namespaceObject.firstValueFrom)((0,external_rxjs_namespaceObject.race)(this.socketManager.observeConnectionReady().pipe((0,external_rxjs_namespaceObject.filter)(Boolean)), this.destructManager.observeIsDestructing()));
         await this.authManager.waitForReadyState();
     }
     async post(path, message) {
@@ -48545,7 +48524,13 @@ class RpcManager {
                 body: serialization_serializeObj(message),
                 headers: headers,
             });
-            return await this.parseResponse(response);
+            const parsedResponse = await this.parseResponse(response);
+            DebugLogger.debug(`received response: ${JSON.stringify(parsedResponse)}`);
+            return parsedResponse;
+        }
+        catch (e) {
+            DebugLogger.debug(`received error: ${JSON.stringify(e)}`);
+            throw e;
         }
         finally {
             this.onGoingRpcCounter.next(this.onGoingRpcCounter.value - 1);
@@ -48557,7 +48542,7 @@ class RpcManager {
         try {
             text = await response.text();
             try {
-                json = JSON.parse(text);
+                json = deserializeObj(text);
             }
             catch (_a) { }
         }
@@ -48657,7 +48642,6 @@ class SocketManager {
         this.allMessagesObserver = new external_rxjs_namespaceObject.Subject();
         this.connectionReady = new external_rxjs_namespaceObject.BehaviorSubject(false);
         this.seenMessageIds = new Set();
-        this.firstConnection = true;
         this.destructSubject = new external_rxjs_namespaceObject.Subject();
         /**
          * On a client disconnecting, we wait for a bit to see if the client reconnects,
@@ -48731,11 +48715,7 @@ class SocketManager {
     }
     onConnectionReady() {
         this.connectionReady.next(true);
-        /** Catchup on messages if reconnecting */
-        if (!this.firstConnection) {
-            this.sendMessage({ type: 'catchup' });
-        }
-        this.firstConnection = false;
+        this.sendMessage({ type: 'catchup' });
     }
     onMessage(messagesStr) {
         if (messagesStr === 'connectionReady') {
@@ -48784,6 +48764,85 @@ class SocketManager {
     }
 }
 
+;// CONCATENATED MODULE: ./src/query/query-sender.ts
+
+
+class QuerySender {
+    constructor(rpcManager, destructManager) {
+        this.rpcManager = rpcManager;
+        this.destructManager = destructManager;
+        /**
+         * A collection of query requests awaiting batch dispatch.
+         */
+        this.pendingQueryRequests = [];
+        /**
+         * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
+         * preventing parallel queries and mutations simplifies the mental model.
+         */
+        this.safeToSendQueriesToServer = new external_rxjs_namespaceObject.BehaviorSubject(true);
+        /**
+         * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
+         * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
+         * queries.
+         */
+        this.inflightQueriesCount = new external_rxjs_namespaceObject.BehaviorSubject(0);
+        this.destructManager.onPreDestruct(() => {
+            this.preDestruct();
+        });
+    }
+    async sendQuery(queryRequest) {
+        const responseSubject = new external_rxjs_namespaceObject.Subject();
+        const responsePromise = (0,external_rxjs_namespaceObject.firstValueFrom)(responseSubject);
+        this.pendingQueryRequests.push({ queryRequest, responseSubject });
+        if (this.pendingQueryBatchTimeout) {
+            clearTimeout(this.pendingQueryBatchTimeout);
+            this.pendingQueryBatchTimeout = undefined;
+        }
+        this.pendingQueryBatchTimeout = setTimeout(() => {
+            this.safeToSendQueriesToServer.pipe(filter(Boolean), (0,external_rxjs_namespaceObject.take)(1)).subscribe(() => {
+                this.processQueryBatch();
+            });
+        }, 0);
+        return responsePromise;
+    }
+    async processQueryBatch() {
+        const queryRequestAndSubjects = this.pendingQueryRequests.splice(0);
+        const pendingQueryRequests = queryRequestAndSubjects.map(({ queryRequest }) => queryRequest);
+        const responseSubjects = queryRequestAndSubjects.map(({ responseSubject }) => responseSubject);
+        this.inflightQueriesCount.next(this.inflightQueriesCount.value + pendingQueryRequests.length);
+        try {
+            const batchResponse = await this.rpcManager.post('query/batchQueries', pendingQueryRequests);
+            for (const { queryRequest, responseSubject } of queryRequestAndSubjects) {
+                const clientRequestId = queryRequest.clientRequestId;
+                const error = batchResponse.errors[clientRequestId];
+                const result = batchResponse.results[clientRequestId];
+                if (error) {
+                    responseSubject.error(error);
+                }
+                else {
+                    responseSubject.next(result);
+                }
+            }
+        }
+        catch (e) {
+            responseSubjects.forEach((responseSubject) => responseSubject.error(e));
+        }
+        finally {
+            this.inflightQueriesCount.next(this.inflightQueriesCount.value - pendingQueryRequests.length);
+        }
+    }
+    /** Will resolve once all the in-flight queries are done. */
+    async waitForAllQueriesToFinish() {
+        return (0,external_rxjs_namespaceObject.firstValueFrom)(this.inflightQueriesCount.pipe(filter((count) => count === 0))).then(() => {
+            return undefined;
+        });
+    }
+    preDestruct() {
+        this.safeToSendQueriesToServer.next(false);
+        this.safeToSendQueriesToServer.complete();
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/squid.ts
 
 
@@ -48807,6 +48866,7 @@ class SocketManager {
 
 
 
+
 
 
 /**
@@ -48991,18 +49051,19 @@ class Squid {
         this.clientIdService = new ClientIdService(this.destructManager);
         this.authManager = new AuthManager(this.destructManager, options.apiKey);
         this.socketManager = new SocketManager(this.clientIdService, options.region, appId, options.messageNotificationWrapper, this.destructManager, this.authManager);
-        this.rpcManager = new RpcManager(options.region, appId, this.socketManager, this.destructManager, httpHeaders, this.authManager, this.clientIdService);
+        this.rpcManager = new RpcManager(options.region, appId, this.destructManager, httpHeaders, this.authManager, this.clientIdService);
         this.documentStore = new DocumentStore();
         this.lockManager = new LockManager();
         this.distributedLockManager = new DistributedLockManager(this.socketManager, this.destructManager);
         this.documentIdentityService = new DocumentIdentityService(this.documentStore, this.destructManager);
         this.documentReferenceFactory = new DocumentReferenceFactory(this.documentIdentityService);
-        this.querySubscriptionManager = new QuerySubscriptionManager(this.rpcManager, this.clientIdService, this.documentStore, this.destructManager, this.documentIdentityService);
+        this.querySender = new QuerySender(this.rpcManager, this.destructManager);
+        this.querySubscriptionManager = new QuerySubscriptionManager(this.rpcManager, this.clientIdService, this.documentStore, this.destructManager, this.documentIdentityService, this.querySender);
         this.localQueryManager = new LocalQueryManager(this.documentStore, this.documentReferenceFactory, this.querySubscriptionManager);
-        const mutationSender = new MutationSender(this.rpcManager, this.lockManager, this.querySubscriptionManager);
+        const mutationSender = new MutationSender(this.rpcManager, this.lockManager, this.querySender);
         this.queryBuilderFactory = new QueryBuilderFactory(this.querySubscriptionManager, this.localQueryManager, this.documentReferenceFactory, this.documentIdentityService);
         this.collectionReferenceFactory = new CollectionReferenceFactory(this.documentReferenceFactory, this.queryBuilderFactory, this.querySubscriptionManager);
-        this.dataManager = new DataManager(this.documentStore, mutationSender, this.socketManager, this.querySubscriptionManager, this.queryBuilderFactory, this.lockManager, this.destructManager, this.documentIdentityService);
+        this.dataManager = new DataManager(this.documentStore, mutationSender, this.socketManager, this.querySubscriptionManager, this.queryBuilderFactory, this.lockManager, this.destructManager, this.documentIdentityService, this.querySender);
         this.documentReferenceFactory.setDataManager(this.dataManager);
         this.backendFunctionManager = new BackendFunctionManager(this.clientIdService, this.rpcManager, this.socketManager);
         this.namedQueryManager = new NamedQueryManager(this.rpcManager, this.socketManager);

package/dist/common/src/bundle-api.types.d.ts

@@ -8,12 +8,15 @@ import { NamedQueryContext } from './named-query.context';
 import { GraphqlContext } from './graphql.context';
 import { DistributedLockContext } from './distributed-lock.context';
 import { AiAssistantChatContext, AiAssistantMutationContext } from './ai-assistant.context';
+import { ClientId } from './communication.types';
+import { ClientConnectionState } from './socket.types';
 export type SecureDatabaseAction<T extends DatabaseActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'read' ? ((context: QueryContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>) : ((context: MutationContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureApiAction = ((context: ApiCallContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureNamedQueryAction = ((context: NamedQueryContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureDistributedLockAction = ((context: DistributedLockContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureGraphQLAction = ((context: GraphqlContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureAiAssistantAction<T extends AiAssistantActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'chat' ? ((context: AiAssistantChatContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>) : ((context: AiAssistantMutationContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
+export type ClientConnectionStateChangeAction = (clientId: ClientId, clientConnectionState: ClientConnectionState) => Promise<void> | void;
 export type ExecutableAction = (...args: any[]) => any;
 export type TriggerAction = ((request: TriggerRequest) => void | Promise<void>) | (() => void | Promise<void>);
 /** The context provided to a trigger function. */

package/dist/common/src/socket.types.d.ts

@@ -1 +1,5 @@
-export {};
+export declare enum ClientConnectionState {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    REMOVED = "REMOVED"
+}

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

@@ -1,4 +1,5 @@
 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';
@@ -20,6 +21,7 @@ export declare class DataManager {
     private readonly lockManager;
     private readonly destructManager;
     private readonly documentIdentityService;
+    private readonly querySender;
     private readonly docIdToLocalTimestamp;
     private currentTransactionId;
     /**
@@ -88,7 +90,7 @@ export declare class DataManager {
     private readonly refreshDocIdToTimestamp;
     private deleteExpiredTimestampsInterval;
     private handleIncomingMessagesForTests;
-    constructor(documentStore: DocumentStore, mutationSender: MutationSender, socketManager: SocketManager, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
+    constructor(documentStore: DocumentStore, mutationSender: MutationSender, socketManager: SocketManager, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
     getProperties(squidDocId: SquidDocId): SquidDocument | undefined;
     /** Whether a document has changes that are out of sync with the server. */
     isDirty(squidDocId: SquidDocId): boolean;

package/dist/typescript-client/src/mutation/mutation-sender.d.ts

@@ -1,10 +1,10 @@
 import { IntegrationId, LockManager, MutateResponse, Mutation } from '@squidcloud/common';
-import { QuerySubscriptionManager } from '../query/query-subscription.manager';
 import { RpcManager } from '../rpc.manager';
+import { QuerySender } from '../query/query-sender';
 export declare class MutationSender {
     private readonly rpcManager;
     private readonly lockManager;
-    private readonly querySubscriptionManager;
-    constructor(rpcManager: RpcManager, lockManager: LockManager, querySubscriptionManager: QuerySubscriptionManager);
+    private readonly querySender;
+    constructor(rpcManager: RpcManager, lockManager: LockManager, querySender: QuerySender);
     sendMutations(mutations: Array<Mutation>, integrationId: IntegrationId): Promise<MutateResponse>;
 }

package/dist/typescript-client/src/query/query-sender.d.ts

@@ -0,0 +1,33 @@
+import { RpcManager } from '../rpc.manager';
+import { QueryRequest, QueryResultData } from '@squidcloud/common';
+import { BehaviorSubject } from 'rxjs';
+import { DestructManager } from '../destruct.manager';
+export declare class QuerySender {
+    private readonly rpcManager;
+    private readonly destructManager;
+    /**
+     * A collection of query requests awaiting batch dispatch.
+     */
+    private readonly pendingQueryRequests;
+    /**
+     * A timeout identifier used to ensure that only the last query in rapid succession triggers the batch send process.
+     */
+    private pendingQueryBatchTimeout?;
+    /**
+     * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
+     * preventing parallel queries and mutations simplifies the mental model.
+     */
+    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
+    /**
+     * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
+     * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
+     * queries.
+     */
+    private readonly inflightQueriesCount;
+    constructor(rpcManager: RpcManager, destructManager: DestructManager);
+    sendQuery(queryRequest: QueryRequest): Promise<QueryResultData>;
+    private processQueryBatch;
+    /** Will resolve once all the in-flight queries are done. */
+    waitForAllQueriesToFinish(): Promise<void>;
+    private preDestruct;
+}

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

@@ -1,70 +1,21 @@
-import { Alias, ClientRequestId, JoinCondition, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
+import { Alias, ClientRequestId, JoinCondition, Query, QueryResultData, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { Observable, Subject } from 'rxjs';
 import { DestructManager } from '../destruct.manager';
 import DocumentIdentityService from '../document-identity.service';
 import { DocumentStore } from '../document-store';
 import { RpcManager } from '../rpc.manager';
 import { ClientIdService } from '../client-id.service';
+import { OngoingQuery } from './query.types';
+import { QuerySender } from './query-sender';
 export declare const FETCH_BEYOND_LIMIT = 100;
 export declare const LIMIT_UNDERFLOW_TRIGGER = 20;
-interface OngoingQuery {
-    clientRequestId: ClientRequestId;
-    query: Query;
-    supportedQueries: Array<OngoingQuery>;
-    supportingOngoingQuery?: OngoingQuery;
-    gotInitialResponse: boolean;
-    activated: boolean;
-    joinCondition?: JoinCondition;
-    alias: Alias;
-    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
-    queryRegistered: BehaviorSubject<boolean>;
-    /**
-     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
-     * query should not be unsubscribed from the server until we registered the child query in the server.
-     */
-    unsubscribeBlockerCount: BehaviorSubject<number>;
-    subscribe: boolean;
-    /**
-     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
-     * for example A.join(B, {..some join condition..}).join(C, {...some join condition}.
-     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
-     * added here.
-     */
-    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
-    isEmptyForJoin: boolean;
-    done: boolean;
-    isInFlight: boolean;
-    forceFetchFromServer: boolean;
-    /**
-     * If there's a limit, we request `limit + FETCH_BEYOND_LIMIT` documents from the server.
-     * If we got that many documents, that means there may be even more. In that case, if our result set goes below
-     * `limit + LIMIT_UNDERFLOW_TRIGGER` documents (due to local or remote deletions), we need to resend the query to the
-     * server to potentially get more documents.
-     * If the number of documents is less than `limit + FETCH_BEYOND_LIMIT`, that means there are not that many documents
-     * on the server, so we don't need to resend the query regardless of how small our result size is or becomes.
-     */
-    limitUnderflowState: LimitUnderflowState;
-}
-declare enum LimitUnderflowState {
-    UNKNOWN = 0,
-    DISABLED = 1,
-    ENABLED = 2
-}
-interface DocsAndAlias {
-    docs: Array<SquidDocument>;
-    alias: Alias;
-}
 export declare class QuerySubscriptionManager {
     private readonly rpcManager;
     private readonly clientIdService;
     private readonly documentStore;
     private readonly destructManager;
     private readonly documentIdentityService;
-    /**
-     * As long as there are mutations in flight we do not want to send queries because it causes race conditions,
-     * preventing parallel queries and mutations simplifies the mental model.
-     */
-    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
+    private readonly querySender;
     /**
      * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
      * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
@@ -73,12 +24,6 @@ export declare class QuerySubscriptionManager {
     onOrphanDocuments: Subject<string[]>;
     /** All the currently running queries with their full state. */
     private readonly ongoingQueries;
-    /**
-     * The number of queries that are currently in-flight (about to be sent to the server or sent but did not get a
-     * response yet). This is used by the data manager to prevent it from sending mutations while there are in-flight
-     * queries.
-     */
-    private readonly inflightQueriesCount;
     /**
      * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
      * This relation is used for determining whether a document can be safely removed.
@@ -90,7 +35,9 @@ export declare class QuerySubscriptionManager {
      * queries)
      */
     private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
+    private readonly queryResultsSubject;
+    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
+    observeQueryResults(): Observable<QueryResultData>;
     /**
      * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
      * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
@@ -144,8 +91,6 @@ export declare class QuerySubscriptionManager {
      * Removes a query from the mapping and updates the orphan documents as needed.
      */
     private removeClientRequestIdMapping;
-    /** Will resolve once all the in-flight queries are done. */
-    waitForAllQueriesToFinish(): Promise<void>;
     /** Register logic for cleaning up the query when it is unsubscribed. */
     private registerQueryFinalizer;
     /** Creates a graph of ongoing queries and returns the root of the graph. */
@@ -157,7 +102,7 @@ export declare class QuerySubscriptionManager {
     private updateOngoingQueryWithNewDataFromSupportingQuery;
     private allOngoingQueriesGotInitialResult;
     private completeAllSupportedQueries;
-    private predestruct;
+    private preDestruct;
     unsubscribe(): void;
     hasSubscription(clientRequestId: ClientRequestId): boolean;
     /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
@@ -183,4 +128,3 @@ export declare class QuerySubscriptionManager {
     private refreshOngoingQueries;
     private migrateDocIds;
 }
-export {};

package/dist/typescript-client/src/query/query.types.d.ts

@@ -0,0 +1,49 @@
+import { Alias, ClientRequestId, JoinCondition, Query, SquidDocument } from '@squidcloud/common';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+export interface OngoingQuery {
+    clientRequestId: ClientRequestId;
+    query: Query;
+    supportedQueries: Array<OngoingQuery>;
+    supportingOngoingQuery?: OngoingQuery;
+    gotInitialResponse: boolean;
+    activated: boolean;
+    joinCondition?: JoinCondition;
+    alias: Alias;
+    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
+    queryRegistered: BehaviorSubject<boolean>;
+    /**
+     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
+     * query should not be unsubscribed from the server until we registered the child query in the server.
+     */
+    unsubscribeBlockerCount: BehaviorSubject<number>;
+    subscribe: boolean;
+    /**
+     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
+     * for example A.join(B, {...some join condition...}).join(C, {...some join condition}.
+     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
+     * added here.
+     */
+    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
+    isEmptyForJoin: boolean;
+    done: boolean;
+    isInFlight: boolean;
+    forceFetchFromServer: boolean;
+    /**
+     * If there's a limit, we request `limit + FETCH_BEYOND_LIMIT` documents from the server.
+     * If we got that many documents, that means there may be even more. In that case, if our result set goes below
+     * `limit + LIMIT_UNDERFLOW_TRIGGER` documents (due to local or remote deletions), we need to resend the query to the
+     * server to potentially get more documents.
+     * If the number of documents is less than `limit + FETCH_BEYOND_LIMIT`, that means there are not that many documents
+     * on the server, so we don't need to resend the query regardless of how small our result size is or becomes.
+     */
+    limitUnderflowState: LimitUnderflowState;
+}
+export declare enum LimitUnderflowState {
+    UNKNOWN = 0,
+    DISABLED = 1,
+    ENABLED = 2
+}
+export interface DocsAndAlias {
+    docs: Array<SquidDocument>;
+    alias: Alias;
+}

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

@@ -2,17 +2,14 @@ import { SupportedSquidRegion } from '@squidcloud/common';
 import { AuthManager } from './auth.manager';
 import { ClientIdService } from './client-id.service';
 import { DestructManager } from './destruct.manager';
-import { SocketManager } from './socket.manager';
 export declare class RpcManager {
     private readonly region;
     private readonly appId;
-    private readonly socketManager;
-    private readonly destructManager;
     private readonly authManager;
     private readonly clientIdService;
     private readonly staticHeaders;
     private readonly onGoingRpcCounter;
-    constructor(region: SupportedSquidRegion, appId: string, socketManager: SocketManager, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
+    constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
     awaitAllSettled(): Promise<void>;
     setStaticHeader(key: string, value: string): void;
     deleteStaticHeader(key: string): void;

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

@@ -15,7 +15,6 @@ export declare class SocketManager {
     private readonly connectionReady;
     private readonly seenMessageIds;
     private socket;
-    private firstConnection;
     private destructSubject;
     /**
      * On a client disconnecting, we wait for a bit to see if the client reconnects,

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

@@ -73,6 +73,7 @@ export declare class Squid {
     private readonly aiClientFactory;
     private readonly _connectionDetails;
     private readonly secretClient;
+    private readonly querySender;
     private static readonly squidInstancesMap;
     /**
      * Creates a new instance of Squid with the given options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",