@naturalcycles/datastore-lib 3.31.0 → 3.32.0

package/dist/datastore.db.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from '@google-cloud/datastore';
 import type { Datastore, Key, Query } from '@google-cloud/datastore';
-import { BaseCommonDB, CommonDB, CommonDBSupport, DBQuery, DBTransaction, RunQueryResult } from '@naturalcycles/db-lib';
+import { BaseCommonDB, CommonDB, CommonDBOptions, CommonDBSaveOptions, CommonDBSupport, DBQuery, DBTransaction, DBTransactionFn, RunQueryResult, CommonDBTransactionOptions } from '@naturalcycles/db-lib';
 import { ObjectWithId, JsonSchemaObject, JsonSchemaRootObject, CommonLogger } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DatastoreDBCfg, DatastoreDBOptions, DatastoreDBSaveOptions, DatastoreDBStreamOptions, DatastorePayload, DatastorePropertyStats, DatastoreStats } from './datastore.model';
@@ -22,7 +22,7 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
     protected KEY: symbol;
     ds(): Datastore;
     ping(): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], _opt?: DatastoreDBOptions): Promise<ROW[]>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: DatastoreDBOptions): Promise<ROW[]>;
     runQuery<ROW extends ObjectWithId>(dbQuery: DBQuery<ROW>, _opt?: DatastoreDBOptions): Promise<RunQueryResult<ROW>>;
     runQueryCount<ROW extends ObjectWithId>(dbQuery: DBQuery<ROW>, _opt?: DatastoreDBOptions): Promise<number>;
     runDatastoreQuery<ROW extends ObjectWithId>(q: Query): Promise<RunQueryResult<ROW>>;
@@ -38,7 +38,7 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
      * regardless if they were actually deleted or not.
      */
     deleteByIds(table: string, ids: string[], opt?: DatastoreDBOptions): Promise<number>;
-    createTransaction(): Promise<DatastoreDBTransaction>;
+    runInTransaction(fn: DBTransactionFn, opt?: CommonDBTransactionOptions): Promise<void>;
     getAllStats(): Promise<DatastoreStats[]>;
     /**
      * Returns undefined e.g when Table is non-existing
@@ -64,8 +64,9 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
 export declare class DatastoreDBTransaction implements DBTransaction {
     db: DatastoreDB;
     tx: Transaction;
-    private constructor();
-    static create(db: DatastoreDB): Promise<DatastoreDBTransaction>;
-    commit(): Promise<void>;
+    constructor(db: DatastoreDB, tx: Transaction);
     rollback(): Promise<void>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<ROW[]>;
+    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW> | undefined): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
 }

package/dist/datastore.db.js

@@ -69,7 +69,7 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
     async ping() {
         await this.getAllStats();
     }
-    async getByIds(table, ids, _opt) {
+    async getByIds(table, ids, opt = {}) {
         if (!ids.length)
             return [];
         const keys = ids.map(id => this.key(table, id));
@@ -77,7 +77,7 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
         if (this.cfg.timeout) {
             // First try
             try {
-                const r = await (0, js_lib_1.pTimeout)(() => this.ds().get(keys), {
+                const r = await (0, js_lib_1.pTimeout)(() => (opt.tx?.tx || this.ds()).get(keys), {
                     timeout: this.cfg.timeout,
                     name: `datastore.getByIds(${table})`,
                 });
@@ -90,7 +90,7 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
                 const DS = datastoreLib.Datastore;
                 this.cachedDatastore = new DS(this.cfg);
                 // Second try (will throw)
-                const r = await (0, js_lib_1.pRetry)(() => this.ds().get(keys), {
+                const r = await (0, js_lib_1.pRetry)(() => (opt.tx?.tx || this.ds()).get(keys), {
                     ...this.getPRetryOptions(`datastore.getByIds(${table}) second try`),
                     maxAttempts: 3,
                     timeout: this.cfg.timeout,
@@ -214,8 +214,21 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
         async (batch) => await (opt.tx?.tx || this.ds()).delete(batch));
         return ids.length;
     }
-    async createTransaction() {
-        return await DatastoreDBTransaction.create(this);
+    async runInTransaction(fn, opt = {}) {
+        const { readOnly } = opt;
+        const datastoreTx = this.ds().transaction({
+            readOnly,
+        });
+        try {
+            await datastoreTx.run();
+            const tx = new DatastoreDBTransaction(this, datastoreTx);
+            await fn(tx);
+            await datastoreTx.commit();
+        }
+        catch (err) {
+            await datastoreTx.rollback();
+            throw err;
+        }
     }
     async getAllStats() {
         const q = this.ds().createQuery('__Stat_Kind__');
@@ -379,16 +392,17 @@ class DatastoreDBTransaction {
         this.db = db;
         this.tx = tx;
     }
-    static async create(db) {
-        const tx = db.ds().transaction();
-        await tx.run();
-        return new DatastoreDBTransaction(db, tx);
-    }
-    async commit() {
-        await this.tx.commit();
-    }
     async rollback() {
         await this.tx.rollback();
     }
+    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.DatastoreDBTransaction = DatastoreDBTransaction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/datastore-lib",
-  "version": "3.31.0",
+  "version": "3.32.0",
   "description": "Opinionated library to work with Google Datastore",
   "scripts": {
     "prepare": "husky install"

package/src/datastore.db.ts

@@ -5,11 +5,15 @@ import {
   BaseCommonDB,
   CommonDB,
   commonDBFullSupport,
+  CommonDBOptions,
   CommonDBSaveMethod,
+  CommonDBSaveOptions,
   CommonDBSupport,
   DBQuery,
   DBTransaction,
+  DBTransactionFn,
   RunQueryResult,
+  CommonDBTransactionOptions,
 } from '@naturalcycles/db-lib'
 import {
   ObjectWithId,
@@ -132,7 +136,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
   override async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    _opt?: DatastoreDBOptions,
+    opt: DatastoreDBOptions = {},
   ): Promise<ROW[]> {
     if (!ids.length) return []
     const keys = ids.map(id => this.key(table, id))
@@ -141,10 +145,13 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     if (this.cfg.timeout) {
       // First try
       try {
-        const r = await pTimeout(() => this.ds().get(keys), {
-          timeout: this.cfg.timeout,
-          name: `datastore.getByIds(${table})`,
-        })
+        const r = await pTimeout(
+          () => ((opt.tx as DatastoreDBTransaction)?.tx || this.ds()).get(keys),
+          {
+            timeout: this.cfg.timeout,
+            name: `datastore.getByIds(${table})`,
+          },
+        )
         rows = r[0]
       } catch {
         this.cfg.logger.log('datastore recreated on error')
@@ -155,15 +162,18 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
         this.cachedDatastore = new DS(this.cfg)
 
         // Second try (will throw)
-        const r = await pRetry(() => this.ds().get(keys), {
-          ...this.getPRetryOptions(`datastore.getByIds(${table}) second try`),
-          maxAttempts: 3,
-          timeout: this.cfg.timeout,
-          errorData: {
-            // This error will be grouped ACROSS all endpoints and usages
-            fingerprint: [DATASTORE_TIMEOUT],
+        const r = await pRetry(
+          () => ((opt.tx as DatastoreDBTransaction)?.tx || this.ds()).get(keys),
+          {
+            ...this.getPRetryOptions(`datastore.getByIds(${table}) second try`),
+            maxAttempts: 3,
+            timeout: this.cfg.timeout,
+            errorData: {
+              // This error will be grouped ACROSS all endpoints and usages
+              fingerprint: [DATASTORE_TIMEOUT],
+            },
           },
-        })
+        )
         rows = r[0]
       }
     } else {
@@ -352,8 +362,24 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     return ids.length
   }
 
-  override async createTransaction(): Promise<DatastoreDBTransaction> {
-    return await DatastoreDBTransaction.create(this)
+  override async runInTransaction(
+    fn: DBTransactionFn,
+    opt: CommonDBTransactionOptions = {},
+  ): Promise<void> {
+    const { readOnly } = opt
+    const datastoreTx = this.ds().transaction({
+      readOnly,
+    })
+
+    try {
+      await datastoreTx.run()
+      const tx = new DatastoreDBTransaction(this, datastoreTx)
+      await fn(tx)
+      await datastoreTx.commit()
+    } catch (err) {
+      await datastoreTx.rollback()
+      throw err
+    }
   }
 
   async getAllStats(): Promise<DatastoreStats[]> {
@@ -532,21 +558,36 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
  * https://cloud.google.com/datastore/docs/concepts/transactions#datastore-datastore-transactional-update-nodejs
  */
 export class DatastoreDBTransaction implements DBTransaction {
-  private constructor(
+  constructor(
     public db: DatastoreDB,
     public tx: Transaction,
   ) {}
 
-  static async create(db: DatastoreDB): Promise<DatastoreDBTransaction> {
-    const tx = db.ds().transaction()
-    await tx.run()
-    return new DatastoreDBTransaction(db, tx)
+  async rollback(): Promise<void> {
+    await this.tx.rollback()
   }
 
-  async commit(): Promise<void> {
-    await this.tx.commit()
+  async getByIds<ROW extends ObjectWithId>(
+    table: string,
+    ids: string[],
+    opt?: CommonDBOptions | undefined,
+  ): Promise<ROW[]> {
+    return await this.db.getByIds(table, ids, { ...opt, tx: this })
   }
-  async rollback(): Promise<void> {
-    await this.tx.rollback()
+
+  async saveBatch<ROW extends Partial<ObjectWithId>>(
+    table: string,
+    rows: ROW[],
+    opt?: CommonDBSaveOptions<ROW> | undefined,
+  ): Promise<void> {
+    await this.db.saveBatch(table, rows, { ...opt, tx: this })
+  }
+
+  async deleteByIds(
+    table: string,
+    ids: string[],
+    opt?: CommonDBOptions | undefined,
+  ): Promise<number> {
+    return await this.db.deleteByIds(table, ids, { ...opt, tx: this })
   }
 }