@squidcloud/local-backend 1.0.450 → 1.0.452

package/dist/typescript-client/src/query/query-subscription.manager.js

@@ -0,0 +1,820 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySubscriptionManager = exports.FETCH_BEYOND_LIMIT = void 0;
+const assertic_1 = require("assertic");
+const otrie_1 = require("otrie");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const query_public_context_1 = require("../../../internal-common/src/public-types-backend/query.public-context");
+const document_types_1 = require("../../../internal-common/src/types/document.types");
+const query_types_1 = require("../../../internal-common/src/types/query.types");
+const array_1 = require("../../../internal-common/src/utils/array");
+const global_utils_1 = require("../../../internal-common/src/utils/global.utils");
+const object_1 = require("../../../internal-common/src/utils/object");
+const serialization_1 = require("../../../internal-common/src/utils/serialization");
+const query_types_2 = require("./query.types");
+exports.FETCH_BEYOND_LIMIT = 100;
+const LIMIT_UNDERFLOW_TRIGGER = 20;
+class QuerySubscriptionManager {
+    constructor(rpcManager, clientIdService, documentStore, destructManager, documentIdentityService, querySender, socketManager, lockManager) {
+        this.rpcManager = rpcManager;
+        this.clientIdService = clientIdService;
+        this.documentStore = documentStore;
+        this.destructManager = destructManager;
+        this.documentIdentityService = documentIdentityService;
+        this.querySender = querySender;
+        this.socketManager = socketManager;
+        this.lockManager = lockManager;
+        this.onOrphanDocuments = new rxjs_1.Subject();
+        this.ongoingQueries = new Map();
+        this.clientRequestIdToLocalDocuments = new Map();
+        this.localDocumentToClientRequestIds = new Map();
+        this.queryMappingManager = new ClientQueryMappingManager();
+        this.queryResultsSubject = new rxjs_1.Subject();
+        this.documentIdentityService.observeChanges().subscribe(this.migrateDocIds.bind(this));
+        this.clientIdService.observeClientReadyToBeRegenerated().subscribe(() => {
+            this.refreshOngoingQueries();
+        });
+        this.destructManager.onPreDestruct(() => {
+            this.preDestruct();
+        });
+    }
+    dumpSubscriptionInfo() {
+        console.log('Ongoing queries:', this.ongoingQueries);
+        console.log('ClientRequestId to local documents:', this.clientRequestIdToLocalDocuments);
+        console.log('Local documents to clientRequestId:', this.localDocumentToClientRequestIds);
+    }
+    observeQueryResults() {
+        return this.queryResultsSubject.asObservable();
+    }
+    hasOngoingQuery(clientRequestId) {
+        return this.ongoingQueries.has(clientRequestId);
+    }
+    getQuery(clientRequestId) {
+        return (0, assertic_1.truthy)(this.ongoingQueries.get(clientRequestId), 'UNKNOWN_QUERY').query;
+    }
+    setGotInitialResult(clientRequestId) {
+        const ongoingQuery = this.ongoingQueries.get(clientRequestId);
+        if (ongoingQuery?.gotInitialResponse) {
+            this.removeClientRequestIdMapping(clientRequestId);
+        }
+        if (ongoingQuery) {
+            ongoingQuery.gotInitialResponse = true;
+            ongoingQuery.isInFlight = false;
+        }
+    }
+    findQueriesForDocument(doc, squidDocId) {
+        const { collectionName, integrationId } = (0, document_types_1.parseSquidDocId)(squidDocId);
+        const mapping = this.queryMappingManager.getMapping(collectionName, integrationId);
+        if (!mapping)
+            return [];
+        return findQueriesForDocumentSync(mapping, doc);
+    }
+    setClientRequestIdsForLocalDoc(squidDocId, properties) {
+        const clientRequestIdsBefore = this.localDocumentToClientRequestIds.get(squidDocId) || new Set();
+        const clientRequestIdsAfter = new Set(properties
+            ? this.findQueriesForDocument(properties, squidDocId).map(querySubscriptionId => (0, query_types_1.parseQuerySubscriptionId)(querySubscriptionId).clientRequestId)
+            : []);
+        const allClientRequestIds = new Set([...clientRequestIdsBefore, ...clientRequestIdsAfter]);
+        for (const clientRequestIdBefore of [...clientRequestIdsBefore]) {
+            if (clientRequestIdsAfter.has(clientRequestIdBefore))
+                continue;
+            clientRequestIdsBefore.delete(clientRequestIdBefore);
+            const localDocsBefore = this.clientRequestIdToLocalDocuments.get(clientRequestIdBefore);
+            if (localDocsBefore) {
+                localDocsBefore.delete(squidDocId);
+                if (!localDocsBefore.size) {
+                    this.clientRequestIdToLocalDocuments.delete(clientRequestIdBefore);
+                }
+            }
+            if (!clientRequestIdsBefore.size) {
+                this.localDocumentToClientRequestIds.delete(squidDocId);
+            }
+        }
+        for (const clientRequestIdAfter of clientRequestIdsAfter) {
+            let clientRequestIds = this.localDocumentToClientRequestIds.get(squidDocId);
+            if (!clientRequestIds) {
+                clientRequestIds = new Set();
+                this.localDocumentToClientRequestIds.set(squidDocId, clientRequestIds);
+            }
+            clientRequestIds.add(clientRequestIdAfter);
+            let localDocuments = this.clientRequestIdToLocalDocuments.get(clientRequestIdAfter);
+            if (!localDocuments) {
+                localDocuments = new Set();
+                this.clientRequestIdToLocalDocuments.set(clientRequestIdAfter, localDocuments);
+            }
+            localDocuments.add(squidDocId);
+        }
+        return [...allClientRequestIds];
+    }
+    addDocToQuery(squidDocId, clientRequestId) {
+        let clientRequestIds = this.localDocumentToClientRequestIds.get(squidDocId);
+        if (!clientRequestIds) {
+            clientRequestIds = new Set();
+            this.localDocumentToClientRequestIds.set(squidDocId, clientRequestIds);
+        }
+        clientRequestIds.add(clientRequestId);
+        let localDocuments = this.clientRequestIdToLocalDocuments.get(clientRequestId);
+        if (!localDocuments) {
+            localDocuments = new Set();
+            this.clientRequestIdToLocalDocuments.set(clientRequestId, localDocuments);
+        }
+        localDocuments.add(squidDocId);
+    }
+    removeDocFromQuery(squidDocId, clientRequestId) {
+        const clientRequestIds = this.localDocumentToClientRequestIds.get(squidDocId);
+        let noQueriesNeedDoc = !clientRequestIds;
+        if (clientRequestIds) {
+            clientRequestIds.delete(clientRequestId);
+            if (!clientRequestIds.size) {
+                this.localDocumentToClientRequestIds.delete(squidDocId);
+                noQueriesNeedDoc = true;
+            }
+        }
+        const localDocuments = this.clientRequestIdToLocalDocuments.get(clientRequestId);
+        if (localDocuments) {
+            localDocuments.delete(squidDocId);
+            if (!localDocuments.size) {
+                this.clientRequestIdToLocalDocuments.delete(clientRequestId);
+            }
+        }
+        if (noQueriesNeedDoc) {
+            this.documentStore.deleteDocument(squidDocId);
+        }
+    }
+    errorOutAllQueries(squidDocId, err) {
+        const clientRequestIds = this.localDocumentToClientRequestIds.get(squidDocId) || new Set();
+        for (const clientRequestId of clientRequestIds) {
+            const ongoingQuery = this.ongoingQueries.get(clientRequestId);
+            if (!ongoingQuery)
+                continue;
+            if (!this.destructManager.isDestructing) {
+                ongoingQuery.dataSubject.error(err);
+            }
+            else {
+                ongoingQuery.dataSubject.complete();
+            }
+            ongoingQuery.done = true;
+        }
+    }
+    notifyAllSubscriptions(clientRequestIds) {
+        const rootOngoingQueries = new Set();
+        for (const clientRequestId of clientRequestIds) {
+            const ongoingQuery = this.ongoingQueries.get(clientRequestId);
+            if (!ongoingQuery)
+                continue;
+            if (!ongoingQuery.gotInitialResponse || !ongoingQuery.activated || ongoingQuery.isInFlight)
+                continue;
+            const docIdSet = this.clientRequestIdToLocalDocuments.get(clientRequestId) || new Set();
+            const result = this.documentStore.sortAndLimitDocs(docIdSet, ongoingQuery.query);
+            const observablesUpdated = ongoingQuery.supportedQueries
+                .map(supportedOngoingQuery => this.updateOngoingQueryWithNewDataFromSupportingQuery(result, supportedOngoingQuery))
+                .some(Boolean);
+            let rootOngoingQuery = ongoingQuery;
+            while (!rootOngoingQuery.allObservables) {
+                rootOngoingQuery = (0, assertic_1.truthy)(rootOngoingQuery?.supportingOngoingQuery);
+            }
+            if (observablesUpdated) {
+                rootOngoingQueries.add(rootOngoingQuery);
+            }
+            if (ongoingQuery.query.limit > 0) {
+                switch (ongoingQuery.limitUnderflowState) {
+                    case query_types_2.LimitUnderflowState.UNKNOWN:
+                        ongoingQuery.limitUnderflowState =
+                            docIdSet.size === ongoingQuery.query.limit + exports.FETCH_BEYOND_LIMIT
+                                ? query_types_2.LimitUnderflowState.ENABLED
+                                : query_types_2.LimitUnderflowState.DISABLED;
+                        break;
+                    case query_types_2.LimitUnderflowState.DISABLED:
+                        break;
+                    case query_types_2.LimitUnderflowState.ENABLED:
+                        if (docIdSet.size < ongoingQuery.query.limit + LIMIT_UNDERFLOW_TRIGGER) {
+                            ongoingQuery.limitUnderflowState = query_types_2.LimitUnderflowState.UNKNOWN;
+                            this.sendQueryToServerOrUseParentQuery(ongoingQuery);
+                            continue;
+                        }
+                }
+            }
+            ongoingQuery.dataSubject.next(result);
+        }
+        for (const rootOngoingQuery of rootOngoingQueries) {
+            const allObservables = this.collectAllObservables(rootOngoingQuery);
+            (0, assertic_1.truthy)(rootOngoingQuery.allObservables).next(allObservables);
+        }
+    }
+    findValidParentOfQuery(query) {
+        const qc = new query_public_context_1.QueryContext(query);
+        for (const candidateParentQuery of this.ongoingQueries.values()) {
+            if (!this.isValidParent(candidateParentQuery)) {
+                continue;
+            }
+            if (qc.isSubqueryOfQuery(candidateParentQuery.query)) {
+                return candidateParentQuery;
+            }
+        }
+        return undefined;
+    }
+    processQuery(query, rootAlias, joins, joinConditions, subscribe, forceFetchFromServer, clientRequestId) {
+        if (subscribe) {
+            this.socketManager.notifyWebSocketIsNeeded();
+        }
+        return (0, rxjs_1.defer)(() => {
+            const rootOngoingQuery = this.createOngoingQueryGraph(query, rootAlias, joins, joinConditions, subscribe, true, {}, clientRequestId);
+            if (forceFetchFromServer) {
+                rootOngoingQuery.forceFetchFromServer = true;
+            }
+            if (!this.lockManager.canGetLock(query_types_2.RUN_IN_TRANSACTION_MUTEX)) {
+                console.warn('WARNING: Executing a query inside a transaction is not supported and will cause a transaction deadlock. If you are executing a query while an active transaction is running but outside of its callback, you can disregard this message.');
+            }
+            this.sendQueryToServerOrUseParentQuery(rootOngoingQuery);
+            rootOngoingQuery.allObservables = new rxjs_1.ReplaySubject(1);
+            const result = rootOngoingQuery.allObservables.pipe((0, rxjs_1.switchMap)(allObservables => (0, rxjs_1.combineLatest)(allObservables).pipe((0, operators_1.map)(allResults => this.joinResults(allResults, joinConditions, rootOngoingQuery)))), (0, operators_1.filter)(() => this.allOngoingQueriesGotInitialResult(rootOngoingQuery)), (0, rxjs_1.startWith)(undefined), (0, rxjs_1.pairwise)(), (0, operators_1.filter)(([before, after]) => !(0, object_1.isEqual)(before, after)), (0, operators_1.map)(([, after]) => after), subscribe ? (0, rxjs_1.tap)() : (0, rxjs_1.take)(1), (0, rxjs_1.finalize)(() => {
+                rootOngoingQuery.dataSubject.complete();
+                rootOngoingQuery.done = true;
+                void this.completeAllSupportedQueries(rootOngoingQuery);
+                rootOngoingQuery.allObservables?.complete();
+            }));
+            const allObservables = this.collectAllObservables(rootOngoingQuery);
+            rootOngoingQuery.allObservables.next(allObservables);
+            return result;
+        }).pipe((0, rxjs_1.share)());
+    }
+    hasOngoingQueryForDocId(squidDocId) {
+        const clientRequestIds = this.localDocumentToClientRequestIds.get(squidDocId);
+        return !!clientRequestIds && !!clientRequestIds.size;
+    }
+    unsubscribe() {
+        const ongoingQueries = [...this.ongoingQueries.values()];
+        for (const ongoingQuery of ongoingQueries) {
+            ongoingQuery.dataSubject.complete();
+            ongoingQuery.allObservables?.complete();
+        }
+    }
+    hasSubscription(clientRequestId) {
+        return !!this.ongoingQueries.get(clientRequestId)?.subscribe;
+    }
+    isValidParent(candidateParentQuery) {
+        if (!candidateParentQuery.activated ||
+            candidateParentQuery.isInFlight ||
+            candidateParentQuery.isEmptyForJoin ||
+            candidateParentQuery.done ||
+            !candidateParentQuery.subscribe ||
+            !candidateParentQuery.gotInitialResponse ||
+            !candidateParentQuery.dataSubject.value) {
+            return false;
+        }
+        const limit = candidateParentQuery.query.limit === -1 ? 1000 : candidateParentQuery.query.limit;
+        return candidateParentQuery.dataSubject.value.length < limit;
+    }
+    findValidParentOfOngoingQuery(ongoingQuery) {
+        if (ongoingQuery.forceFetchFromServer)
+            return undefined;
+        const qc = new query_public_context_1.QueryContext(ongoingQuery.query);
+        for (const candidateParentQuery of this.ongoingQueries.values()) {
+            if (ongoingQuery === candidateParentQuery) {
+                return undefined;
+            }
+            else if (!this.isValidParent(candidateParentQuery)) {
+                continue;
+            }
+            else if (qc.isSubqueryOfQuery(candidateParentQuery.query)) {
+                return candidateParentQuery;
+            }
+        }
+        return undefined;
+    }
+    removeClientRequestIdMapping(clientRequestId) {
+        const docs = this.clientRequestIdToLocalDocuments.get(clientRequestId);
+        if (!docs)
+            return;
+        this.clientRequestIdToLocalDocuments.delete(clientRequestId);
+        const orphanDocument = [];
+        for (const doc of docs) {
+            const clientRequestIds = (0, assertic_1.truthy)(this.localDocumentToClientRequestIds.get(doc));
+            clientRequestIds.delete(clientRequestId);
+            if (!clientRequestIds.size) {
+                this.localDocumentToClientRequestIds.delete(doc);
+                orphanDocument.push(doc);
+            }
+        }
+        if (orphanDocument.length) {
+            this.onOrphanDocuments.next(orphanDocument);
+        }
+    }
+    registerQueryFinalizer(ongoingQuery) {
+        const clientRequestId = ongoingQuery.clientRequestId;
+        const querySubscriptionId = (0, query_types_1.getQuerySubscriptionId)(this.clientIdService.getClientId(), clientRequestId);
+        ongoingQuery.dataSubject
+            .pipe((0, rxjs_1.finalize)(async () => {
+            if (ongoingQuery.unsubscribeBlockerCount.value > 0) {
+                await (0, rxjs_1.firstValueFrom)((0, rxjs_1.race)(this.destructManager.observeIsDestructing(), ongoingQuery.unsubscribeBlockerCount.pipe((0, operators_1.filter)(count => count === 0))));
+            }
+            void this.queryMappingManager.removeQuery(querySubscriptionId);
+            this.ongoingQueries.delete(clientRequestId);
+            if (ongoingQuery.subscribe) {
+                if (!ongoingQuery.isEmptyForJoin && ongoingQuery.activated) {
+                    const unsubscribeRequest = {
+                        clientRequestId,
+                    };
+                    this.rpcManager.post('query/unsubscribe', unsubscribeRequest).catch(e => {
+                        if (this.destructManager.isDestructing)
+                            return;
+                        console.error('Got error while unsubscribing from query', ongoingQuery.query, e);
+                    });
+                }
+            }
+            this.removeClientRequestIdMapping(clientRequestId);
+        }), (0, operators_1.filter)(Boolean))
+            .subscribe({
+            error: () => {
+            },
+        });
+    }
+    createOngoingQueryGraph(query, alias, joins, joinConditionsMap, subscribe, isRoot, createdOngoingQueries = {}, providedClientRequestId) {
+        if (createdOngoingQueries[alias])
+            return createdOngoingQueries[alias];
+        const clientRequestId = isRoot && providedClientRequestId ? providedClientRequestId : this.clientIdService.generateClientRequestId();
+        const supportedQueries = [];
+        const result = {
+            clientRequestId,
+            activated: isRoot,
+            alias,
+            query,
+            subscribe,
+            dataSubject: new rxjs_1.BehaviorSubject(null),
+            supportedQueries,
+            supportingOngoingQuery: undefined,
+            joinCondition: undefined,
+            gotInitialResponse: false,
+            isEmptyForJoin: false,
+            canExpandForJoin: true,
+            unsubscribeBlockerCount: new rxjs_1.BehaviorSubject(0),
+            queryRegistered: new rxjs_1.BehaviorSubject(false),
+            done: false,
+            isInFlight: false,
+            forceFetchFromServer: false,
+            limitUnderflowState: subscribe ? query_types_2.LimitUnderflowState.UNKNOWN : query_types_2.LimitUnderflowState.DISABLED,
+        };
+        this.registerQueryFinalizer(result);
+        this.ongoingQueries.set(clientRequestId, result);
+        createdOngoingQueries[alias] = result;
+        for (const [rightAlias, joinCondition] of Object.entries(joinConditionsMap)) {
+            const leftAlias = joinCondition.leftAlias;
+            if (leftAlias !== alias && rightAlias !== alias)
+                continue;
+            const chosenAlias = leftAlias === alias ? rightAlias : leftAlias;
+            if (leftAlias === alias) {
+                const supportedQuery = this.createOngoingQueryGraph(joins[chosenAlias], chosenAlias, joins, joinConditionsMap, subscribe, false, createdOngoingQueries);
+                supportedQuery.joinCondition = joinCondition;
+                supportedQueries.push(supportedQuery);
+            }
+            else {
+                result.supportingOngoingQuery = this.createOngoingQueryGraph(joins[chosenAlias], chosenAlias, joins, joinConditionsMap, subscribe, false, createdOngoingQueries);
+            }
+        }
+        return result;
+    }
+    collectAllObservables(ongoingQuery, result = []) {
+        if (ongoingQuery.isEmptyForJoin) {
+            return result;
+        }
+        const alias = ongoingQuery.alias;
+        result.push(ongoingQuery.dataSubject.pipe((0, operators_1.filter)(Boolean), (0, operators_1.map)(docs => {
+            return { docs, alias };
+        })));
+        for (const supportedQuery of ongoingQuery.supportedQueries) {
+            this.collectAllObservables(supportedQuery, result);
+        }
+        return result;
+    }
+    joinResults(allResults, joinConditions, rootOngoingQuery) {
+        const aliasToDocs = allResults.reduce((accum, docsAndAlias) => {
+            if (accum[docsAndAlias.alias]) {
+                accum[docsAndAlias.alias].push(...docsAndAlias.docs);
+            }
+            else {
+                accum[docsAndAlias.alias] = [...docsAndAlias.docs];
+            }
+            return accum;
+        }, {});
+        let result = aliasToDocs[rootOngoingQuery.alias].map(doc => ({
+            [rootOngoingQuery.alias]: doc,
+        }));
+        const ongoingQueriesInOrder = this.getOngoingQueriesBfs(rootOngoingQuery);
+        const visitedAliases = new Set();
+        for (let i = 1; i < ongoingQueriesInOrder.length; i++) {
+            const ongoingQuery = ongoingQueriesInOrder[i];
+            const rightAlias = ongoingQuery.alias;
+            if (visitedAliases.has(rightAlias))
+                continue;
+            visitedAliases.add(rightAlias);
+            result = this.join(result, rightAlias, aliasToDocs[rightAlias], joinConditions[rightAlias]);
+        }
+        return result;
+    }
+    join(left, rightAlias, rightDocs, joinCondition) {
+        if (!left.length)
+            return left;
+        const availableLeftAliases = Object.keys(left[0]);
+        if (!(joinCondition && availableLeftAliases.includes(joinCondition.leftAlias))) {
+            throw new Error('No join condition found for alias ' + rightAlias);
+        }
+        const rightAsMap = new Map();
+        (rightDocs || []).forEach(doc => {
+            const val = this.transformKey(doc[joinCondition.right]);
+            if (!rightAsMap.has(val))
+                rightAsMap.set(val, []);
+            (0, assertic_1.truthy)(rightAsMap.get(val)).push(doc);
+        });
+        return left.flatMap(leftElement => {
+            const rightDocsWithSameValue = rightAsMap.get(this.transformKey(leftElement[joinCondition.leftAlias]?.[joinCondition.left])) || [];
+            if (rightDocsWithSameValue.length) {
+                return rightDocsWithSameValue.map(rightDoc => ({ ...leftElement, [rightAlias]: rightDoc }));
+            }
+            else if (joinCondition.isInner) {
+                return [];
+            }
+            else {
+                return [{ ...leftElement, [rightAlias]: undefined }];
+            }
+        });
+    }
+    getOngoingQueriesBfs(rootOngoingQuery) {
+        const result = [];
+        const queue = [rootOngoingQuery];
+        while (queue.length) {
+            const current = (0, assertic_1.truthy)(queue.shift());
+            if (current.isEmptyForJoin)
+                continue;
+            result.push(current);
+            queue.push(...current.supportedQueries);
+        }
+        return result;
+    }
+    updateOngoingQueryWithNewDataFromSupportingQuery(supportingQueryResult, supportedOngoingQuery) {
+        const joinCondition = (0, assertic_1.truthy)(supportedOngoingQuery.joinCondition);
+        const query = supportedOngoingQuery.query;
+        if (!supportedOngoingQuery.activated) {
+            supportedOngoingQuery.activated = true;
+            const existingCondValues = query.conditions
+                .filter(query_types_1.isSimpleCondition)
+                .filter(cond => {
+                return cond.fieldName === joinCondition.right && cond.operator === '==';
+            })
+                .map(cond => cond.value);
+            if (existingCondValues.length) {
+                this.sendQueryToServerOrUseParentQuery(supportedOngoingQuery);
+                supportedOngoingQuery.canExpandForJoin = false;
+                return true;
+            }
+            const newConditions = supportingQueryResult
+                .map(supportingDoc => supportingDoc[joinCondition.left] ?? null)
+                .map(value => {
+                return {
+                    fieldName: joinCondition.right,
+                    operator: '==',
+                    value,
+                };
+            });
+            if (newConditions.length) {
+                query.conditions.push(...newConditions);
+                this.sendQueryToServerOrUseParentQuery(supportedOngoingQuery);
+            }
+            else {
+                supportedOngoingQuery.isEmptyForJoin = true;
+            }
+            return true;
+        }
+        else {
+            if (!supportedOngoingQuery.canExpandForJoin) {
+                return false;
+            }
+            const supportedQueriesWithSameAlias = (0, assertic_1.truthy)(supportedOngoingQuery.supportingOngoingQuery?.supportedQueries).filter(q => q.alias === supportedOngoingQuery.alias);
+            const allNeededValues = new Set(supportingQueryResult.map(resultDoc => resultDoc[joinCondition.left] ?? null));
+            for (const supportedQuery of supportedQueriesWithSameAlias) {
+                supportedQuery.query.conditions
+                    .filter(query_types_1.isSimpleCondition)
+                    .filter(cond => cond.fieldName === joinCondition.right)
+                    .forEach(cond => {
+                    allNeededValues.delete(cond.value);
+                });
+            }
+            if (allNeededValues.size === 0) {
+                return false;
+            }
+            const newQuery = (0, object_1.cloneDeep)(query);
+            newQuery.conditions = newQuery.conditions.filter(cond => !(0, query_types_1.isSimpleCondition)(cond) || cond.fieldName !== joinCondition.right);
+            [...allNeededValues].forEach(value => {
+                newQuery.conditions.push({
+                    fieldName: joinCondition.right,
+                    operator: '==',
+                    value,
+                });
+            });
+            const ongoingQuery = {
+                ...supportedOngoingQuery,
+                query: newQuery,
+                activated: true,
+                gotInitialResponse: false,
+                dataSubject: new rxjs_1.BehaviorSubject(null),
+                clientRequestId: this.clientIdService.generateClientRequestId(),
+                isEmptyForJoin: false,
+            };
+            this.registerQueryFinalizer(ongoingQuery);
+            this.ongoingQueries.set(ongoingQuery.clientRequestId, ongoingQuery);
+            (0, assertic_1.truthy)(supportedOngoingQuery.supportingOngoingQuery).supportedQueries.push(ongoingQuery);
+            this.sendQueryToServerOrUseParentQuery(ongoingQuery);
+            return true;
+        }
+    }
+    allOngoingQueriesGotInitialResult(rootOngoingQuery) {
+        if (rootOngoingQuery.isEmptyForJoin)
+            return true;
+        if (!rootOngoingQuery.gotInitialResponse)
+            return false;
+        if (!rootOngoingQuery.supportedQueries.length)
+            return true;
+        return rootOngoingQuery.supportedQueries.every(ongoingQuery => this.allOngoingQueriesGotInitialResult(ongoingQuery));
+    }
+    async completeAllSupportedQueries(rootOngoingQuery) {
+        const supportedQueries = [...(rootOngoingQuery.supportedQueries || [])];
+        while (supportedQueries.length) {
+            const supportedQuery = (0, assertic_1.truthy)(supportedQueries.shift());
+            supportedQueries.push(...(supportedQuery.supportedQueries || []));
+            await (0, rxjs_1.firstValueFrom)(supportedQuery.unsubscribeBlockerCount.pipe((0, operators_1.filter)(count => count === 0)));
+            supportedQuery.dataSubject.complete();
+        }
+    }
+    transformKey(key) {
+        if (key instanceof Date) {
+            return `DATE AS string KEY: ${key.toISOString()}`;
+        }
+        return key;
+    }
+    preDestruct() {
+        this.unsubscribe();
+    }
+    sendQueryToServerOrUseParentQuery(ongoingQuery, forceSendToServer = false) {
+        if (this.destructManager.isDestructing)
+            return;
+        const query = ongoingQuery.query;
+        const clientRequestId = ongoingQuery.clientRequestId;
+        const querySubscriptionId = (0, query_types_1.getQuerySubscriptionId)(this.clientIdService.getClientId(), clientRequestId);
+        this.queryMappingManager.addQuery(query, querySubscriptionId);
+        this.ongoingQueries.set(clientRequestId, ongoingQuery);
+        const parentOngoingQuery = forceSendToServer ? undefined : this.findValidParentOfOngoingQuery(ongoingQuery);
+        if (parentOngoingQuery) {
+            void this.useParentOngoingQuery(ongoingQuery, parentOngoingQuery);
+        }
+        else {
+            this.sendQueryToServer(ongoingQuery);
+        }
+    }
+    async useParentOngoingQuery(ongoingQuery, parentOngoingQuery) {
+        const queryRegisterRequest = {
+            clientRequestId: ongoingQuery.clientRequestId,
+            query: ongoingQuery.query,
+            parentClientRequestId: parentOngoingQuery.clientRequestId,
+        };
+        const queryContext = new query_public_context_1.QueryContext(ongoingQuery.query);
+        parentOngoingQuery.unsubscribeBlockerCount.next(parentOngoingQuery.unsubscribeBlockerCount.value + 1);
+        try {
+            await (0, rxjs_1.firstValueFrom)(parentOngoingQuery.queryRegistered.pipe((0, operators_1.filter)(Boolean)));
+        }
+        catch (e) {
+            if (!this.destructManager.isDestructing) {
+                ongoingQuery.dataSubject.error(e);
+                ongoingQuery.queryRegistered.error(e);
+            }
+            else {
+                ongoingQuery.dataSubject.complete();
+                ongoingQuery.queryRegistered.complete();
+            }
+            ongoingQuery.done = true;
+            return;
+        }
+        if (this.destructManager.isDestructing)
+            return;
+        if (ongoingQuery.done) {
+            return;
+        }
+        this.rpcManager
+            .post('query/register', queryRegisterRequest)
+            .then(() => {
+            ongoingQuery.isInFlight = false;
+            ongoingQuery.queryRegistered.next(true);
+        })
+            .catch(e => {
+            ongoingQuery.isInFlight = false;
+            if (!this.destructManager.isDestructing) {
+                console.error('Query error', ongoingQuery.query, parentOngoingQuery.query, e);
+                ongoingQuery.dataSubject.error(e);
+            }
+            else {
+                ongoingQuery.dataSubject.complete();
+            }
+            ongoingQuery.done = true;
+        })
+            .finally(() => {
+            parentOngoingQuery.unsubscribeBlockerCount.next(parentOngoingQuery.unsubscribeBlockerCount.value - 1);
+        });
+        const takeUntilNotifier = (0, rxjs_1.race)(ongoingQuery.queryRegistered.pipe((0, operators_1.filter)(Boolean), (0, rxjs_1.delay)(2000), (0, rxjs_1.take)(1)), this.destructManager.observeIsDestructing().pipe((0, rxjs_1.take)(1)));
+        parentOngoingQuery.dataSubject
+            .pipe((0, rxjs_1.takeWhile)(() => {
+            return !ongoingQuery.done;
+        }), (0, rxjs_1.takeUntil)(takeUntilNotifier), (0, operators_1.filter)(Boolean), (0, rxjs_1.tap)(() => {
+            if (ongoingQuery.gotInitialResponse)
+                return;
+            this.setGotInitialResult(ongoingQuery.clientRequestId);
+        }), (0, operators_1.map)(documents => documents.filter(doc => queryContext.documentMatchesQuery(doc))))
+            .subscribe({
+            next: results => {
+                for (const result of results) {
+                    this.setClientRequestIdsForLocalDoc((0, document_types_1.getSquidDocId)(result.__docId__, ongoingQuery.query.collectionName, ongoingQuery.query.integrationId), result);
+                }
+                this.notifyAllSubscriptions([ongoingQuery.clientRequestId]);
+            },
+            error: e => {
+                if (!this.destructManager.isDestructing) {
+                    ongoingQuery.dataSubject.error(e);
+                }
+                else {
+                    ongoingQuery.dataSubject.complete();
+                }
+            },
+        });
+    }
+    sendQueryToServer(ongoingQuery) {
+        const oldLimit = ongoingQuery.query.limit;
+        const newLimit = oldLimit > 0 && ongoingQuery.subscribe ? oldLimit + exports.FETCH_BEYOND_LIMIT : oldLimit;
+        const queryRequest = {
+            query: { ...ongoingQuery.query, limit: newLimit },
+            clientRequestId: ongoingQuery.clientRequestId,
+            subscribe: ongoingQuery.subscribe,
+        };
+        ongoingQuery.isInFlight = true;
+        this.querySender
+            .sendQuery(queryRequest)
+            .then(queryResult => {
+            ongoingQuery.isInFlight = false;
+            ongoingQuery.queryRegistered.next(true);
+            this.queryResultsSubject.next(queryResult);
+        })
+            .catch(e => {
+            ongoingQuery.isInFlight = false;
+            if (!this.destructManager.isDestructing) {
+                global_utils_1.DebugLogger.debug('Query error', ongoingQuery.query, e);
+                ongoingQuery.dataSubject.error(e);
+                ongoingQuery.queryRegistered.error('query failed');
+            }
+            else {
+                ongoingQuery.dataSubject.complete();
+                ongoingQuery.queryRegistered.complete();
+            }
+            ongoingQuery.done = true;
+        });
+    }
+    refreshOngoingQueries() {
+        for (const query of this.ongoingQueries.values()) {
+            this.sendQueryToServerOrUseParentQuery(query, true);
+        }
+        return;
+    }
+    migrateDocIds(idResolutionMap) {
+        const squidDocIds = Object.keys(idResolutionMap);
+        for (const set of this.clientRequestIdToLocalDocuments.values()) {
+            squidDocIds.forEach(key => {
+                if (set.has(key)) {
+                    set.delete(key);
+                    set.add(idResolutionMap[key]);
+                }
+            });
+        }
+        squidDocIds.forEach(key => {
+            (0, object_1.replaceKeyInMap)(this.localDocumentToClientRequestIds, key, idResolutionMap[key]);
+        });
+    }
+}
+exports.QuerySubscriptionManager = QuerySubscriptionManager;
+function matchesCompositeCondition(condition, doc) {
+    for (const subCondition of condition.fields) {
+        const valueInDocument = (0, object_1.getInPath)(doc, subCondition.fieldName) ?? null;
+        if ((0, query_types_1.compareOperator)(subCondition.value, valueInDocument, subCondition.operator)) {
+            return true;
+        }
+        if ((0, query_types_1.compareOperator)(subCondition.value, valueInDocument, '!=')) {
+            return false;
+        }
+    }
+    return false;
+}
+function findQueriesForDocumentSync(mapping, doc) {
+    const result = [...(mapping.unconditional || [])];
+    const mappedIdFoundMap = new Map();
+    for (const [encodedCondition, queryIds] of Object.entries(mapping.conditional || {})) {
+        const condition = (0, serialization_1.deserializeObj)(encodedCondition);
+        let matchesCondition;
+        if ((0, query_types_1.isSimpleCondition)(condition)) {
+            const valueInDocument = (0, object_1.getInPath)(doc, condition.fieldName) ?? null;
+            matchesCondition = (0, query_types_1.compareOperator)(condition.value, valueInDocument, condition.operator);
+        }
+        else {
+            matchesCondition = matchesCompositeCondition(condition, doc);
+        }
+        if (matchesCondition) {
+            for (const mappedId of queryIds) {
+                mappedIdFoundMap.set(mappedId, (mappedIdFoundMap.get(mappedId) || 0) + 1);
+            }
+        }
+    }
+    for (const [mappedId, matchCount] of mappedIdFoundMap.entries()) {
+        if (matchCount >= mapping.queriesMetadata[mappedId].condCount) {
+            result.push(mappedId);
+        }
+    }
+    return result;
+}
+class ClientQueryMappingManager {
+    constructor() {
+        this.stateService = new otrie_1.TrieStore({});
+        this.querySubscriptionIdToQuery = {};
+    }
+    addQuery(query, querySubscriptionId) {
+        this.stateService.runInBatch(() => {
+            let condCount = 0;
+            const visitedEqualityFields = new Set();
+            for (const condition of query.conditions) {
+                if ((0, query_types_1.isSimpleCondition)(condition) && ['=='].includes(condition.operator)) {
+                    const fieldName = (0, serialization_1.encodeValueForMapping)(condition.fieldName);
+                    if (!visitedEqualityFields.has(fieldName)) {
+                        condCount++;
+                        visitedEqualityFields.add(fieldName);
+                    }
+                }
+                else {
+                    condCount++;
+                }
+                const conditionPath = this.getConditionStatePath(query, condition);
+                const clientRequestIdsForCondition = [...(this.stateService.get(conditionPath) || [])];
+                (0, array_1.insertSorted)(clientRequestIdsForCondition, querySubscriptionId);
+                this.stateService.set(conditionPath, clientRequestIdsForCondition);
+            }
+            if (!query.conditions.length) {
+                const path = ['queryMapping', query.collectionName, query.integrationId, 'mapping', 'unconditional'];
+                const currentArray = [...(this.stateService.get(path) || [])];
+                (0, array_1.insertSorted)(currentArray, querySubscriptionId);
+                this.stateService.set(path, currentArray);
+            }
+            this.stateService.set([...this.getQueryMetadataStatePath(query, querySubscriptionId), 'condCount'], condCount);
+        });
+        this.querySubscriptionIdToQuery[querySubscriptionId] = query;
+    }
+    async removeQuery(querySubscriptionId) {
+        const query = this.querySubscriptionIdToQuery[querySubscriptionId];
+        if (!query)
+            return;
+        this.stateService.runInBatch(() => {
+            for (const cond of query.conditions) {
+                const path = this.getConditionStatePath(query, cond);
+                const currentArray = [...(this.stateService.get(path) || [])];
+                (0, array_1.removeSorted)(currentArray, querySubscriptionId);
+                if (currentArray.length) {
+                    this.stateService.set(path, currentArray);
+                }
+                else {
+                    this.stateService.delete(path);
+                }
+            }
+            if (!query.conditions.length) {
+                const path = ['queryMapping', query.collectionName, query.integrationId, 'mapping', 'unconditional'];
+                const currentArray = [...(this.stateService.get(path) || [])];
+                (0, array_1.removeSorted)(currentArray, querySubscriptionId);
+                this.stateService.set(path, currentArray);
+            }
+            this.stateService.delete(this.getQueryMetadataStatePath(query, querySubscriptionId));
+        });
+        return query;
+    }
+    getMapping(collectionName, integrationId) {
+        return this.stateService.get([
+            'queryMapping',
+            collectionName,
+            integrationId,
+            'mapping',
+        ]);
+    }
+    getQueryMetadataStatePath(query, clientRequestId) {
+        return [
+            'queryMapping',
+            query.collectionName,
+            query.integrationId,
+            'mapping',
+            'queriesMetadata',
+            `${clientRequestId}`,
+        ];
+    }
+    getConditionStatePath(query, cond) {
+        return ['queryMapping', query.collectionName, query.integrationId, 'mapping', 'conditional', (0, query_types_1.encodeCondition)(cond)];
+    }
+}
+//# sourceMappingURL=query-subscription.manager.js.map