@squidcloud/backend 1.0.0

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,16 @@
+import { DocId, DocIdObj, IntegrationId, UserFacingDocType } from '@squidcloud/common';
+import { DocumentReference } from './document-reference';
+import { DocumentReferenceFactory } from './document-reference.factory';
+import { QueryBuilder, QueryBuilderFactory } from './query/query-builder.factory';
+import { Alias } from './query/query.types';
+export declare class CollectionReference<T extends UserFacingDocType> {
+    private readonly collectionName;
+    private integrationId;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly documents;
+    constructor(collectionName: string, integrationId: IntegrationId, documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory);
+    doc(docId: DocId | DocIdObj): DocumentReference<T>;
+    query(): Omit<QueryBuilder<T, any, Record<Alias, DocumentReference<T>>, false>, 'join'>;
+    joinQuery<A extends Alias>(alias: A): QueryBuilder<T, A, Record<A, DocumentReference<T>>, true>;
+}

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

@@ -0,0 +1,11 @@
+import { CollectionName, IntegrationId, UserFacingDocType } from '@squidcloud/common';
+import { CollectionReference } from './collection-reference';
+import { DocumentReferenceFactory } from './document-reference.factory';
+import { QueryBuilderFactory } from './query/query-builder.factory';
+export declare class CollectionReferenceFactory {
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly collections;
+    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory);
+    get<T extends UserFacingDocType>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
+}

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

@@ -0,0 +1,140 @@
+import { DocType, FullDocIdStr, LockManager, Mutation } from '@squidcloud/common';
+import { DbDao } from './db.dao';
+import { DestructManager } from './destruct.manager';
+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 declare class DataManager {
+    private readonly dbDao;
+    private readonly mutationSender;
+    private readonly socketManager;
+    private readonly querySubscriptionManager;
+    private readonly queryBuilderFactory;
+    private readonly lockManager;
+    private readonly destructManager;
+    private readonly fullDocIdToLocalTimestamp;
+    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 docToTimestamp;
+    /**
+     * 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 fullDocId 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 docsToResync;
+    private deleteExpiredTimestampsInterval;
+    private handleIncomingMessages;
+    constructor(dbDao: DbDao, mutationSender: MutationSender, socketManager: SocketManagerInterface, querySubscriptionManager: QuerySubscriptionManager, queryBuilderFactory: QueryBuilderFactory, lockManager: LockManager, destructManager: DestructManager);
+    getProperties(fullDocIdStr: FullDocIdStr): DocType | undefined;
+    isDirty(fullDocIdStr: FullDocIdStr): 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 exists locally, remove it as well.
+     * 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;
+    /**
+     * Returns whether it is safe to remove the document locally. A document is safe to be removed if:
+     * 1 - It has no pending incoming mutations
+     * 2 - All the outgoing mutations already have timestamp
+     * 3 - The document is orphan - there is no outgoing query for it
+     */
+    private isDocumentSafeForDelete;
+    /**
+     * Updates the document with the new properties, returns true if an update was done or false in case the doc did not
+     * change.
+     */
+    private applyLocalDbUpdateFromSnapshot;
+    private finishTransaction;
+    private sendAllUnsentOutgoingMutations;
+    private sendMutationsForIntegration;
+    private removeOutgoingMutation;
+    private resyncFailedUpdates;
+    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 removeDocumentLocally;
+}

package/dist/typescript-client/src/db.dao.d.ts

@@ -0,0 +1,20 @@
+import { DocType, FullDocIdStr, Query } from '@squidcloud/common';
+export type DbId = number;
+export declare class DbDao {
+    private readonly db;
+    private readonly dbIdToDoc;
+    private readonly fullDocIdToDbId;
+    constructor();
+    saveDocument(fullDocIdStr: FullDocIdStr, properties: DocType | undefined): DbId | undefined;
+    removeDocumentFromDb(fullDocIdStr: FullDocIdStr): void;
+    isDbDifferentThanInMemory(fullDocIdStr: FullDocIdStr): boolean;
+    getDocumentProperties(fullDocIdStr: FullDocIdStr): DocType;
+    getDocumentPropertiesOrUndefined(fullDocIdStr: FullDocIdStr): DocType | undefined;
+    executeQuery(query: Query): Array<DocType>;
+    private convertToDocType;
+    private convertToLokiCondition;
+    private getDbCollection;
+    private getDbIdToDocForCollection;
+    /** Converts multiple == conditions to $in, and multiple != conditions to $nin */
+    private applyEqualityConditions;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { FullDocIdStr, Paths, UserFacingDocType } from '@squidcloud/common';
+import { DataManager } from './data.manager';
+import { QueryBuilderFactory } from './query/query-builder.factory';
+import { TransactionId } from './types';
+export declare class DocumentReference<T extends UserFacingDocType = any> {
+    readonly fullDocId: FullDocIdStr;
+    private readonly dataManager;
+    private readonly queryBuilderFactory;
+    constructor(fullDocId: FullDocIdStr, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
+    data(): T;
+    get(): Promise<DocumentReference<T> | undefined>;
+    isDirty(): boolean;
+    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>;
+}

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

@@ -0,0 +1,9 @@
+import { FullDocIdStr } 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(fullDocId: FullDocIdStr, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
+    setDataManager(dataManager: DataManager): void;
+}

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,4 @@
+export { CollectionReference } from './collection-reference';
+export { DocumentReference } from './document-reference';
+export { Changes } from './query/query-builder.factory';
+export { Squid } from './squid';

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

@@ -0,0 +1,11 @@
+import { ClientId, DocTimestamp, IntegrationId, LockManager, Mutation } from '@squidcloud/common';
+import { RpcManager } from '../rpc.manager';
+import { QuerySubscriptionManager } from '../query/query-subscription.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<DocTimestamp>;
+}

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

@@ -0,0 +1,13 @@
+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/query-builder.factory.d.ts

@@ -0,0 +1,41 @@
+import { CollectionName, FieldName, FullDocIdStr, IntegrationId, Operator, PrimitiveFieldType, Query, UserFacingDocType } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { DocumentReference } from '../document-reference';
+import { DocumentReferenceFactory } from '../document-reference.factory';
+import { QuerySubscriptionManager } from './query-subscription.manager';
+import { Alias } from './query.types';
+export declare class QueryBuilderFactory {
+    private readonly querySubscriptionManager;
+    private readonly documentReferenceFactory;
+    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory);
+    getForDocument<MyDocType extends UserFacingDocType, ReturnType extends Record<Alias, DocumentReference<MyDocType>>>(fullDocId: FullDocIdStr): Omit<QueryBuilder<MyDocType, any, ReturnType, false>, 'join'>;
+    get<MyDocType extends UserFacingDocType, ReturnType extends Record<Alias, DocumentReference<MyDocType>>>(collectionName: CollectionName, integrationId: IntegrationId): Omit<QueryBuilder<MyDocType, any, ReturnType, false>, 'join'>;
+    getForJoin<MyDocType extends UserFacingDocType, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<MyDocType>>>(collectionName: CollectionName, integrationId: IntegrationId, alias: MyAlias): QueryBuilder<MyDocType, MyAlias, ReturnType, true>;
+}
+export declare class QueryBuilder<MyDocType extends UserFacingDocType, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<MyDocType> | undefined>, SupportsJoin extends boolean> {
+    private readonly collectionName;
+    private readonly integrationId;
+    private readonly querySubscriptionManager;
+    private readonly documentReferenceFactory;
+    private readonly alias;
+    private readonly supportsJoin;
+    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, supportsJoin: SupportsJoin, queryBuilderFactory: QueryBuilderFactory);
+    where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): SupportsJoin extends true ? this : Omit<this, 'join'>;
+    limit(limit: number): SupportsJoin extends true ? this : Omit<this, 'join'>;
+    sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): SupportsJoin extends true ? this : Omit<this, 'join'>;
+    join<J extends UserFacingDocType, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: QueryBuilder<J, RightAlias, RightReturnType, true>, leftFieldName: keyof MyDocType & FieldName, rightFieldName: keyof J & FieldName): QueryBuilder<MyDocType, MyAlias, ReturnType & Partial<RightReturnType>, true>;
+    snapshot(): SupportsJoin extends true ? Promise<Array<ReturnType>> : Promise<Array<DocumentReference<MyDocType>>>;
+    snapshots(subscribe?: boolean): SupportsJoin extends true ? Observable<Array<ReturnType>> : Observable<Array<DocumentReference<MyDocType>>>;
+    changes(): Observable<Changes<MyDocType>>;
+    build(): Query;
+}
+export interface Changes<MyDocType extends UserFacingDocType> {
+    inserts: Array<DocumentReference<MyDocType>>;
+    updates: Array<DocumentReference<MyDocType>>;
+    deletes: Array<MyDocType>;
+}

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

@@ -0,0 +1,55 @@
+import { ClientId, ClientRequestId, DocType, FullDocIdStr, Query, QuerySubscriptionId } from '@squidcloud/common';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { DbDao } from '../db.dao';
+import { DestructManager } from '../destruct.manager';
+import { RpcManager } from '../rpc.manager';
+import { Alias, JoinCondition } from './query.types';
+export declare class QuerySubscriptionManager {
+    private readonly rpcManager;
+    private readonly clientId;
+    private readonly dbDao;
+    private readonly destructManager;
+    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, dbDao: DbDao, destructManager: DestructManager);
+    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
+    getQuery(clientRequestId: ClientRequestId): Query;
+    setGotResponseFromServer(clientRequestId: ClientRequestId): void;
+    findQueriesForDocument(doc: DocType, fullDocId: FullDocIdStr): 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 (fullDocId --> client request Ids and, clientRequestId --> fullDocIds).
+     * 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(fullDocId: FullDocIdStr, properties: DocType | undefined): Array<ClientRequestId>;
+    errorOutAllQueries(fullDocId: FullDocIdStr, 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, DocType | undefined>>>;
+    hasOngoingQueryForDocId(fullDocIdStr: 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 destruct;
+    hasSubscription(clientRequestId: ClientRequestId): boolean;
+    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
+    private sendQueryToServer;
+}

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,23 @@
+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);
+    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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,48 @@
+import { ApiEndpointId, ApiKey, AppId, CollectionName, IntegrationId, QueryName, UserFacingDocType } from '@squidcloud/common';
+import { CollectionReference } from './collection-reference';
+import { TransactionId } from './types';
+import { GraphQLClient } from './graphql-client';
+export interface SquidOptions {
+    messageNotificationWrapper?: (fn: () => any) => any;
+    appId: AppId;
+    apiKey?: ApiKey;
+    baseUrl?: string;
+    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 dbDao;
+    private readonly lockManager;
+    private readonly querySubscriptionManager;
+    private readonly queryBuilderFactory;
+    private readonly collectionReferenceFactory;
+    private readonly backendFunctionManager;
+    private readonly namedQueryManager;
+    private readonly apiManager;
+    private readonly graphqlClientFactory;
+    private readonly destructManager;
+    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 UserFacingDocType>(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>;
+}

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

@@ -0,0 +1,7 @@
+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;

package/dist/typescript-client/src/state/actions.d.ts

@@ -0,0 +1,29 @@
+import { StateLeafNode } from './action.applier';
+export declare enum ActionType {
+    DELETE_PATH = "DELETE_PATH",
+    SET_PATH = "SET_PATH",
+    BATCH_ACTION = "BATCH_ACTION"
+}
+export declare interface BaseAction {
+    type: ActionType;
+}
+export declare interface PathAction extends BaseAction {
+    path: string[];
+}
+export type DeletePathAction = PathAction;
+export declare interface SetPathAction extends PathAction {
+    payload?: StateLeafNode;
+}
+export declare interface BatchAction extends BaseAction {
+    payload: BaseAction[];
+}
+export declare interface StateMessage {
+    type: 'ACTIONS';
+    payload: BaseAction[];
+}
+export declare function isPathAction(action: BaseAction): action is PathAction;
+export declare function isSetPathAction(action: BaseAction): action is SetPathAction;
+export declare function isDeletePathAction(action: BaseAction): action is DeletePathAction;
+export declare function isBatchAction(action: BaseAction): action is BatchAction;
+export declare function extractAllPathActions(action: BaseAction): PathAction[];
+export declare function getSingleAction(actions: BaseAction[]): BaseAction;

package/dist/typescript-client/src/state/path_trie.d.ts

@@ -0,0 +1,27 @@
+import { BaseAction } from './actions';
+export declare class PathTrie<T> {
+    private root;
+    getOrCreatePathTrieNode(path: string[], nodeData?: T): PathTrieNode<T>;
+    getPathTrieNode(path: string[]): PathTrieNode<T> | undefined;
+    getPathTrie(path: string[]): PathTrie<T> | undefined;
+    /**
+     * If the callback returns false, it will not iterate into the children of the current node.
+     */
+    iterateBfs(callback: (data: T, path: string[]) => void | boolean): void;
+    removeNode(path: string[]): void;
+    clearNodeData(path: string[]): void;
+    getNodeList(path: string[]): Array<PathTrieNode<T>>;
+    private iterateInternal;
+}
+export declare class PathTrieNode<T> {
+    children: Map<string, PathTrieNode<T>>;
+    nodeData: T | undefined;
+}
+/**
+ * Returns a trie which contains all the paths affected by the action. For
+ * example, if the action contains a path action applied on path [A, B, C], then
+ * [A], [A, B], [A, B, C] will be in the returned trie. Moreover, if
+ * subscriptionTree is provided and contains [A, B, C, ...], then [A, B, C, ...]
+ * will also be included in the returned trie.
+ */
+export declare function getPathTrieFromAction(action: BaseAction, subscriptionTree?: PathTrie<{}>): PathTrie<boolean>;

package/dist/typescript-client/src/state/state.service.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { State, StateLeafNode } from './action.applier';
+import { BaseAction } from './actions';
+export declare class StateService {
+    private readonly subscriptionsTree;
+    private state;
+    private batchCount;
+    private readonly batchedActions;
+    dispatch(action: BaseAction): void;
+    runInBatch(fn: () => unknown): void;
+    observePath<T>(path: string[], pathsToExcludeFn?: () => Array<string[]>): Observable<T>;
+    setKeyInPath<T extends State>(path: string[], key: keyof T & string, value: T[keyof T] & StateLeafNode, noopIfSame?: boolean): void;
+    setPartial<T extends State>(path: string[], partialState: Partial<T>, noopIfSame?: boolean): void;
+    setInPath(path: string[], payload: StateLeafNode, noopIfSame?: boolean): void;
+    pushToArray(path: string[], payload: StateLeafNode): void;
+    deletePath(path: string[]): void;
+    getState(): State;
+    getStateInPath<T extends StateLeafNode>(path: string[]): T;
+    destroy(): void;
+    private getOrCreateSubjectForPath;
+    private dispatchSubscriptions;
+}

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

@@ -0,0 +1,2 @@
+export type TransactionId = string;
+export declare const NOOP_FN: (fn: () => any) => any;