@naturalcycles/firestore-lib 1.6.0 → 1.6.1

package/dist/firestore.db.d.ts

@@ -1,5 +1,5 @@
 import { Firestore, Query, Transaction } from '@google-cloud/firestore';
-import { BaseCommonDB, CommonDB, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBSupport, DBQuery, DBTransaction, RunQueryResult } from '@naturalcycles/db-lib';
+import { BaseCommonDB, CommonDB, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBSupport, DBQuery, DBTransaction, DBTransactionFn, RunQueryResult } from '@naturalcycles/db-lib';
 import { ObjectWithId, AnyObjectWithId } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 export interface FirestoreDBCfg {
@@ -9,11 +9,14 @@ export interface FirestoreDBOptions extends CommonDBOptions {
 }
 export interface FirestoreDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyObjectWithId> extends CommonDBSaveOptions<ROW> {
 }
+export declare class RollbackError extends Error {
+    constructor();
+}
 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?: 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>;
@@ -22,7 +25,7 @@ export declare class FirestoreDB extends BaseCommonDB implements CommonDB {
     deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>, opt?: FirestoreDBOptions): Promise<number>;
     deleteByIds(table: string, ids: string[], opt?: FirestoreDBOptions): Promise<number>;
     private querySnapshotToArray;
-    createTransaction(): Promise<FirestoreDBTransaction>;
+    runInTransaction(fn: DBTransactionFn): Promise<void>;
     ping(): Promise<void>;
     getTables(): Promise<string[]>;
 }
@@ -32,18 +35,9 @@ export declare class FirestoreDB extends BaseCommonDB implements CommonDB {
 export declare class FirestoreDBTransaction implements DBTransaction {
     db: FirestoreDB;
     tx: Transaction;
-    private txPendingDefer;
-    private txCompletedDefer;
-    /**
-     * This defer is held during Transaction and
-     * is released when it's ready to be committed or rolled back.
-     */
-    /**
-     * This is resolved after Transaction is committed or rolled back.
-     * On error - it rejects with that error.
-     */
-    private constructor();
-    static create(db: FirestoreDB): Promise<FirestoreDBTransaction>;
-    commit(): Promise<void>;
+    constructor(db: FirestoreDB, tx: Transaction);
     rollback(): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
 }

package/dist/firestore.db.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirestoreDBTransaction = exports.FirestoreDB = void 0;
+exports.FirestoreDBTransaction = exports.FirestoreDB = exports.RollbackError = void 0;
 const db_lib_1 = require("@naturalcycles/db-lib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
@@ -11,6 +11,12 @@ const methodMap = {
     update: 'update',
     upsert: 'set',
 };
+class RollbackError extends Error {
+    constructor() {
+        super('rollback');
+    }
+}
+exports.RollbackError = RollbackError;
 class FirestoreDB extends db_lib_1.BaseCommonDB {
     constructor(cfg) {
         super();
@@ -22,17 +28,12 @@ class FirestoreDB extends db_lib_1.BaseCommonDB {
         };
     }
     // GET
-    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<ROW>(table, id, opt)))).filter(
-        //   Boolean,
-        // ) as ROW[]
+    async getByIds(table, ids, opt = {}) {
         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)))))
+        return (await (opt.tx?.tx || firestore).getAll(...ids.map(id => col.doc((0, firestore_util_1.escapeDocId)(id)))))
             .map(doc => {
             const data = doc.data();
             if (data === undefined)
@@ -148,30 +149,20 @@ class FirestoreDB extends db_lib_1.BaseCommonDB {
         });
         return rows;
     }
-    // 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}`)
-    //       }
-    //     }
-    //   })
-    // }
-    async createTransaction() {
-        return await FirestoreDBTransaction.create(this);
+    async runInTransaction(fn) {
+        try {
+            await this.cfg.firestore.runTransaction(async (firestoreTx) => {
+                const tx = new FirestoreDBTransaction(this, firestoreTx);
+                await fn(tx);
+            });
+        }
+        catch (err) {
+            if (err instanceof RollbackError) {
+                // RollbackError should be handled gracefully (not re-throw)
+                return;
+            }
+            throw err;
+        }
     }
     async ping() {
         // no-op now
@@ -185,49 +176,21 @@ exports.FirestoreDB = FirestoreDB;
  * https://firebase.google.com/docs/firestore/manage-data/transactions
  */
 class FirestoreDBTransaction {
-    /**
-     * This defer is held during Transaction and
-     * is released when it's ready to be committed or rolled back.
-     */
-    // private txPendingDefer = pDefer()
-    /**
-     * This is resolved after Transaction is committed or rolled back.
-     * On error - it rejects with that error.
-     */
-    // private txCompletedDefer = pDefer()
-    constructor(db, tx, txPendingDefer, txCompletedDefer) {
+    constructor(db, tx) {
         this.db = db;
         this.tx = tx;
-        this.txPendingDefer = txPendingDefer;
-        this.txCompletedDefer = txCompletedDefer;
-    }
-    static async create(db) {
-        const txCreated = (0, js_lib_1.pDefer)();
-        const txPendingDefer = (0, js_lib_1.pDefer)();
-        const txCompletedDefer = (0, js_lib_1.pDefer)();
-        db.cfg.firestore
-            .runTransaction(async (tx) => {
-            txCreated.resolve(tx);
-            // Now we pause and let consumers to use the Transaction,
-            // until commit/rollback is called
-            await txPendingDefer;
-        })
-            .then(() => {
-            txCompletedDefer.resolve();
-        })
-            .catch(err => {
-            txCompletedDefer.reject(err);
-        });
-        const tx = await txCreated;
-        return new FirestoreDBTransaction(db, tx, txPendingDefer, txCompletedDefer);
-    }
-    async commit() {
-        this.txPendingDefer.resolve();
-        await this.txCompletedDefer;
     }
     async rollback() {
-        this.txPendingDefer.reject(new Error('rollback'));
-        await this.txCompletedDefer;
+        throw new RollbackError();
+    }
+    async getByIds(table, ids, opt) {
+        return await this.db.getByIds(table, ids, { ...opt, tx: this });
+    }
+    async saveBatch(table, rows, opt) {
+        await this.db.saveBatch(table, rows, { ...opt, tx: this });
+    }
+    async deleteByIds(table, ids, opt) {
+        return await this.db.deleteByIds(table, ids, { ...opt, tx: this });
     }
 }
 exports.FirestoreDBTransaction = FirestoreDBTransaction;

package/package.json

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

package/src/firestore.db.ts

@@ -16,6 +16,7 @@ import {
   CommonDBSupport,
   DBQuery,
   DBTransaction,
+  DBTransactionFn,
   RunQueryResult,
 } from '@naturalcycles/db-lib'
 import {
@@ -28,8 +29,6 @@ import {
   AnyObjectWithId,
   _assert,
   _isTruthy,
-  pDefer,
-  DeferredPromise,
 } from '@naturalcycles/js-lib'
 import { ReadableTyped, transformMapSimple } from '@naturalcycles/nodejs-lib'
 import { escapeDocId, unescapeDocId } from './firestore.util'
@@ -51,6 +50,12 @@ const methodMap: Record<CommonDBSaveMethod, SaveOp> = {
   upsert: 'set',
 }
 
+export class RollbackError extends Error {
+  constructor() {
+    super('rollback')
+  }
+}
+
 export class FirestoreDB extends BaseCommonDB implements CommonDB {
   constructor(public cfg: FirestoreDBCfg) {
     super()
@@ -66,19 +71,18 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    _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[]
     if (!ids.length) return []
 
     const { firestore } = this.cfg
     const col = firestore.collection(table)
 
-    return (await firestore.getAll(...ids.map(id => col.doc(escapeDocId(id)))))
+    return (
+      await ((opt.tx as FirestoreDBTransaction)?.tx || firestore).getAll(
+        ...ids.map(id => col.doc(escapeDocId(id))),
+      )
+    )
       .map(doc => {
         const data = doc.data()
         if (data === undefined) return
@@ -268,31 +272,19 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
     return rows
   }
 
-  // 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 createTransaction(): Promise<FirestoreDBTransaction> {
-    return await FirestoreDBTransaction.create(this)
+  override async runInTransaction(fn: DBTransactionFn): Promise<void> {
+    try {
+      await this.cfg.firestore.runTransaction(async firestoreTx => {
+        const tx = new FirestoreDBTransaction(this, firestoreTx)
+        await fn(tx)
+      })
+    } catch (err) {
+      if (err instanceof RollbackError) {
+        // RollbackError should be handled gracefully (not re-throw)
+        return
+      }
+      throw err
+    }
   }
 
   override async ping(): Promise<void> {
@@ -308,55 +300,32 @@ export class FirestoreDB extends BaseCommonDB implements CommonDB {
  * https://firebase.google.com/docs/firestore/manage-data/transactions
  */
 export class FirestoreDBTransaction implements DBTransaction {
-  /**
-   * This defer is held during Transaction and
-   * is released when it's ready to be committed or rolled back.
-   */
-  // private txPendingDefer = pDefer()
-
-  /**
-   * This is resolved after Transaction is committed or rolled back.
-   * On error - it rejects with that error.
-   */
-  // private txCompletedDefer = pDefer()
-
-  private constructor(
+  constructor(
     public db: FirestoreDB,
     public tx: Transaction,
-    private txPendingDefer: DeferredPromise,
-    private txCompletedDefer: DeferredPromise,
   ) {}
 
-  static async create(db: FirestoreDB): Promise<FirestoreDBTransaction> {
-    const txCreated = pDefer<Transaction>()
-    const txPendingDefer = pDefer()
-    const txCompletedDefer = pDefer()
-
-    db.cfg.firestore
-      .runTransaction(async tx => {
-        txCreated.resolve(tx)
-
-        // Now we pause and let consumers to use the Transaction,
-        // until commit/rollback is called
-        await txPendingDefer
-      })
-      .then(() => {
-        txCompletedDefer.resolve()
-      })
-      .catch(err => {
-        txCompletedDefer.reject(err)
-      })
+  async rollback(): Promise<void> {
+    throw new RollbackError()
+  }
 
-    const tx = await txCreated
-    return new FirestoreDBTransaction(db, tx, txPendingDefer, txCompletedDefer)
+  async getByIds<ROW extends ObjectWithId>(
+    table: string,
+    ids: string[],
+    opt?: CommonDBOptions,
+  ): Promise<ROW[]> {
+    return await this.db.getByIds(table, ids, { ...opt, tx: this })
   }
 
-  async commit(): Promise<void> {
-    this.txPendingDefer.resolve()
-    await this.txCompletedDefer
+  async saveBatch<ROW extends Partial<ObjectWithId>>(
+    table: string,
+    rows: ROW[],
+    opt?: CommonDBSaveOptions<ROW>,
+  ): Promise<void> {
+    await this.db.saveBatch(table, rows, { ...opt, tx: this })
   }
-  async rollback(): Promise<void> {
-    this.txPendingDefer.reject(new Error('rollback'))
-    await this.txCompletedDefer
+
+  async deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number> {
+    return await this.db.deleteByIds(table, ids, { ...opt, tx: this })
   }
 }