@my-devkit/firebase 1.0.127 → 1.0.129

package/src/firestore-client.ts

@@ -1,4 +1,4 @@
-import { deserialize, Document, Logger, NotFoundError, serialize } from '@my-devkit/core';
+import { _orderBy, Cacheable, deserialize, Document, Logger, NotFoundError, serialize } from '@my-devkit/core';
 import { getFirestore } from 'firebase-admin/firestore';
 
 import { Injectable, TransactionalClient } from './decorators';
@@ -9,41 +9,41 @@ import { ITransactionalClient } from './interfaces';
 @Injectable()
 export class FirestoreClient implements ITransactionalClient {
     private db = getFirestore();
-    private operations: FirestoreClient.Operation[] = [];
-    private cachedDocuments = new Map<string, Document>();
+    private operations = new Map<string, FirestoreClient.Operation>();
 
     public async save(): Promise<void> {
-        Logger.info(`Saving ${this.operations.length} operations`);
+        Logger.info(`Saving ${this.operations.size} operations`);
 
-        for (const operation of this.operations) {
-            if (operation.action === FirestoreClient.Action.Create) {
+        for (const operation of Array.from(this.operations.values())) {
+            if (this.isCreateOperation(operation)) {
                 Logger.info(`Create document ${operation.document._path}`);
                 await this.db.doc(operation.document._path).set(serialize(operation.document));
-            } else if (operation.action === FirestoreClient.Action.Update) {
+            } else if (this.isUpdateOperation(operation)) {
                 Logger.info(`Update document ${operation.document._path}`);
                 await this.db.doc(operation.document._path).set(serialize(operation.document));
-            } else if (operation.action === FirestoreClient.Action.Delete) {
+            } else if (this.isDeleteOperation(operation)) {
                 Logger.info(`Delete document ${operation.document._path}`);
                 await this.db.doc(operation.document._path).delete();
             } else {
-                throw new Error(`Transactional Repository: Not supported action ${operation.action}`);
+                throw new Error(`Not supported action ${operation.action}`);
             }
         }
     }
 
-    public async _find<T>(path: string): Promise<T> {
+    public async _find<T extends Document>(path: string): Promise<T> {
         Logger.info(`Repository: find ${path}`);
-        if (this.cachedDocuments.has(path)) {
+        if (this.operations.has(path)) {
             Logger.info(`Repository: document returned from transaction`);
-            return <any>this.cachedDocuments.get(path);
+            const operation = this.operations.get(path);
+            return this.isDeleteOperation(operation) ? null : <T>operation.document;
         }
-        const doc = await this.db.doc(path).get();
-        const result = doc.data();
-        return result ? deserialize(result) : null;
+
+        return this.queryDocument<T>(path);
     }
 
-    public async _findWhere<T>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = []): Promise<T> {
-        const documents = await this._getWhere<T>(collection, whereClauses);
+    public async _findWhere<T extends Document>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], options?: FirestoreClient.QueryOptions): Promise<T> {
+        const documents = await this._getWhere<T>(collection, whereClauses, options);
+
         if (documents.length > 1) {
             throw new Error(`Transactional Repository: Too many documents found (${documents.length})`);
         }
@@ -51,7 +51,7 @@ export class FirestoreClient implements ITransactionalClient {
         return documents[0] || null;
     }
 
-    public async _get<T>(path: string): Promise<T> {
+    public async _get<T extends Document>(path: string): Promise<T> {
         Logger.info(`Repository: get ${path}`);
         const result = await this._find<T>(path);
         if (!result) {
@@ -61,52 +61,120 @@ export class FirestoreClient implements ITransactionalClient {
         return result;
     }
 
-    public async _getAll<T>(collection: string): Promise<T[]> {
-        Logger.info(`Repository: getAll ${collection}`);
-        const documents: T[] = [];
-        const querySnapshot = await this.getCollectionReference(collection).get();
-        querySnapshot.forEach(doc => {
-            documents.push(deserialize(doc.data()));
-        });
-        return documents;
+    public async _getAll<T extends Document>(collection: string, options?: FirestoreClient.QueryOptions): Promise<T[]> {
+        return this._getWhere(collection, [], options);
     }
 
-    public async _getWhere<T>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], orderBy: string = null): Promise<T[]> {
+    public async _getWhere<T extends Document>(collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [], options?: FirestoreClient.QueryOptions): Promise<T[]> {
         Logger.info(`Repository: getWhere ${collection} whereClauses: ${JSON.stringify(whereClauses)}`);
-        const documents: T[] = [];
+        const documentMap = await this.queryCollection<T>(collection, whereClauses, options);
 
-        let query = this.getCollectionReference(collection);
+        for (const operation of Array.from(this.operations.values())) {
+            const exists = documentMap.has(operation.document._path);
 
-        whereClauses.forEach(where => {
-            query = query.where(where[0], where[1], where[2]);
-        });
+            switch (operation.action) {
+                case FirestoreClient.Action.Create:
+                    if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
+                        documentMap.set(operation.document._path, <T>operation.document);
+                        Logger.info(`Repository: Document ${operation.document._path} added to result`);
+                    }
+                    break;
+                case FirestoreClient.Action.Update:
+                    if (this.doesDocumentMatchQuery(operation.document, collection, whereClauses)) {
+                        Logger.info(`Repository: Document ${operation.document._path} ${exists ? 'updated from' : 'added to'} result`);
+                        documentMap.set(operation.document._path, <T>operation.document);
+                    } else if (exists) {
+                        documentMap.delete(operation.document._path);
+                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
+                    }
+                    break;
+                case FirestoreClient.Action.Delete:
+                    if (exists) {
+                        documentMap.delete(operation.document._path);
+                        Logger.info(`Repository: Document ${operation.document._path} removed from result`);
+                    }
+                    break;
+                default:
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${operation.action} on ${operation.document._path}`);
+            }
+        }
 
-        if (orderBy) {
-            query = query.orderBy(orderBy);
+        Logger.info(`Repository: ${documentMap.size} documents found`);
+
+        let documents = Array.from(documentMap.values());
+
+        if (options?.orderBy) {
+            documents = _orderBy(documents, [options.orderBy], [options.orderByDirection || 'asc']);
         }
 
-        const querySnapshot = await query.get();
-        querySnapshot.forEach(doc => {
-            documents.push(deserialize(doc.data()));
-        });
+        if (options?.limit) {
+            documents = documents.slice(0, options.limit);
+        }
 
         return documents;
     }
 
 
-    public createDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Create });
-        this.cachedDocuments.set(document._path, document);
+    public createDocument<T extends Document>(document: T): void {
+        const existingOperation = this.operations.get(document._path);
+
+        if (existingOperation) {
+            switch (existingOperation.action) {
+                case FirestoreClient.Action.Create:
+                    throw new Error(`FirestoreClient: can't create twice document ${document._path}`);
+                case FirestoreClient.Action.Update:
+                    throw new Error(`FirestoreClient: can't create already existing document ${document._path}`);
+                case FirestoreClient.Action.Delete:
+                    existingOperation.action = FirestoreClient.Action.Update;
+                    existingOperation.document = document;
+                    break;
+                default:
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+            }
+        } else {
+            this.operations.set(document._path, { document, action: FirestoreClient.Action.Create });
+        }
     }
 
-    public updateDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Update });
-        this.cachedDocuments.set(document._path, document);
+    public updateDocument<T extends Document>(document: T): void {
+        const existingOperation = this.operations.get(document._path);
+
+        if (existingOperation) {
+            switch (existingOperation.action) {
+                case FirestoreClient.Action.Create:
+                case FirestoreClient.Action.Update:
+                    existingOperation.document = document;
+                    break;
+                case FirestoreClient.Action.Delete:
+                    throw new Error(`FirestoreClient: can't update deleted document ${document._path}`);
+                default:
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+            }
+        } else {
+            this.operations.set(document._path, { document, action: FirestoreClient.Action.Update });
+        }
     }
 
-    public deleteDocument(document: Document): void {
-        this.operations.push({ document, action: FirestoreClient.Action.Delete });
-        this.cachedDocuments.delete(document._path);
+    public deleteDocument<T extends Document>(document: T): void {
+        const existingOperation = this.operations.get(document._path);
+
+        if (existingOperation) {
+            switch (existingOperation.action) {
+                case FirestoreClient.Action.Create:
+                    this.operations.delete(document._path);
+                    break;
+                case FirestoreClient.Action.Update:
+                    existingOperation.document = document;
+                    existingOperation.action = FirestoreClient.Action.Delete;
+                    break;
+                case FirestoreClient.Action.Delete:
+                    throw new Error(`FirestoreClient: can't delete already deleted document ${document._path}`);
+                default:
+                    throw new Error(`FirestoreClient: Unhandled existing operation ${existingOperation.action} on ${document._path}`);
+            }
+        } else {
+            this.operations.set(document._path, { document, action: FirestoreClient.Action.Delete });
+        }
     }
 
     private getCollectionReference(collection: string): FirebaseFirestore.CollectionReference | FirebaseFirestore.Query {
@@ -116,6 +184,90 @@ export class FirestoreClient implements ITransactionalClient {
             return this.db.collection(collection);
         }
     }
+
+    @Cacheable()
+    private async queryCollection<T extends Document>(
+        collection: string,
+        whereClauses: [string, FirestoreClient.Operator, any | any[]][] = [],
+        options: FirestoreClient.QueryOptions
+    ): Promise<Map<string, T>> {
+        let query = this.getCollectionReference(collection);
+
+        whereClauses.forEach(where => {
+            query = query.where(where[0], where[1], where[2]);
+        });
+
+        if (options?.orderBy) {
+            query = query.orderBy(options.orderBy, options.orderByDirection || 'asc');
+        }
+
+        if (options?.limit) {
+            query = query.limit(options.limit);
+        }
+
+        const querySnapshot = await query.get();
+
+        const documents = new Map<string, T>();
+        querySnapshot.forEach(doc => {
+            const document = deserialize<T>(doc.data());
+            documents.set(document._path, document);
+        });
+        return documents;
+    }
+
+    @Cacheable()
+    private async queryDocument<T extends Document>(path: string): Promise<T> {
+        const doc = await this.db.doc(path).get();
+        const result = doc.data();
+        return result ? deserialize<T>(result) : null;
+    }
+
+    private doesDocumentMatchQuery<T extends Document>(document: T, collection: string, whereClauses: [string, FirestoreClient.Operator, any | any[]][]): boolean {
+        const serializedDocument = serialize(document);
+
+        return document._path.startsWith(`${collection}/`) && whereClauses.every(wc => {
+            const documentValue = serializedDocument[wc[0]];
+            const operator = wc[1];
+            const expectedValue = wc[2];
+
+            switch (operator) {
+                case '==':
+                    return documentValue === expectedValue;
+                case '!=':
+                    return documentValue !== undefined && documentValue !== expectedValue;
+                case '>':
+                    return documentValue > expectedValue;
+                case '>=':
+                    return documentValue >= expectedValue;
+                case '<':
+                    return documentValue < expectedValue;
+                case '<=':
+                    return documentValue <= expectedValue;
+                case 'array-contains':
+                    return Array.isArray(documentValue) && documentValue.includes(expectedValue);
+                case 'array-contains-any':
+                    return Array.isArray(documentValue) && Array.isArray(expectedValue) && documentValue.some(v => expectedValue.includes(v));
+                case 'in':
+                    return Array.isArray(expectedValue) && expectedValue.includes(documentValue);
+                case 'not-in':
+                    return Array.isArray(expectedValue) && !expectedValue.includes(documentValue);
+                default:
+                    throw new Error(`Operator ${operator} not handled!`);
+            }
+        });
+    }
+
+    private isCreateOperation(operation: FirestoreClient.Operation): boolean {
+        return operation.action === FirestoreClient.Action.Create;
+    }
+
+    private isUpdateOperation(operation: FirestoreClient.Operation): boolean {
+        return operation.action === FirestoreClient.Action.Update;
+    }
+
+    private isDeleteOperation(operation: FirestoreClient.Operation): boolean {
+        return operation.action === FirestoreClient.Action.Delete;
+    }
 }
 
 export namespace FirestoreClient {
@@ -131,4 +283,10 @@ export namespace FirestoreClient {
         Delete = <any>'Delete'
     }
     export type Operator = FirebaseFirestore.WhereFilterOp;
+
+    export interface QueryOptions {
+        orderBy?: string;
+        orderByDirection?: FirebaseFirestore.OrderByDirection;
+        limit?: number;
+    }
 }