@naturalcycles/firestore-lib 1.2.2 → 1.4.0

package/dist/firestore.db.d.ts

@@ -12,16 +12,15 @@ export interface FirestoreDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyO
 export declare class FirestoreDB extends BaseCommonDB implements CommonDB {
     cfg: FirestoreDBCfg;
     constructor(cfg: FirestoreDBCfg);
-    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], opt?: FirestoreDBOptions): Promise<ROW[]>;
-    getById<ROW extends ObjectWithId>(table: string, id: ROW['id'], _opt?: FirestoreDBOptions): Promise<ROW | null>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: FirestoreDBOptions): Promise<ROW[]>;
     runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: FirestoreDBOptions): Promise<RunQueryResult<ROW>>;
     runFirestoreQuery<ROW extends ObjectWithId>(q: Query, _opt?: FirestoreDBOptions): Promise<ROW[]>;
-    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: FirestoreDBOptions): Promise<number>;
+    runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: FirestoreDBOptions): Promise<number>;
     streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, _opt?: CommonDBStreamOptions): ReadableTyped<ROW>;
     saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: FirestoreDBSaveOptions<ROW>): Promise<void>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: FirestoreDBOptions): Promise<number>;
     deleteByIds<ROW extends ObjectWithId>(table: string, ids: ROW['id'][], _opt?: FirestoreDBOptions): Promise<number>;
     private querySnapshotToArray;
-    commitTransaction(_tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void>;
+    commitTransaction(tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void>;
     ping(): Promise<void>;
 }

package/dist/firestore.db.js

@@ -17,20 +17,27 @@ class FirestoreDB extends db_lib_1.BaseCommonDB {
         this.cfg = cfg;
     }
     // GET
-    async getByIds(table, ids, opt) {
+    async getByIds(table, ids, _opt) {
         // Oj, doesn't look like a very optimal implementation!
         // TODO: check if we can query by keys or smth
-        return (await Promise.all(ids.map(id => this.getById(table, id, opt)))).filter(Boolean);
-    }
-    async getById(table, id, _opt) {
-        const doc = await this.cfg.firestore.collection(table).doc((0, firestore_util_1.escapeDocId)(id)).get();
-        const data = doc.data();
-        if (data === undefined)
-            return null;
-        return {
-            id,
-            ...data,
-        };
+        // return (await Promise.all(ids.map(id => this.getById<ROW>(table, id, opt)))).filter(
+        //   Boolean,
+        // ) as ROW[]
+        if (!ids.length)
+            return [];
+        const { firestore } = this.cfg;
+        const col = firestore.collection(table);
+        return (await firestore.getAll(...ids.map(id => col.doc((0, firestore_util_1.escapeDocId)(id)))))
+            .map(doc => {
+            const data = doc.data();
+            if (data === undefined)
+                return;
+            return {
+                id: (0, firestore_util_1.unescapeDocId)(doc.id),
+                ...data,
+            };
+        })
+            .filter(js_lib_1._isTruthy);
     }
     // QUERY
     async runQuery(q, opt) {
@@ -45,9 +52,10 @@ class FirestoreDB extends db_lib_1.BaseCommonDB {
     async runFirestoreQuery(q, _opt) {
         return this.querySnapshotToArray(await q.get());
     }
-    async runQueryCount(q, opt) {
-        const { rows } = await this.runQuery(q.select([]), opt);
-        return rows.length;
+    async runQueryCount(q, _opt) {
+        const firestoreQuery = (0, query_util_1.dbQueryToFirestoreQuery)(q, this.cfg.firestore.collection(q.table));
+        const r = await firestoreQuery.count().get();
+        return r.data().count;
     }
     streamQuery(q, _opt) {
         const firestoreQuery = (0, query_util_1.dbQueryToFirestoreQuery)(q, this.cfg.firestore.collection(q.table));
@@ -98,8 +106,25 @@ class FirestoreDB extends db_lib_1.BaseCommonDB {
         });
         return rows;
     }
-    async commitTransaction(_tx, _opt) {
-        throw new Error('commitTransaction is not supported yet');
+    async commitTransaction(tx, _opt) {
+        const { firestore } = this.cfg;
+        await firestore.runTransaction(async (tr) => {
+            for (const op of tx.ops) {
+                if (op.type === 'saveBatch') {
+                    op.rows.forEach(row => {
+                        tr.set(firestore.collection(op.table).doc((0, firestore_util_1.escapeDocId)(row.id)), (0, js_lib_1._filterUndefinedValues)(row));
+                    });
+                }
+                else if (op.type === 'deleteByIds') {
+                    op.ids.forEach(id => {
+                        tr.delete(firestore.collection(op.table).doc((0, firestore_util_1.escapeDocId)(id)));
+                    });
+                }
+                else {
+                    throw new Error(`DBOperation not supported: ${op.type}`);
+                }
+            }
+        });
     }
     async ping() {
         // no-op now

package/package.json

@@ -37,7 +37,7 @@
   "engines": {
     "node": ">=14.15.0"
   },
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "Firestore implementation of CommonDB interface",
   "author": "Natural Cycles Team",
   "license": "MIT"

package/src/firestore.db.ts

@@ -19,6 +19,7 @@ import {
   ObjectWithId,
   AnyObjectWithId,
   _assert,
+  _isTruthy,
 } from '@naturalcycles/js-lib'
 import { ReadableTyped, transformMapSimple } from '@naturalcycles/nodejs-lib'
 import { escapeDocId, unescapeDocId } from './firestore.util'
@@ -47,29 +48,28 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: ROW['id'][],
-    opt?: FirestoreDBOptions,
+    _opt?: FirestoreDBOptions,
   ): Promise<ROW[]> {
     // Oj, doesn't look like a very optimal implementation!
     // TODO: check if we can query by keys or smth
-    return (await Promise.all(ids.map(id => this.getById<ROW>(table, id, opt)))).filter(
-      Boolean,
-    ) as ROW[]
-  }
-
-  async getById<ROW extends ObjectWithId>(
-    table: string,
-    id: ROW['id'],
-    _opt?: FirestoreDBOptions,
-  ): Promise<ROW | null> {
-    const doc = await this.cfg.firestore.collection(table).doc(escapeDocId(id)).get()
-
-    const data = doc.data()
-    if (data === undefined) return null
-
-    return {
-      id,
-      ...(data as any),
-    }
+    // return (await Promise.all(ids.map(id => this.getById<ROW>(table, id, opt)))).filter(
+    //   Boolean,
+    // ) as ROW[]
+    if (!ids.length) return []
+
+    const { firestore } = this.cfg
+    const col = firestore.collection(table)
+
+    return (await firestore.getAll(...ids.map(id => col.doc(escapeDocId(id)))))
+      .map(doc => {
+        const data = doc.data()
+        if (data === undefined) return
+        return {
+          id: unescapeDocId(doc.id),
+          ...(data as any),
+        }
+      })
+      .filter(_isTruthy)
   }
 
   // QUERY
@@ -83,7 +83,7 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
 
     // Special case when projection query didn't specify 'id'
     if (q._selectedFieldNames && !q._selectedFieldNames.includes('id')) {
-      rows = rows.map(r => _omit(r as any, ['id']))
+      rows = rows.map(r => _omit(r, ['id']))
     }
 
     return { rows }
@@ -98,10 +98,11 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
 
   override async runQueryCount<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    opt?: FirestoreDBOptions,
+    _opt?: FirestoreDBOptions,
   ): Promise<number> {
-    const { rows } = await this.runQuery(q.select([]), opt)
-    return rows.length
+    const firestoreQuery = dbQueryToFirestoreQuery(q, this.cfg.firestore.collection(q.table))
+    const r = await firestoreQuery.count().get()
+    return r.data().count
   }
 
   override streamQuery<ROW extends ObjectWithId>(
@@ -201,8 +202,27 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
     return rows
   }
 
-  override async commitTransaction(_tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void> {
-    throw new Error('commitTransaction is not supported yet')
+  override async commitTransaction(tx: DBTransaction, _opt?: CommonDBSaveOptions): Promise<void> {
+    const { firestore } = this.cfg
+
+    await firestore.runTransaction(async tr => {
+      for (const op of tx.ops) {
+        if (op.type === 'saveBatch') {
+          op.rows.forEach(row => {
+            tr.set(
+              firestore.collection(op.table).doc(escapeDocId(row.id)),
+              _filterUndefinedValues(row),
+            )
+          })
+        } else if (op.type === 'deleteByIds') {
+          op.ids.forEach(id => {
+            tr.delete(firestore.collection(op.table).doc(escapeDocId(id)))
+          })
+        } else {
+          throw new Error(`DBOperation not supported: ${(op as any).type}`)
+        }
+      }
+    })
   }
 
   override async ping(): Promise<void> {