@naturalcycles/firestore-lib 2.3.0 → 2.5.0

package/dist/firestore.db.d.ts

@@ -19,7 +19,7 @@ export declare class FirestoreDB extends BaseCommonDB implements CommonDB {
     support: CommonDBSupport;
     getByIds<ROW extends ObjectWithId>(table: string, ids: string[], 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[]>;
+    runFirestoreQuery<ROW extends ObjectWithId>(q: Query): Promise<ROW[]>;
     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 ObjectWithId>(table: string, rows: ROW[], opt?: FirestoreDBSaveOptions<ROW>): Promise<void>;

package/dist/firestore.db.js

@@ -57,14 +57,14 @@ export class FirestoreDB extends BaseCommonDB {
             };
         }
         const firestoreQuery = dbQueryToFirestoreQuery(q, this.cfg.firestore.collection(q.table));
-        let rows = await this.runFirestoreQuery(firestoreQuery, opt);
+        let rows = await this.runFirestoreQuery(firestoreQuery);
         // Special case when projection query didn't specify 'id'
         if (q._selectedFieldNames && !q._selectedFieldNames.includes('id')) {
             rows = rows.map(r => _omit(r, ['id']));
         }
         return { rows };
     }
-    async runFirestoreQuery(q, _opt) {
+    async runFirestoreQuery(q) {
         return this.querySnapshotToArray(await q.get());
     }
     async runQueryCount(q, _opt) {
@@ -88,21 +88,22 @@ export class FirestoreDB extends BaseCommonDB {
         const method = methodMap[opt.saveMethod] || 'set';
         if (opt.tx) {
             const { tx } = opt.tx;
-            rows.forEach(row => {
+            for (const row of rows) {
                 _assert(row.id, `firestore-db doesn't support id auto-generation, but empty id was provided in saveBatch`);
-                tx[method](col.doc(escapeDocId(row.id)), _filterUndefinedValues(row));
-            });
+                const { id, ...rowWithoutId } = row;
+                tx[method](col.doc(escapeDocId(id)), _filterUndefinedValues(rowWithoutId));
+            }
             return;
         }
-        // Firestore allows max 500 items in one batch
-        await pMap(_chunk(rows, 500), async (chunk) => {
+        await pMap(_chunk(rows, MAX_ITEMS), async (chunk) => {
             const batch = firestore.batch();
-            chunk.forEach(row => {
+            for (const row of chunk) {
                 _assert(row.id, `firestore-db doesn't support id auto-generation, but empty id was provided in saveBatch`);
-                batch[method](col.doc(escapeDocId(row.id)), _filterUndefinedValues(row));
-            });
+                const { id, ...rowWithoutId } = row;
+                batch[method](col.doc(escapeDocId(id)), _filterUndefinedValues(rowWithoutId));
+            }
             await batch.commit();
-        }, { concurrency: 1 });
+        }, { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY });
     }
     // DELETE
     async deleteByQuery(q, opt) {
@@ -123,29 +124,27 @@ export class FirestoreDB extends BaseCommonDB {
         const col = firestore.collection(table);
         if (opt.tx) {
             const { tx } = opt.tx;
-            ids.forEach(id => {
+            for (const id of ids) {
                 tx.delete(col.doc(escapeDocId(id)));
-            });
+            }
             return ids.length;
         }
-        await pMap(_chunk(ids, 500), async (chunk) => {
+        await pMap(_chunk(ids, MAX_ITEMS), async (chunk) => {
             const batch = firestore.batch();
-            chunk.forEach(id => {
+            for (const id of chunk) {
                 batch.delete(col.doc(escapeDocId(id)));
-            });
+            }
             await batch.commit();
+        }, {
+            concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY,
         });
         return ids.length;
     }
     querySnapshotToArray(qs) {
-        const rows = [];
-        qs.forEach(doc => {
-            rows.push({
-                id: unescapeDocId(doc.id),
-                ...doc.data(),
-            });
-        });
-        return rows;
+        return qs.docs.map(doc => ({
+            id: unescapeDocId(doc.id),
+            ...doc.data(),
+        }));
     }
     async runInTransaction(fn, opt = {}) {
         const { readOnly } = opt;
@@ -174,7 +173,6 @@ export class FirestoreDB extends BaseCommonDB {
         const batch = firestore.batch();
         for (const [id, increment] of _stringMapEntries(incrementMap)) {
             batch.set(col.doc(escapeDocId(id)), {
-                // todo: lazy-load FieldValue
                 [prop]: FieldValue.increment(increment),
             }, { merge: true });
         }
@@ -214,3 +212,7 @@ export class FirestoreDBTransaction {
         return await this.db.deleteByIds(table, ids, { ...opt, tx: this });
     }
 }
+// Datastore (also Firestore and other Google APIs) supports max 500 of items when saving/deleting, etc.
+const MAX_ITEMS = 500;
+// It's an empyrical value, but anything less than infinity is better than infinity
+const FIRESTORE_RECOMMENDED_CONCURRENCY = 8;

package/dist/query.util.js

@@ -5,16 +5,15 @@ const OP_MAP = {
 // in: 'array-contains',
 };
 export function dbQueryToFirestoreQuery(dbQuery, emptyQuery) {
+    let q = emptyQuery;
     // filter
-    // eslint-disable-next-line unicorn/no-array-reduce
-    let q = dbQuery._filters.reduce((q, f) => {
-        return q.where(f.name, OP_MAP[f.op] || f.op, f.val);
-    }, emptyQuery);
+    for (const f of dbQuery._filters) {
+        q = q.where(f.name, OP_MAP[f.op] || f.op, f.val);
+    }
     // order
-    // eslint-disable-next-line unicorn/no-array-reduce
-    q = dbQuery._orders.reduce((q, ord) => {
-        return q.orderBy(ord.name, ord.descending ? 'desc' : 'asc');
-    }, q);
+    for (const ord of dbQuery._orders) {
+        q = q.orderBy(ord.name, ord.descending ? 'desc' : 'asc');
+    }
     // limit
     q = q.limit(dbQuery._limitValue);
     // selectedFields

package/package.json

@@ -12,7 +12,7 @@
     "@types/node": "^24",
     "dotenv": "^17",
     "firebase-admin": "^13",
-    "@naturalcycles/dev-lib": "19.11.0"
+    "@naturalcycles/dev-lib": "18.4.2"
   },
   "exports": {
     ".": "./dist/index.js"
@@ -38,7 +38,7 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Firestore implementation of CommonDB interface",
   "author": "Natural Cycles Team",
   "license": "MIT",

package/src/firestore.db.ts

@@ -85,8 +85,8 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
         if (data === undefined) return
         return {
           id: unescapeDocId(doc.id),
-          ...(data as any),
-        }
+          ...data,
+        } as ROW
       })
       .filter(_isTruthy)
   }
@@ -106,7 +106,7 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
 
     const firestoreQuery = dbQueryToFirestoreQuery(q, this.cfg.firestore.collection(q.table))
 
-    let rows = await this.runFirestoreQuery<ROW>(firestoreQuery, opt)
+    let rows = await this.runFirestoreQuery<ROW>(firestoreQuery)
 
     // Special case when projection query didn't specify 'id'
     if (q._selectedFieldNames && !q._selectedFieldNames.includes('id')) {
@@ -116,10 +116,7 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
     return { rows }
   }
 
-  async runFirestoreQuery<ROW extends ObjectWithId>(
-    q: Query,
-    _opt?: FirestoreDBOptions,
-  ): Promise<ROW[]> {
+  async runFirestoreQuery<ROW extends ObjectWithId>(q: Query): Promise<ROW[]> {
     return this.querySnapshotToArray(await q.get())
   }
 
@@ -159,37 +156,41 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
     if (opt.tx) {
       const { tx } = opt.tx as FirestoreDBTransaction
 
-      rows.forEach(row => {
+      for (const row of rows) {
         _assert(
           row.id,
           `firestore-db doesn't support id auto-generation, but empty id was provided in saveBatch`,
         )
 
-        tx[method as 'set' | 'create'](col.doc(escapeDocId(row.id)), _filterUndefinedValues(row))
-      })
+        const { id, ...rowWithoutId } = row
+        tx[method as 'set' | 'create'](
+          col.doc(escapeDocId(id)),
+          _filterUndefinedValues(rowWithoutId),
+        )
+      }
       return
     }
 
-    // Firestore allows max 500 items in one batch
     await pMap(
-      _chunk(rows, 500),
+      _chunk(rows, MAX_ITEMS),
       async chunk => {
         const batch = firestore.batch()
 
-        chunk.forEach(row => {
+        for (const row of chunk) {
           _assert(
             row.id,
             `firestore-db doesn't support id auto-generation, but empty id was provided in saveBatch`,
           )
+          const { id, ...rowWithoutId } = row
           batch[method as 'set' | 'create'](
-            col.doc(escapeDocId(row.id)),
-            _filterUndefinedValues(row),
+            col.doc(escapeDocId(id)),
+            _filterUndefinedValues(rowWithoutId),
           )
-        })
+        }
 
         await batch.commit()
       },
-      { concurrency: 1 },
+      { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY },
     )
   }
 
@@ -208,7 +209,7 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
         q.select([]),
         this.cfg.firestore.collection(q.table),
       )
-      ids = (await this.runFirestoreQuery<ROW>(firestoreQuery)).map(obj => obj.id)
+      ids = (await this.runFirestoreQuery<ObjectWithId>(firestoreQuery)).map(obj => obj.id)
     }
 
     await this.deleteByIds(q.table, ids, opt)
@@ -227,36 +228,39 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
     if (opt.tx) {
       const { tx } = opt.tx as FirestoreDBTransaction
 
-      ids.forEach(id => {
+      for (const id of ids) {
         tx.delete(col.doc(escapeDocId(id)))
-      })
+      }
       return ids.length
     }
 
-    await pMap(_chunk(ids, 500), async chunk => {
-      const batch = firestore.batch()
+    await pMap(
+      _chunk(ids, MAX_ITEMS),
+      async chunk => {
+        const batch = firestore.batch()
 
-      chunk.forEach(id => {
-        batch.delete(col.doc(escapeDocId(id)))
-      })
+        for (const id of chunk) {
+          batch.delete(col.doc(escapeDocId(id)))
+        }
 
-      await batch.commit()
-    })
+        await batch.commit()
+      },
+      {
+        concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY,
+      },
+    )
 
     return ids.length
   }
 
   private querySnapshotToArray<T = any>(qs: QuerySnapshot): T[] {
-    const rows: any[] = []
-
-    qs.forEach(doc => {
-      rows.push({
-        id: unescapeDocId(doc.id),
-        ...doc.data(),
-      })
-    })
-
-    return rows
+    return qs.docs.map(
+      doc =>
+        ({
+          id: unescapeDocId(doc.id),
+          ...doc.data(),
+        }) as T,
+    )
   }
 
   override async runInTransaction(
@@ -301,7 +305,6 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
       batch.set(
         col.doc(escapeDocId(id)),
         {
-          // todo: lazy-load FieldValue
           [prop]: FieldValue.increment(increment),
         },
         { merge: true },
@@ -358,3 +361,8 @@ export class FirestoreDBTransaction implements DBTransaction {
     return await this.db.deleteByIds(table, ids, { ...opt, tx: this })
   }
 }
+
+// Datastore (also Firestore and other Google APIs) supports max 500 of items when saving/deleting, etc.
+const MAX_ITEMS = 500
+// It's an empyrical value, but anything less than infinity is better than infinity
+const FIRESTORE_RECOMMENDED_CONCURRENCY = 8

package/src/query.util.ts

@@ -13,17 +13,17 @@ export function dbQueryToFirestoreQuery<ROW extends ObjectWithId>(
   dbQuery: DBQuery<ROW>,
   emptyQuery: Query,
 ): Query {
+  let q = emptyQuery
+
   // filter
-  // eslint-disable-next-line unicorn/no-array-reduce
-  let q = dbQuery._filters.reduce((q, f) => {
-    return q.where(f.name as string, OP_MAP[f.op] || (f.op as WhereFilterOp), f.val)
-  }, emptyQuery)
+  for (const f of dbQuery._filters) {
+    q = q.where(f.name as string, OP_MAP[f.op] || (f.op as WhereFilterOp), f.val)
+  }
 
   // order
-  // eslint-disable-next-line unicorn/no-array-reduce
-  q = dbQuery._orders.reduce((q, ord) => {
-    return q.orderBy(ord.name as string, ord.descending ? 'desc' : 'asc')
-  }, q)
+  for (const ord of dbQuery._orders) {
+    q = q.orderBy(ord.name as string, ord.descending ? 'desc' : 'asc')
+  }
 
   // limit
   q = q.limit(dbQuery._limitValue)