@naturalcycles/firestore-lib 2.4.0 → 2.6.0

package/dist/firestore.db.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore, Query, Transaction } from '@google-cloud/firestore';
-import type { CommonDB, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBSupport, CommonDBTransactionOptions, DBQuery, DBTransaction, DBTransactionFn, RunQueryResult } from '@naturalcycles/db-lib';
+import type { CommonDB, CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBSupport, CommonDBTransactionOptions, DBQuery, DBTransaction, DBTransactionFn, RunQueryResult } from '@naturalcycles/db-lib';
 import { BaseCommonDB } from '@naturalcycles/db-lib';
 import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types';
 import type { ReadableTyped } from '@naturalcycles/nodejs-lib/stream';
@@ -8,6 +8,8 @@ export interface FirestoreDBCfg {
 }
 export interface FirestoreDBOptions extends CommonDBOptions {
 }
+export interface FirestoreDBReadOptions extends CommonDBReadOptions {
+}
 export interface FirestoreDBSaveOptions<ROW extends ObjectWithId> extends CommonDBSaveOptions<ROW> {
 }
 export declare class RollbackError extends Error {
@@ -17,14 +19,18 @@ export declare class FirestoreDB extends BaseCommonDB implements CommonDB {
     cfg: FirestoreDBCfg;
     constructor(cfg: FirestoreDBCfg);
     support: CommonDBSupport;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: FirestoreDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: FirestoreDBReadOptions): Promise<ROW[]>;
+    multiGetByIds<ROW extends ObjectWithId>(map: StringMap<string[]>, opt?: CommonDBReadOptions): Promise<StringMap<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>;
+    multiSaveBatch<ROW extends ObjectWithId>(map: StringMap<ROW[]>, opt?: FirestoreDBSaveOptions<ROW>): Promise<void>;
+    patchById<ROW extends ObjectWithId>(table: string, id: string, patch: Partial<ROW>, opt?: FirestoreDBOptions): Promise<void>;
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: FirestoreDBOptions): Promise<number>;
     deleteByIds(table: string, ids: string[], opt?: FirestoreDBOptions): Promise<number>;
+    multiDeleteByIds(map: StringMap<string[]>, opt?: FirestoreDBOptions): Promise<number>;
     private querySnapshotToArray;
     runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
     /**

package/dist/firestore.db.js

@@ -47,6 +47,29 @@ export class FirestoreDB extends BaseCommonDB {
         })
             .filter(_isTruthy);
     }
+    async multiGetByIds(map, opt = {}) {
+        const result = {};
+        const { firestore } = this.cfg;
+        const refs = [];
+        for (const [table, ids] of _stringMapEntries(map)) {
+            result[table] = [];
+            const col = firestore.collection(table);
+            refs.push(...ids.map(id => col.doc(escapeDocId(id))));
+        }
+        const snapshots = await (opt.tx?.tx || firestore).getAll(...refs);
+        snapshots.forEach(snap => {
+            const data = snap.data();
+            if (data === undefined)
+                return;
+            const table = snap.ref.parent.id;
+            const row = {
+                id: unescapeDocId(snap.id),
+                ...data,
+            };
+            result[table].push(row);
+        });
+        return result;
+    }
     // QUERY
     async runQuery(q, opt) {
         const idFilter = q._filters.find(f => f.name === 'id');
@@ -57,14 +80,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) {
@@ -90,19 +113,65 @@ export class FirestoreDB extends BaseCommonDB {
             const { tx } = opt.tx;
             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) => {
+            // .batch is called "Atomic batch writer"
+            // Executes multiple writes in a single atomic transaction-like commit — all succeed or all fail.
+            // If any write in the batch fails (e.g., permission error, missing doc), the whole batch fails.
+            // Good for small, related sets of writes where consistency is critical.
             const batch = firestore.batch();
             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: FIRESTORE_RECOMMENDED_CONCURRENCY });
+    }
+    async multiSaveBatch(map, opt = {}) {
+        const { firestore } = this.cfg;
+        const method = methodMap[opt.saveMethod] || 'set';
+        if (opt.tx) {
+            const { tx } = opt.tx;
+            for (const [table, rows] of _stringMapEntries(map)) {
+                const col = firestore.collection(table);
+                for (const row of rows) {
+                    _assert(row.id, `firestore-db doesn't support id auto-generation, but empty id was provided in multiSaveBatch`);
+                    const { id, ...rowWithoutId } = row;
+                    tx[method](col.doc(escapeDocId(id)), _filterUndefinedValues(rowWithoutId));
+                }
+            }
+            return;
+        }
+        const tableRows = [];
+        for (const [table, rows] of _stringMapEntries(map)) {
+            for (const row of rows) {
+                tableRows.push([table, row]);
+            }
+        }
+        await pMap(_chunk(tableRows, MAX_ITEMS), async (chunk) => {
+            const batch = firestore.batch();
+            for (const [table, row] of chunk) {
+                _assert(row.id, `firestore-db doesn't support id auto-generation, but empty id was provided in multiSaveBatch`);
+                const { id, ...rowWithoutId } = row;
+                batch[method](firestore.collection(table).doc(escapeDocId(id)), _filterUndefinedValues(rowWithoutId));
             }
             await batch.commit();
-        }, { concurrency: 1 });
+        }, { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY });
+    }
+    async patchById(table, id, patch, opt = {}) {
+        const { firestore } = this.cfg;
+        const col = firestore.collection(table);
+        if (opt.tx) {
+            const { tx } = opt.tx;
+            tx.update(col.doc(escapeDocId(id)), patch);
+            return;
+        }
+        await col.doc(escapeDocId(id)).update(patch);
     }
     // DELETE
     async deleteByQuery(q, opt) {
@@ -128,24 +197,44 @@ export class FirestoreDB extends BaseCommonDB {
             }
             return ids.length;
         }
-        await pMap(_chunk(ids, 500), async (chunk) => {
+        await pMap(_chunk(ids, MAX_ITEMS), async (chunk) => {
             const batch = firestore.batch();
             for (const id of chunk) {
                 batch.delete(col.doc(escapeDocId(id)));
             }
             await batch.commit();
-        });
+        }, { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY });
         return ids.length;
     }
+    async multiDeleteByIds(map, opt = {}) {
+        const { firestore } = this.cfg;
+        const refs = [];
+        for (const [table, ids] of _stringMapEntries(map)) {
+            const col = firestore.collection(table);
+            refs.push(...ids.map(id => col.doc(escapeDocId(id))));
+        }
+        if (opt.tx) {
+            const { tx } = opt.tx;
+            for (const ref of refs) {
+                tx.delete(ref);
+            }
+        }
+        else {
+            await pMap(_chunk(refs, MAX_ITEMS), async (chunk) => {
+                const batch = firestore.batch();
+                for (const ref of chunk) {
+                    batch.delete(ref);
+                }
+                await batch.commit();
+            }, { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY });
+        }
+        return refs.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 +263,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 +302,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

@@ -38,7 +38,7 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "Firestore implementation of CommonDB interface",
   "author": "Natural Cycles Team",
   "license": "MIT",

package/src/firestore.db.ts

@@ -1,14 +1,17 @@
 import type {
+  DocumentReference,
   Firestore,
   Query,
   QueryDocumentSnapshot,
   QuerySnapshot,
   Transaction,
+  UpdateData,
 } from '@google-cloud/firestore'
 import { FieldValue } from '@google-cloud/firestore'
 import type {
   CommonDB,
   CommonDBOptions,
+  CommonDBReadOptions,
   CommonDBSaveMethod,
   CommonDBSaveOptions,
   CommonDBStreamOptions,
@@ -36,6 +39,7 @@ export interface FirestoreDBCfg {
 }
 
 export interface FirestoreDBOptions extends CommonDBOptions {}
+export interface FirestoreDBReadOptions extends CommonDBReadOptions {}
 export interface FirestoreDBSaveOptions<ROW extends ObjectWithId>
   extends CommonDBSaveOptions<ROW> {}
 
@@ -68,7 +72,7 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    opt: FirestoreDBOptions = {},
+    opt: FirestoreDBReadOptions = {},
   ): Promise<ROW[]> {
     if (!ids.length) return []
 
@@ -85,12 +89,40 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
         if (data === undefined) return
         return {
           id: unescapeDocId(doc.id),
-          ...(data as any),
-        }
+          ...data,
+        } as ROW
       })
       .filter(_isTruthy)
   }
 
+  override async multiGetByIds<ROW extends ObjectWithId>(
+    map: StringMap<string[]>,
+    opt: CommonDBReadOptions = {},
+  ): Promise<StringMap<ROW[]>> {
+    const result: StringMap<ROW[]> = {}
+    const { firestore } = this.cfg
+    const refs: DocumentReference[] = []
+    for (const [table, ids] of _stringMapEntries(map)) {
+      result[table] = []
+      const col = firestore.collection(table)
+      refs.push(...ids.map(id => col.doc(escapeDocId(id))))
+    }
+
+    const snapshots = await ((opt.tx as FirestoreDBTransaction)?.tx || firestore).getAll(...refs)
+    snapshots.forEach(snap => {
+      const data = snap.data()
+      if (data === undefined) return
+      const table = snap.ref.parent.id
+      const row = {
+        id: unescapeDocId(snap.id),
+        ...data,
+      } as ROW
+      result[table]!.push(row)
+    })
+
+    return result
+  }
+
   // QUERY
   override async runQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
@@ -106,7 +138,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 +148,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())
   }
 
@@ -165,15 +194,22 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
           `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 => {
+        // .batch is called "Atomic batch writer"
+        // Executes multiple writes in a single atomic transaction-like commit — all succeed or all fail.
+        // If any write in the batch fails (e.g., permission error, missing doc), the whole batch fails.
+        // Good for small, related sets of writes where consistency is critical.
         const batch = firestore.batch()
 
         for (const row of chunk) {
@@ -181,18 +217,95 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
             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(id)),
+            _filterUndefinedValues(rowWithoutId),
+          )
+        }
+
+        await batch.commit()
+      },
+      { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY },
+    )
+  }
+
+  override async multiSaveBatch<ROW extends ObjectWithId>(
+    map: StringMap<ROW[]>,
+    opt: FirestoreDBSaveOptions<ROW> = {},
+  ): Promise<void> {
+    const { firestore } = this.cfg
+    const method: SaveOp = methodMap[opt.saveMethod!] || 'set'
+
+    if (opt.tx) {
+      const { tx } = opt.tx as FirestoreDBTransaction
+
+      for (const [table, rows] of _stringMapEntries(map)) {
+        const col = firestore.collection(table)
+        for (const row of rows) {
+          _assert(
+            row.id,
+            `firestore-db doesn't support id auto-generation, but empty id was provided in multiSaveBatch`,
+          )
+
+          const { id, ...rowWithoutId } = row
+          tx[method as 'set' | 'create'](
+            col.doc(escapeDocId(id)),
+            _filterUndefinedValues(rowWithoutId),
+          )
+        }
+      }
+      return
+    }
+
+    const tableRows: TableRow<ROW>[] = []
+    for (const [table, rows] of _stringMapEntries(map)) {
+      for (const row of rows) {
+        tableRows.push([table, row])
+      }
+    }
+
+    await pMap(
+      _chunk(tableRows, MAX_ITEMS),
+      async chunk => {
+        const batch = firestore.batch()
+
+        for (const [table, row] of chunk) {
+          _assert(
+            row.id,
+            `firestore-db doesn't support id auto-generation, but empty id was provided in multiSaveBatch`,
+          )
+          const { id, ...rowWithoutId } = row
           batch[method as 'set' | 'create'](
-            col.doc(escapeDocId(row.id)),
-            _filterUndefinedValues(row),
+            firestore.collection(table).doc(escapeDocId(id)),
+            _filterUndefinedValues(rowWithoutId),
           )
         }
 
         await batch.commit()
       },
-      { concurrency: 1 },
+      { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY },
     )
   }
 
+  override async patchById<ROW extends ObjectWithId>(
+    table: string,
+    id: string,
+    patch: Partial<ROW>,
+    opt: FirestoreDBOptions = {},
+  ): Promise<void> {
+    const { firestore } = this.cfg
+    const col = firestore.collection(table)
+
+    if (opt.tx) {
+      const { tx } = opt.tx as FirestoreDBTransaction
+      tx.update(col.doc(escapeDocId(id)), patch as UpdateData<ROW>)
+      return
+    }
+
+    await col.doc(escapeDocId(id)).update(patch)
+  }
+
   // DELETE
   override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
@@ -208,7 +321,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)
@@ -233,30 +346,62 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
       return ids.length
     }
 
-    await pMap(_chunk(ids, 500), async chunk => {
-      const batch = firestore.batch()
-
-      for (const id of chunk) {
-        batch.delete(col.doc(escapeDocId(id)))
-      }
-
-      await batch.commit()
-    })
+    await pMap(
+      _chunk(ids, MAX_ITEMS),
+      async chunk => {
+        const batch = firestore.batch()
+        for (const id of chunk) {
+          batch.delete(col.doc(escapeDocId(id)))
+        }
+        await batch.commit()
+      },
+      { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY },
+    )
 
     return ids.length
   }
 
-  private querySnapshotToArray<T = any>(qs: QuerySnapshot): T[] {
-    const rows: any[] = []
+  override async multiDeleteByIds(
+    map: StringMap<string[]>,
+    opt: FirestoreDBOptions = {},
+  ): Promise<number> {
+    const { firestore } = this.cfg
+    const refs: DocumentReference[] = []
+    for (const [table, ids] of _stringMapEntries(map)) {
+      const col = firestore.collection(table)
+      refs.push(...ids.map(id => col.doc(escapeDocId(id))))
+    }
 
-    qs.forEach(doc => {
-      rows.push({
-        id: unescapeDocId(doc.id),
-        ...doc.data(),
-      })
-    })
+    if (opt.tx) {
+      const { tx } = opt.tx as FirestoreDBTransaction
+      for (const ref of refs) {
+        tx.delete(ref)
+      }
+    } else {
+      await pMap(
+        _chunk(refs, MAX_ITEMS),
+        async chunk => {
+          const batch = firestore.batch()
+          for (const ref of chunk) {
+            batch.delete(ref)
+          }
+          await batch.commit()
+        },
+        { concurrency: FIRESTORE_RECOMMENDED_CONCURRENCY },
+      )
+    }
+
+    return refs.length
+  }
 
-    return rows
+  private querySnapshotToArray<T = any>(qs: QuerySnapshot): T[] {
+    return qs.docs.map(
+      doc =>
+        ({
+          id: unescapeDocId(doc.id),
+          ...doc.data(),
+        }) as T,
+    )
   }
 
   override async runInTransaction(
@@ -301,7 +446,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 +502,10 @@ 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
+
+type TableRow<ROW extends ObjectWithId> = [table: string, row: ROW]

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)