@squidcloud/backend 1.0.0 → 1.0.2

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

@@ -1,16 +1,17 @@
-import { DocId, DocIdObj, IntegrationId, UserFacingDocType } from '@squidcloud/common';
+import { DocId, DocIdObj, DocumentData, IdResolutionMap, IntegrationId } 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> {
+export declare class CollectionReference<T extends DocumentData> {
     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>;
+    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>;
+    migrateDocIds(idResolutionMap: IdResolutionMap): void;
 }

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

@@ -1,11 +1,14 @@
-import { CollectionName, IntegrationId, UserFacingDocType } from '@squidcloud/common';
+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 { QueryBuilderFactory } from './query/query-builder.factory';
 export declare class CollectionReferenceFactory {
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
+    private readonly documentIdentityService;
     private readonly collections;
-    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory);
-    get<T extends UserFacingDocType>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
+    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, documentIdentityService: DocumentIdentityService);
+    get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
+    private migrateDocIds;
 }

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

@@ -1,20 +1,26 @@
-import { DocType, FullDocIdStr, LockManager, Mutation } from '@squidcloud/common';
-import { DbDao } from './db.dao';
+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 dbDao;
+    private readonly documentStore;
     private readonly mutationSender;
     private readonly socketManager;
     private readonly querySubscriptionManager;
     private readonly queryBuilderFactory;
     private readonly lockManager;
     private readonly destructManager;
-    private readonly fullDocIdToLocalTimestamp;
+    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
@@ -31,7 +37,7 @@ export declare class DataManager {
      * 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;
+    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
@@ -53,7 +59,7 @@ export declare class DataManager {
      *     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
+     * 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;
@@ -73,10 +79,11 @@ export declare class DataManager {
     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;
+    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
@@ -105,7 +112,7 @@ export declare class DataManager {
     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.
+     * 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
@@ -113,17 +120,29 @@ export declare class DataManager {
      */
     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
+     * 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.
      */
-    private isDocumentSafeForDelete;
+    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 applyLocalDbUpdateFromSnapshot;
+    private updateDocumentFromSnapshot;
     private finishTransaction;
     private sendAllUnsentOutgoingMutations;
     private sendMutationsForIntegration;
@@ -136,5 +155,8 @@ export declare class DataManager {
      * An orphan document should not stay locally since it may be stale after some time.
      */
     private handleOrphanDocs;
-    private removeDocumentLocally;
+    private acknowledgeDocument;
+    private setExpiration;
+    private forgetDocument;
+    private migrateDocIds;
 }

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

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

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

@@ -0,0 +1,12 @@
+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,18 +1,21 @@
-import { FullDocIdStr, Paths, UserFacingDocType } from '@squidcloud/common';
+import { DocumentData, IdResolutionMap, Paths, SquidDocId } 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;
+export declare class DocumentReference<T extends DocumentData = any> {
+    private _squidDocId;
     private readonly dataManager;
     private readonly queryBuilderFactory;
-    constructor(fullDocId: FullDocIdStr, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
+    constructor(_squidDocId: SquidDocId, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
+    get squidDocId(): SquidDocId;
     data(): T;
     get(): Promise<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 +1,9 @@
-import { FullDocIdStr } from '@squidcloud/common';
+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(fullDocId: FullDocIdStr, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
+    create(squidDocId: SquidDocId, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
     setDataManager(dataManager: DataManager): void;
 }

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

@@ -0,0 +1,11 @@
+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/mutation/mutation-sender.d.ts

@@ -1,11 +1,11 @@
-import { ClientId, DocTimestamp, IntegrationId, LockManager, Mutation } from '@squidcloud/common';
-import { RpcManager } from '../rpc.manager';
+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<DocTimestamp>;
+    sendMutations(mutations: Array<Mutation>, integrationId: IntegrationId): Promise<MutateResponse>;
 }

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

@@ -1,5 +1,6 @@
-import { CollectionName, FieldName, FullDocIdStr, IntegrationId, Operator, PrimitiveFieldType, Query, UserFacingDocType } from '@squidcloud/common';
+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';
@@ -7,12 +8,13 @@ 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>;
+    private readonly documentIdentityService;
+    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, documentIdentityService: DocumentIdentityService);
+    getForDocument<DocumentType extends DocumentData, ReturnType extends Record<Alias, DocumentReference<DocumentType>>>(squidDocId: SquidDocId): Omit<QueryBuilder<DocumentType, any, ReturnType, false>, 'join'>;
+    get<DocumentType extends DocumentData, ReturnType extends Record<Alias, DocumentReference<DocumentType>>>(collectionName: CollectionName, integrationId: IntegrationId): Omit<QueryBuilder<DocumentType, any, ReturnType, false>, 'join'>;
+    getForJoin<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType>>>(collectionName: CollectionName, integrationId: IntegrationId, alias: MyAlias): QueryBuilder<DocumentType, MyAlias, ReturnType, true>;
 }
-export declare class QueryBuilder<MyDocType extends UserFacingDocType, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<MyDocType> | undefined>, SupportsJoin extends boolean> {
+export declare class QueryBuilder<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType> | undefined>, SupportsJoin extends boolean> {
     private readonly collectionName;
     private readonly integrationId;
     private readonly querySubscriptionManager;
@@ -20,22 +22,23 @@ export declare class QueryBuilder<MyDocType extends UserFacingDocType, MyAlias e
     private readonly alias;
     private readonly supportsJoin;
     private readonly queryBuilderFactory;
+    private readonly documentIdentityService;
     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'>;
+    constructor(collectionName: CollectionName, integrationId: IntegrationId, querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, alias: MyAlias, supportsJoin: SupportsJoin, queryBuilderFactory: QueryBuilderFactory, documentIdentityService: DocumentIdentityService);
+    where(fieldName: (keyof DocumentType & 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>>;
+    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): SupportsJoin extends true ? this : Omit<this, 'join'>;
+    join<J extends DocumentData, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: QueryBuilder<J, RightAlias, RightReturnType, true>, leftFieldName: keyof DocumentType & FieldName, rightFieldName: keyof J & FieldName): QueryBuilder<DocumentType, MyAlias, ReturnType & Partial<RightReturnType>, true>;
+    snapshot(): SupportsJoin extends true ? Promise<Array<ReturnType>> : Promise<Array<DocumentReference<DocumentType>>>;
+    snapshots(subscribe?: boolean): SupportsJoin extends true ? Observable<Array<ReturnType>> : Observable<Array<DocumentReference<DocumentType>>>;
+    changes(): Observable<Changes<DocumentType>>;
     build(): Query;
 }
-export interface Changes<MyDocType extends UserFacingDocType> {
-    inserts: Array<DocumentReference<MyDocType>>;
-    updates: Array<DocumentReference<MyDocType>>;
-    deletes: Array<MyDocType>;
+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,14 +1,16 @@
-import { ClientId, ClientRequestId, DocType, FullDocIdStr, Query, QuerySubscriptionId } from '@squidcloud/common';
+import { ClientId, ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { DbDao } from '../db.dao';
 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 dbDao;
+    private readonly documentStore;
     private readonly destructManager;
+    private readonly documentIdentityService;
     readonly safeToSendQueriesToServer: BehaviorSubject<boolean>;
     onOrphanDocuments: Subject<string[]>;
     private readonly ongoingQueries;
@@ -20,22 +22,22 @@ export declare class QuerySubscriptionManager {
     private readonly clientRequestIdToLocalDocuments;
     private readonly localDocumentToClientRequestIds;
     private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientId: ClientId, dbDao: DbDao, destructManager: DestructManager);
+    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: DocType, fullDocId: FullDocIdStr): Array<QuerySubscriptionId>;
+    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 (fullDocId --> client request Ids and, clientRequestId --> fullDocIds).
+     * 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(fullDocId: FullDocIdStr, properties: DocType | undefined): Array<ClientRequestId>;
-    errorOutAllQueries(fullDocId: FullDocIdStr, err: any): void;
+    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, DocType | undefined>>>;
-    hasOngoingQueryForDocId(fullDocIdStr: string): boolean;
+    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;
@@ -48,8 +50,9 @@ export declare class QuerySubscriptionManager {
     private updateOngoingQueryWithNewDataFromSupportingQuery;
     private allOngoingQueriesGotServerResult;
     private completeAllSupportedQueries;
-    private destruct;
+    private predestruct;
     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/squid.d.ts

@@ -1,12 +1,12 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, IntegrationId, QueryName, UserFacingDocType } from '@squidcloud/common';
+import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, IntegrationId, PartialBy, QueryName, SquidRegion } from '@squidcloud/common';
 import { CollectionReference } from './collection-reference';
-import { TransactionId } from './types';
 import { GraphQLClient } from './graphql-client';
+import { TransactionId } from './types';
 export interface SquidOptions {
     messageNotificationWrapper?: (fn: () => any) => any;
     appId: AppId;
     apiKey?: ApiKey;
-    baseUrl?: string;
+    region: SquidRegion;
     apiServerUrlOverrideMapping?: Record<IntegrationId, string>;
 }
 /** Reference to the squid db. Provides all the available actions on the DB. */
@@ -16,7 +16,7 @@ export declare class Squid {
     private readonly rpcManager;
     private readonly dataManager;
     private readonly documentReferenceFactory;
-    private readonly dbDao;
+    private readonly documentStore;
     private readonly lockManager;
     private readonly querySubscriptionManager;
     private readonly queryBuilderFactory;
@@ -26,8 +26,9 @@ export declare class Squid {
     private readonly apiManager;
     private readonly graphqlClientFactory;
     private readonly destructManager;
+    private readonly documentIdentityService;
     private static readonly squidInstancesMap;
-    constructor(options: SquidOptions);
+    constructor(options: PartialBy<SquidOptions, 'region'>);
     /**
      * This method is a factory method for creating a Squid instance
      */
@@ -38,7 +39,7 @@ export declare class Squid {
      * to the security rules.
      */
     setAuthIdToken(idToken: string | undefined): void;
-    collection<T extends UserFacingDocType>(collectionName: CollectionName, integrationId?: IntegrationId): CollectionReference<T>;
+    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>;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@squidcloud/backend",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Squid Cloud's backend SDK",
   "main": "dist/index.js",
   "types": "dist/backend/src/index.d.ts",
   "scripts": {
     "prebuild": "rimraf dist",
-    "build": "webpack --mode=production"
+    "build": "webpack --mode=production",
+    "publish:public": "npm version patch && npm run build && npm publish --access public"
   },
   "files": [
     "dist/**/*"

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

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