@squidcloud/client 1.0.10 → 1.0.11

package/dist/package.json

@@ -37,18 +37,16 @@
     "@supercharge/promise-pool": "^2.3.2",
     "cross-fetch": "^3.1.5",
     "lodash": "^4.17.21",
-    "lokijs": "^1.5.12",
     "rxjs": "7.5.7",
     "socket.io-client": "^4.5.2"
   },
   "devDependencies": {
-    "cpx": "^1.5.0",
     "@types/lodash": "^4.14.186",
-    "@types/lokijs": "^1.5.7",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
     "@webpack-cli/generators": "^3.0.0",
     "copy-webpack-plugin": "^11.0.0",
+    "cpx": "^1.5.0",
     "eslint": "8.22.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",

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

@@ -1,9 +1,9 @@
-import { DocId, DocIdObj, IdResolutionMap, 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;

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

@@ -1,4 +1,4 @@
-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';
@@ -9,6 +9,6 @@ export declare class CollectionReferenceFactory {
     private readonly documentIdentityService;
     private readonly collections;
     constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, documentIdentityService: DocumentIdentityService);
-    get<T extends UserFacingDocType>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
+    get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
     private migrateDocIds;
 }

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

@@ -1,7 +1,7 @@
-import { DocTimestamp, 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';
@@ -9,10 +9,10 @@ import { SocketManagerInterface } from './socket.manager';
 import { TransactionId } from './types';
 export interface DocTimestampMetadata {
     timestamp: DocTimestamp;
-    expireTimestamp: number | undefined;
+    expireTimestamp?: number;
 }
 export declare class DataManager {
-    private readonly dbDao;
+    private readonly documentStore;
     private readonly mutationSender;
     private readonly socketManager;
     private readonly querySubscriptionManager;
@@ -20,7 +20,7 @@ export declare class DataManager {
     private readonly lockManager;
     private readonly destructManager;
     private readonly documentIdentityService;
-    private readonly fullDocIdToLocalTimestamp;
+    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
@@ -37,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
@@ -59,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;
@@ -79,13 +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, documentIdentityService: DocumentIdentityService);
-    getProperties(fullDocIdStr: FullDocIdStr): DocType | undefined;
+    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(fullDocIdStr: FullDocIdStr): boolean;
-    /** Whether the document is tracked by any ongoing queries or outgoing mutations. */
-    isTracked(fullDocIdStr: FullDocIdStr): boolean;
+    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
@@ -114,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
@@ -122,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.
      */
-    private isDocumentSafeForDelete;
+    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 applyLocalDbUpdateFromSnapshot;
+    private updateDocumentFromSnapshot;
     private finishTransaction;
     private sendAllUnsentOutgoingMutations;
     private sendMutationsForIntegration;
@@ -145,6 +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

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

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

@@ -1,13 +1,13 @@
-import { FullDocIdStr, IdResolutionMap, 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> {
-    private _fullDocId;
+export declare class DocumentReference<T extends DocumentData = any> {
+    private _squidDocId;
     private readonly dataManager;
     private readonly queryBuilderFactory;
-    constructor(_fullDocId: FullDocIdStr, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
-    get fullDocId(): FullDocIdStr;
+    constructor(_squidDocId: SquidDocId, dataManager: DataManager, queryBuilderFactory: QueryBuilderFactory);
+    get squidDocId(): SquidDocId;
     data(): T;
     get(): Promise<DocumentReference<T> | undefined>;
     isDirty(): boolean;

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/query/query-builder.factory.d.ts

@@ -1,4 +1,4 @@
-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';
@@ -10,11 +10,11 @@ export declare class QueryBuilderFactory {
     private readonly documentReferenceFactory;
     private readonly documentIdentityService;
     constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, documentIdentityService: DocumentIdentityService);
-    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>;
+    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;
@@ -28,17 +28,17 @@ export declare class QueryBuilder<MyDocType extends UserFacingDocType, MyAlias e
     /** 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, documentIdentityService: DocumentIdentityService);
-    where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): SupportsJoin extends true ? this : Omit<this, 'join'>;
+    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,14 @@
-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>;
@@ -22,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, documentIdentityService: DocumentIdentityService);
+    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;
@@ -50,7 +50,7 @@ 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;

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

@@ -1,4 +1,4 @@
-import { ApiEndpointId, ApiKey, AppId, CollectionName, IntegrationId, QueryName, UserFacingDocType } from '@squidcloud/common';
+import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, IntegrationId, QueryName, SquidRegion } from '@squidcloud/common';
 import { CollectionReference } from './collection-reference';
 import { GraphQLClient } from './graphql-client';
 import { TransactionId } from './types';
@@ -6,7 +6,7 @@ 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;
@@ -39,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/dist/typescript-client/src/testing/squid-env-setup.d.ts

@@ -1,12 +1,12 @@
-import { ClientRequestId, CollectionName, DocId, DocType, IntegrationId, LockManager, MutationType } from '@squidcloud/common';
+import { ClientRequestId, CollectionName, DocId, IntegrationId, LockManager, MutationType, SquidDocument } from '@squidcloud/common';
 import { Subject, Subscription } from 'rxjs';
 import { CollectionReference } from '../collection-reference';
 import { CollectionReferenceFactory } from '../collection-reference.factory';
 import { DataManager } from '../data.manager';
-import { DbDao } from '../db.dao';
 import { DestructManager } from '../destruct.manager';
 import DocumentIdentityService from '../document-identity.service';
 import { DocumentReferenceFactory } from '../document-reference.factory';
+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';
@@ -42,7 +42,7 @@ export declare class SquidEnvSetup {
     readonly querySubscriptionManager: QuerySubscriptionManager;
     readonly socketManager: FakeSocketManager;
     readonly rpcManager: FakeRpcManager;
-    readonly dbDao: DbDao;
+    readonly documentStore: DocumentStore;
     readonly documentReferenceFactory: DocumentReferenceFactory;
     readonly collectionReferenceFactory: CollectionReferenceFactory;
     readonly queryBuilderFactory: QueryBuilderFactory;
@@ -55,18 +55,18 @@ export declare class SquidEnvSetup {
     readonly collectionA: CollectionReference<TestDocTypeA>;
     readonly collectionB: CollectionReference<TestDocTypeB>;
     constructor();
-    simulateQueryResponse(docs: Array<Partial<DocType>>, collectionName: CollectionName, integrationId?: IntegrationId, clientRequestId?: ClientRequestId): void;
+    simulateQueryResponse(docs: Array<Partial<SquidDocument>>, collectionName: CollectionName, integrationId?: IntegrationId, clientRequestId?: ClientRequestId): void;
     simulateMutationsResponse(updates: Array<{
         mutationType: MutationType;
         collectionName: CollectionName;
         integrationId?: IntegrationId;
         clientRequestId?: ClientRequestId;
-        doc: Partial<DocType> & {
+        doc: Partial<SquidDocument> & {
             __docId__: DocId;
         };
-    }>, mutationsTimestamp?: number): void;
+    }>, mutationsTimestamp?: number): Promise<void>;
     simulateErrorResponse(message: string): void;
-    runAsync(fn: () => any): void;
+    runAsync(fn: () => any): Promise<void>;
     getInternalDocId(idValue: string): string;
     executeQueryOnCollectionA(subscribe?: boolean): QueryResponse;
     executeJoinQuery(subscribe?: boolean): JoinQueryResponse;
@@ -74,3 +74,4 @@ export declare class SquidEnvSetup {
     simulateResponseForCollectionB(id: string, b: number): void;
 }
 export declare let squidEnvSetup: SquidEnvSetup;
+export declare function squidEnvSetupBeforeEach(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/index.js",
   "types": "dist/typescript-client/src/index.d.ts",
@@ -37,18 +37,16 @@
     "@supercharge/promise-pool": "^2.3.2",
     "cross-fetch": "^3.1.5",
     "lodash": "^4.17.21",
-    "lokijs": "^1.5.12",
     "rxjs": "7.5.7",
     "socket.io-client": "^4.5.2"
   },
   "devDependencies": {
-    "cpx": "^1.5.0",
     "@types/lodash": "^4.14.186",
-    "@types/lokijs": "^1.5.7",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
     "@webpack-cli/generators": "^3.0.0",
     "copy-webpack-plugin": "^11.0.0",
+    "cpx": "^1.5.0",
     "eslint": "8.22.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",

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

@@ -1,22 +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;
-    isInMemory(fullDocIdStr: FullDocIdStr): boolean;
-    isInDatabase(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;
-    migrateDocId(fullDocIdStr: FullDocIdStr, newFullDocIdStr: FullDocIdStr): void;
-}