@squidcloud/backend 1.0.8 → 1.0.9

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

@@ -1,14 +0,0 @@
-import { ApiEndpointId, ClientId, IntegrationId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { RpcManager } from './rpc.manager';
-import { SocketManager } from './socket.manager';
-export declare class ApiManager {
-    private readonly clientId;
-    private readonly rpcManager;
-    private readonly socketManager;
-    private readonly apiServerUrlOverrideMapping;
-    private readonly ongoingApiExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager, apiServerUrlOverrideMapping?: Record<IntegrationId, string>);
-    callApiAndSubscribe<T>(integrationId: IntegrationId, endpointId: ApiEndpointId, request: Record<string, any>): Observable<T>;
-    private handleApiResponse;
-}

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

@@ -1,13 +0,0 @@
-import { ClientId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { RpcManager } from './rpc.manager';
-import { SocketManager } from './socket.manager';
-export declare class BackendFunctionManager {
-    private readonly clientId;
-    private readonly rpcManager;
-    private readonly socketManager;
-    private readonly ongoingFunctionExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager);
-    executeFunctionAndSubscribe<T>(functionName: string, ...params: any[]): Observable<T>;
-    private handleFunctionResponse;
-}

package/dist/typescript-client/src/collection-reference.d.ts

@@ -1,19 +0,0 @@
-import { DocId, DocIdObj, DocumentData, IdResolutionMap, IntegrationId } from '@squidcloud/common';
-import { DocumentReference } from './document-reference';
-import { DocumentReferenceFactory } from './document-reference.factory';
-import { JoinQueryBuilder, JoinQueryBuilderFactory } from './query/join-query-builder.factory';
-import { QueryBuilder, QueryBuilderFactory } from './query/query-builder.factory';
-import { Alias } from './query/query.types';
-export declare class CollectionReference<T extends DocumentData> {
-    private readonly collectionName;
-    private integrationId;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
-    private readonly documents;
-    constructor(collectionName: string, integrationId: IntegrationId, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, joinQueryBuilderFactory: JoinQueryBuilderFactory);
-    doc(docId?: DocId | DocIdObj): DocumentReference<T>;
-    query(): QueryBuilder<T>;
-    joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<T, A, Record<A, DocumentReference<T>>>;
-    migrateDocIds(idResolutionMap: IdResolutionMap): void;
-}

package/dist/typescript-client/src/collection-reference.factory.d.ts

@@ -1,16 +0,0 @@
-import { CollectionName, DocumentData, IntegrationId } from '@squidcloud/common';
-import { CollectionReference } from './collection-reference';
-import DocumentIdentityService from './document-identity.service';
-import { DocumentReferenceFactory } from './document-reference.factory';
-import { JoinQueryBuilderFactory } from './query/join-query-builder.factory';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-export declare class CollectionReferenceFactory {
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
-    private readonly documentIdentityService;
-    private readonly collections;
-    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, joinQueryBuilderFactory: JoinQueryBuilderFactory, documentIdentityService: DocumentIdentityService);
-    get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
-    private migrateDocIds;
-}

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

@@ -1,164 +0,0 @@
-import { DocTimestamp, LockManager, Mutation, SquidDocId, SquidDocument } from '@squidcloud/common';
-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 { QuerySubscriptionManager } from './query/query-subscription.manager';
-import { SocketManagerInterface } from './socket.manager';
-import { TransactionId } from './types';
-export interface DocTimestampMetadata {
-    timestamp: DocTimestamp;
-    expireTimestamp?: number;
-}
-export declare class DataManager {
-    private readonly documentStore;
-    private readonly mutationSender;
-    private readonly socketManager;
-    private readonly querySubscriptionManager;
-    private readonly queryBuilderFactory;
-    private readonly lockManager;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private readonly docIdToLocalTimestamp;
-    private currentTransactionId;
-    /**
-     * During a batch, any update to a document that may trigger an update to a query is collected here and once the batch
-     * ends, the relevant subscribes to these queries will be updated.
-     */
-    private readonly batchClientRequestIds;
-    /**
-     * In this map we save timestamps for documents that are available locally or recently deleted but need to remain
-     * here so if a mutation comes from the server we know whether to apply it or not based on the timestamp. For
-     * example, if a document is removed locally and immediately after, an update is received from the server - In that
-     * case, it may be the update pre-dates the data that was available locally a second ago. For that reason, the
-     * timestamp needs to be kept and even for removed documents it will be kept for ~20 seconds more.
-     *
-     * Eventually, this map is used as a gatekeeper for preventing old versions of a document (based on timestamp) to
-     * appear on the client.
-     */
-    private readonly docIdToServerTimestamp;
-    /**
-     * In the case of a local change (outgoing change) without a server timestamp, an incoming server update cannot be
-     * applied and needs to be queued until the local state allows it. In this case the incoming update will be queued in
-     * this map. Any future incoming server update to the same document will override the previous update in case it has
-     * a later timestamp.
-     */
-    private readonly pendingIncomingUpdates;
-    /**
-     * A mutation sent to the server will be stored in this map until it receives a timestamp from the server. These
-     * mutations were already applied locally and were sent to the server or about to be sent if sentToServer=false
-     * (or are queued in the MutationSender due to a lock). The existence of these pending mutations indicates the data
-     * manager to:
-     * 1 - Not apply any incoming server mutation while there are outgoing mutations without a timestamp
-     * 2 - Not delete the local document even if there are no queries related to this document - there is a chance
-     *     that there will be a future query that will need this document and the query needs to return the local version
-     *     of the document.
-     * 3 - Even when all outgoing mutations have a timestamp, it may be that there is a pending query in flight that will
-     *     need to return the document. In this case, the local document may be different from the server. Hence, it
-     *     cannot accept the server change and will wait for another update from the server. For this purpose, timestamp
-     *     will be stored in docsToTimestamp for ~20 more seconds.
-     *
-     * Note: Only one entry per squidDocId can be with sentToServer=false. This is true since all updates to the same doc
-     *       in the same batch are appended (and reduced) to the same outgoing mutation object.
-     */
-    private readonly pendingOutgoingMutations;
-    /**
-     * A subject for whether there are outgoing mutations. If there are outgoing mutations, any incoming update from the
-     * server will be delayed until all the outgoing mutations will be acknowledged by the server.
-     * This mechanism is needed to avoid this case:
-     *
-     * collection.docRef('a').delete();
-     * collection.snapshots().subscribe((res) => {
-     *   // The result here may include doc with id='a' since the delete mutation was not acknowledged.
-     * });
-     *
-     * If we wait for the acknowledgment message, we will have a server timestamp and will be able to ignore the incoming
-     * result for document with id='a'.
-     */
-    private readonly outgoingMutationsEmpty;
-    private readonly failedDocsToResync;
-    private readonly refreshDocIdToTimestamp;
-    private deleteExpiredTimestampsInterval;
-    private handleIncomingMessagesForTests;
-    constructor(documentStore: DocumentStore, mutationSender: MutationSender, socketManager: SocketManagerInterface, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
-    getProperties(squidDocId: SquidDocId): SquidDocument | undefined;
-    /** Whether a document has changes that are out of sync with the server. */
-    isDirty(squidDocId: SquidDocId): boolean;
-    /**
-     * Runs the provided function without sending mutations to the server while collecting the updates to the different
-     * queries. Local updates will still be applied. Once the batch finishes, all the updates will be sent to the server
-     * and the different queries will be notified. runInTransaction may be invoked inside another runInTransaction, only
-     * the top level batch will trigger updates to the server.
-     */
-    runInTransaction(fn: (transactionId: TransactionId) => Promise<void>, transactionId?: TransactionId): Promise<void>;
-    /** Applies a mutation done from the client (from DocumentReference) and sends it to the server. */
-    applyOutgoingMutation(mutation: Mutation, transactionId: TransactionId | undefined): Promise<void>;
-    /** Same as runInTransaction with the exception that the passed function runs synchronously. */
-    private runInTransactionSync;
-    /** Remove properties from the document record that should not be sent to the server. */
-    private removeInternalProperties;
-    /** Listens and handles mutations and snapshots notifications from the socketManager. */
-    private handleNotifications;
-    private handleIncomingMutations;
-    private handleIncomingQuerySnapshots;
-    /**
-     * Returns a boolean for whether some updates were ignored because the client knows of a later timestamp for those
-     * documents.
-     */
-    private applyIncomingUpdates;
-    private addPendingIncomingUpdate;
-    private maybeApplyIncomingUpdate;
-    private destruct;
-    private stopDeleteExpiredTimestampsJob;
-    /**
-     * Removes entries from the docToTimestamp map for all the documents that are no longer relevant for this client.
-     * If a document is currently tracked, we forget it.
-     * Cases a document is considered not relevant anymore:
-     * 1 - There are no outgoing or incoming updates for this document AND:
-     *   a - The document was deleted on the server and this client already received a notification about it OR
-     *   b - The document no longer has a query that will keep it up-to-date
-     */
-    private startDeleteExpiredTimestampsJob;
-    /**
-     * Whether the document is tracked by any pending mutations or ongoing queries.
-     */
-    isTracked(squidDocId: string): boolean;
-    /**
-     * Whether a document exists locally, but is no longer tracked by any mutations or queries. This is often the case
-     * for in-memory DocumentReferences that are not part of any query.
-     */
-    isForgotten(squidDocId: SquidDocId): boolean;
-    /**
-     * Whether a document only exists locally. This means that the document has never by sent to or received from the
-     * server.
-     */
-    isLocalOnly(squidDocId: SquidDocId): boolean;
-    /**
-     * Whether the document has even been acknowledged by the server. Acknowledgements occur when an incoming query or
-     * mutation is received, and when an outgoing mutation is acknowledged.
-     */
-    hasBeenAcknowledged(squidDocId: SquidDocId): boolean;
-    /**
-     * Updates the document with the new properties, returns true if an update was done or false in case the doc did not
-     * change.
-     */
-    private updateDocumentFromSnapshot;
-    private finishTransaction;
-    private sendAllUnsentOutgoingMutations;
-    private sendMutationsForIntegration;
-    private removeOutgoingMutation;
-    private resyncFailedUpdates;
-    private refreshUpdatedDocuments;
-    private groupOutgoingMutationsByIntegrationId;
-    /**
-     * Handles the case that due to some change (an incoming or outgoing change to a document), a document becomes orphan.
-     * That is, there are no ongoing queries that will keep it up-to-date.
-     * An orphan document should not stay locally since it may be stale after some time.
-     */
-    private handleOrphanDocs;
-    private acknowledgeDocument;
-    private setExpiration;
-    private forgetDocument;
-    private migrateDocIds;
-}

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

@@ -1,9 +0,0 @@
-export type DestructorFn = () => Promise<void> | void;
-export declare class DestructManager {
-    private readonly predestructors;
-    private readonly destructors;
-    private isDestructed;
-    onPreDestruct(fn: DestructorFn): void;
-    onDestruct(fn: DestructorFn): void;
-    destruct(): Promise<void>;
-}

package/dist/typescript-client/src/document-identity.service.d.ts

@@ -1,12 +0,0 @@
-import { IdResolutionMap } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-import { DocumentStore } from './document-store';
-export default class DocumentIdentityService {
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly changeNotifier;
-    constructor(documentStore: DocumentStore, destructManager: DestructManager);
-    migrate(idResolutionMap: IdResolutionMap): void;
-    observeChanges(): Observable<IdResolutionMap>;
-}

package/dist/typescript-client/src/document-reference.d.ts

@@ -1,23 +0,0 @@
-import { DocumentData, IdResolutionMap, Paths, SquidDocId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DataManager } from './data.manager';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-import { TransactionId } from './types';
-export declare class DocumentReference<T extends DocumentData = any> {
-    private _squidDocId;
-    private readonly dataManager;
-    private readonly queryBuilderFactory;
-    constructor(_squidDocId: SquidDocId, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
-    get squidDocId(): SquidDocId;
-    data(): T;
-    snapshot(): Promise<DocumentReference<T> | undefined>;
-    snapshots(): Observable<DocumentReference<T> | undefined>;
-    isDirty(): boolean;
-    private isTracked;
-    update(data: Partial<Record<Paths<T>, any>>, transactionId?: TransactionId): Promise<void>;
-    setInPath(path: Paths<T>, value: any, transactionId?: TransactionId): Promise<void>;
-    deleteInPath(path: Paths<T>, transactionId?: TransactionId): Promise<void>;
-    insert(data: T, transactionId?: TransactionId): Promise<void>;
-    delete(transactionId?: TransactionId): Promise<void>;
-    migrateDocIds(idResolutionMap: IdResolutionMap): void;
-}

package/dist/typescript-client/src/document-reference.factory.d.ts

@@ -1,9 +0,0 @@
-import { SquidDocId } from '@squidcloud/common';
-import { DataManager } from './data.manager';
-import { DocumentReference } from './document-reference';
-import { QueryBuilderFactory } from './query/query-builder.factory';
-export declare class DocumentReferenceFactory {
-    private dataManager;
-    create(squidDocId: SquidDocId, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
-    setDataManager(dataManager: DataManager): void;
-}

package/dist/typescript-client/src/document-store.d.ts

@@ -1,11 +0,0 @@
-import { Query, SquidDocId, SquidDocument } from '@squidcloud/common';
-export declare class DocumentStore {
-    private readonly squidDocIdToDoc;
-    saveDocument(squidDocId: SquidDocId, properties: SquidDocument | undefined): SquidDocument | undefined;
-    hasData(squidDocId: SquidDocId): boolean;
-    getDocument(squidDocId: SquidDocId): SquidDocument;
-    getDocumentOrUndefined(squidDocId: SquidDocId): SquidDocument | undefined;
-    sortAndLimitDocs(docIdSet: Set<SquidDocId> | undefined, query: Query): Array<SquidDocument>;
-    private removeInternalProperties;
-    migrateDocId(squidDocId: SquidDocId, newSquidDocId: SquidDocId): void;
-}

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

@@ -1,9 +0,0 @@
-import { GraphQLRequest, IntegrationId } from '@squidcloud/common';
-import { RpcManager } from './rpc.manager';
-export declare class GraphQLClient {
-    private readonly rpcManager;
-    private readonly client;
-    constructor(rpcManager: RpcManager, integrationId: IntegrationId);
-    query<T = any>(request: GraphQLRequest): Promise<T>;
-    mutate<T = Record<string, any>>(request: GraphQLRequest): Promise<T | null | undefined>;
-}

package/dist/typescript-client/src/graphql-client.factory.d.ts

@@ -1,9 +0,0 @@
-import { IntegrationId } from '@squidcloud/common';
-import { GraphQLClient } from './graphql-client';
-import { RpcManager } from './rpc.manager';
-export declare class GraphQLClientFactory {
-    private readonly rpcManager;
-    private readonly clientsMap;
-    constructor(rpcManager: RpcManager);
-    get(integrationId: IntegrationId): GraphQLClient;
-}

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

@@ -1,7 +0,0 @@
-export { CollectionReference } from './collection-reference';
-export { DocumentReference } from './document-reference';
-export { JoinQueryBuilder } from './query/join-query-builder.factory';
-export { Changes, QueryBuilder } from './query/query-builder.factory';
-export { Alias, JoinCondition } from './query/query.types';
-export { Squid, SquidOptions } from './squid';
-export { TransactionId } from './types';

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

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

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

@@ -1,13 +0,0 @@
-import { ClientId, IntegrationId, QueryName } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { RpcManager } from './rpc.manager';
-import { SocketManager } from './socket.manager';
-export declare class NamedQueryManager {
-    private readonly clientId;
-    private readonly rpcManager;
-    private readonly socketManager;
-    private readonly ongoingNamedQueryExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager);
-    executeNamedQueryAndSubscribe<T>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Observable<T>;
-    private handleNamedQueryResponse;
-}

package/dist/typescript-client/src/query/join-query-builder.factory.d.ts

@@ -1,35 +0,0 @@
-import { CollectionName, DocumentData, FieldName, IntegrationId, Operator, PrimitiveFieldType, Query } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DocumentReference } from '../document-reference';
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { QueryBuilderFactory } from './query-builder.factory';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-import { Alias } from './query.types';
-export declare class JoinQueryBuilderFactory {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory);
-    getForJoin<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType>>>(collectionName: CollectionName, integrationId: IntegrationId, alias: MyAlias): JoinQueryBuilder<DocumentType, MyAlias, ReturnType>;
-}
-export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType> | undefined>> {
-    private readonly collectionName;
-    private readonly integrationId;
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly alias;
-    private readonly joinQueryBuilderFactory;
-    private readonly queryBuilderFactory;
-    private readonly simpleQueryBuilder;
-    private readonly joins;
-    /** Record that maps the right alias to the left condition */
-    private readonly joinConditions;
-    constructor(collectionName: CollectionName, integrationId: IntegrationId, querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, alias: MyAlias, joinQueryBuilderFactory: JoinQueryBuilderFactory, queryBuilderFactory: QueryBuilderFactory);
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    limit(limit: number): this;
-    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
-    join<J extends DocumentData, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: JoinQueryBuilder<J, RightAlias, RightReturnType>, leftFieldName: keyof DocumentType & FieldName, rightFieldName: keyof J & FieldName): JoinQueryBuilder<DocumentType, MyAlias, ReturnType & Partial<RightReturnType>>;
-    snapshot(): Promise<Array<ReturnType>>;
-    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
-    build(): Query;
-}

package/dist/typescript-client/src/query/query-builder.factory.d.ts

@@ -1,37 +0,0 @@
-import { CollectionName, DocumentData, FieldName, IntegrationId, Operator, PrimitiveFieldType, Query, SquidDocId } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentReference } from '../document-reference';
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-export declare class QueryBuilderFactory {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly documentIdentityService;
-    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, documentIdentityService: DocumentIdentityService);
-    getForDocument<DocumentType extends DocumentData>(squidDocId: SquidDocId): QueryBuilder<DocumentType>;
-    get<DocumentType extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): QueryBuilder<DocumentType>;
-}
-export declare class QueryBuilder<DocumentType extends DocumentData> {
-    private readonly collectionName;
-    private readonly integrationId;
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly documentIdentityService;
-    private readonly simpleQueryBuilder;
-    constructor(collectionName: CollectionName, integrationId: IntegrationId, querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, documentIdentityService: DocumentIdentityService);
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    limit(limit: number): this;
-    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
-    snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
-    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
-    changes(): Observable<Changes<DocumentType>>;
-    build(): Query;
-    get hash(): string;
-}
-export interface Changes<DocumentType extends DocumentData> {
-    inserts: Array<DocumentReference<DocumentType>>;
-    updates: Array<DocumentReference<DocumentType>>;
-    deletes: Array<DocumentType>;
-}

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

@@ -1,59 +0,0 @@
-import { ClientId, ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, 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 { Alias, JoinCondition } from './query.types';
-export declare class QuerySubscriptionManager {
-    private readonly rpcManager;
-    private readonly clientId;
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
-    onOrphanDocuments: Subject<string[]>;
-    private readonly ongoingQueries;
-    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.
-     */
-    private readonly clientRequestIdToLocalDocuments;
-    private readonly localDocumentToClientRequestIds;
-    private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientId: ClientId, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
-    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
-    getQuery(clientRequestId: ClientRequestId): Query;
-    setGotResponseFromServer(clientRequestId: ClientRequestId): void;
-    findQueriesForDocument(doc: SquidDocument, squidDocId: SquidDocId): Array<QuerySubscriptionId>;
-    /**
-     * Given the new document's properties, finds all the queries that should be notified with the new properties and
-     * updates the internal mappings (squidDocId --> client request Ids and, clientRequestId --> squidDocIds).
-     * Returns an array with all the previous and current client request ids (basically all the client request ids that
-     * will need to be notified due to the change of properties).
-     */
-    setClientRequestIdsForLocalDoc(squidDocId: SquidDocId, properties: SquidDocument | undefined): Array<ClientRequestId>;
-    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
-    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
-    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
-    hasOngoingQueryForDocId(squidDocId: string): boolean;
-    private removeClientRequestId;
-    waitForAllQueriesToFinish(): Promise<void>;
-    private registerQueryFinalizer;
-    /** Creates a graph of ongoing queries and returns the root of the graph. */
-    private createOngoingQueryGraph;
-    private collectAllObservables;
-    private joinResults;
-    private join;
-    private getOngoingQueriesBfs;
-    private updateOngoingQueryWithNewDataFromSupportingQuery;
-    private allOngoingQueriesGotServerResult;
-    private completeAllSupportedQueries;
-    private predestruct;
-    unsubscribe(): void;
-    hasSubscription(clientRequestId: ClientRequestId): boolean;
-    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
-    private sendQueryToServer;
-    private migrateDocIds;
-}

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

@@ -1,7 +0,0 @@
-import { FieldName } from '@squidcloud/common';
-export type Alias = string;
-export interface JoinCondition {
-    leftAlias: Alias;
-    leftFieldName: FieldName;
-    rightFieldName: FieldName;
-}

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

@@ -1,24 +0,0 @@
-import { ApiKey } from '@squidcloud/common';
-import { DestructManager } from './destruct.manager';
-import { SocketManagerInterface } from './socket.manager';
-export declare class RpcManager {
-    private readonly rpcEndpoint;
-    private readonly socketManager;
-    private readonly staticHeaders;
-    private readonly onGoingRpcsCounter;
-    constructor(rpcEndpoint: string, socketManager: SocketManagerInterface, destructManager: DestructManager, apiKey?: ApiKey);
-    awaitAllSettled(): Promise<void>;
-    setStaticHeader(key: string, value: string): void;
-    deleteStaticHeader(key: string): void;
-    getEndpoint(): string;
-    getStaticHeaders(): Record<string, string>;
-    post<T>(path: string, message: any): Promise<T>;
-}
-export declare class RpcError extends Error {
-    readonly statusCode: number;
-    readonly statusText: string;
-    readonly headers: Headers;
-    readonly url: string;
-    readonly body: string;
-    constructor(statusCode: number, statusText: string, headers: Headers, url: string, body: string);
-}

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

@@ -1,27 +0,0 @@
-import { ClientId, MessageFromClient, MessageToClient } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-export interface SocketManagerInterface {
-    observeNotifications(): Observable<MessageToClient>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-}
-export declare class SocketManager implements SocketManagerInterface {
-    private readonly clientId;
-    private readonly socketIoEndpoint;
-    private readonly messageNotificationWrapper;
-    private readonly destructManager;
-    private readonly webSocketObserver;
-    private readonly allMessagesObserver;
-    private readonly connectionReady;
-    private readonly seenMessageIds;
-    private socket;
-    private firstConnection;
-    constructor(clientId: ClientId, socketIoEndpoint: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager);
-    observeNotifications(): Observable<MessageToClient>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-    private connect;
-    private setupMessageAcknowledgments;
-    private destruct;
-}

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

@@ -1,51 +0,0 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, IntegrationId, QueryName, SupportedSquidRegion } from '@squidcloud/common';
-import { CollectionReference } from './collection-reference';
-import { GraphQLClient } from './graphql-client';
-import { TransactionId } from './types';
-export interface SquidOptions {
-    messageNotificationWrapper?: (fn: () => any) => any;
-    appId: AppId;
-    apiKey?: ApiKey;
-    region: SupportedSquidRegion;
-    apiServerUrlOverrideMapping?: Record<IntegrationId, string>;
-}
-/** Reference to the squid db. Provides all the available actions on the DB. */
-export declare class Squid {
-    private readonly socketManager;
-    private readonly clientId;
-    private readonly rpcManager;
-    private readonly dataManager;
-    private readonly documentReferenceFactory;
-    private readonly documentStore;
-    private readonly lockManager;
-    private readonly querySubscriptionManager;
-    private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
-    private readonly collectionReferenceFactory;
-    private readonly backendFunctionManager;
-    private readonly namedQueryManager;
-    private readonly apiManager;
-    private readonly graphqlClientFactory;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private static readonly squidInstancesMap;
-    constructor(options: SquidOptions);
-    /**
-     * This method is a factory method for creating a Squid instance
-     */
-    static getInstance(options: SquidOptions): Squid;
-    static getInstances(): Array<Squid>;
-    /**
-     * Sets the auth id token (OpenId) that will be sent to the server and will be used for providing the Auth object
-     * to the security rules.
-     */
-    setAuthIdToken(idToken: string | undefined): void;
-    collection<T extends DocumentData>(collectionName: CollectionName, integrationId?: IntegrationId): CollectionReference<T>;
-    runInTransaction(fn: (transactionId: TransactionId) => Promise<void>): Promise<void>;
-    executeFunction<T = any>(functionName: string, ...params: any[]): Promise<T>;
-    executeNamedQuery<T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Promise<T>;
-    callApi<T = any>(integrationId: IntegrationId, endpointId: ApiEndpointId, request?: Record<string, any>): Promise<T>;
-    graphql(integrationId: IntegrationId): GraphQLClient;
-    destruct(): Promise<void>;
-    unsubscribe(): Promise<void>;
-}

package/dist/typescript-client/src/state/action.applier.d.ts

@@ -1,7 +0,0 @@
-import { BaseAction } from './actions';
-export type StateLeafNode = string | boolean | number | null | undefined | object | Array<StateLeafNode> | State;
-export type State = {
-    [key: string]: StateLeafNode;
-};
-export declare function apply(state: State, action: BaseAction): State;
-export declare function isStateObject(state: StateLeafNode): state is State;