@naturalcycles/datastore-lib 3.38.1 → 3.38.3

package/dist/datastore.db.d.ts

@@ -57,6 +57,11 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
     getTables(): Promise<string[]>;
     getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
     private getPRetryOptions;
+    /**
+     * Silently rollback the transaction.
+     * It may happen that transaction is already committed/rolled back, so we don't want to throw an error here.
+     */
+    private rollback;
 }
 /**
  * https://cloud.google.com/datastore/docs/concepts/transactions#datastore-datastore-transactional-update-nodejs

package/dist/datastore.db.js

@@ -206,9 +206,7 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
      */
     async deleteByIds(table, ids, opt = {}) {
         const keys = ids.map(id => this.key(table, id));
-        await (0, js_lib_1.pMap)((0, js_lib_1._chunk)(keys, MAX_ITEMS), 
-        // eslint-disable-next-line @typescript-eslint/return-await
-        async (batch) => await (opt.tx?.tx || this.ds()).delete(batch), {
+        await (0, js_lib_1.pMap)((0, js_lib_1._chunk)(keys, MAX_ITEMS), async (batch) => await (opt.tx?.tx || this.ds()).delete(batch), {
             concurrency: DATASTORE_RECOMMENDED_CONCURRENCY,
         });
         return ids.length;
@@ -225,7 +223,7 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
             await datastoreTx.commit();
         }
         catch (err) {
-            await datastoreTx.rollback();
+            await this.rollback(datastoreTx);
             throw err;
         }
     }
@@ -381,6 +379,19 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
             },
         };
     }
+    /**
+     * Silently rollback the transaction.
+     * It may happen that transaction is already committed/rolled back, so we don't want to throw an error here.
+     */
+    async rollback(datastoreTx) {
+        try {
+            await datastoreTx.rollback();
+        }
+        catch (err) {
+            // log the error, but don't re-throw, as this should be a graceful rollback
+            this.cfg.logger.error(err);
+        }
+    }
 }
 exports.DatastoreDB = DatastoreDB;
 /**

package/dist/datastoreKeyValueDB.d.ts

@@ -1,6 +1,5 @@
-import { CommonKeyValueDB } from '@naturalcycles/db-lib';
+import { CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-lib';
 import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB';
-import { KeyValueTuple } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DatastoreDB } from './datastore.db';
 import { DatastoreDBCfg } from './datastore.model';
@@ -16,12 +15,12 @@ export declare class DatastoreKeyValueDB implements CommonKeyValueDB {
     };
     ping(): Promise<void>;
     createTable(): Promise<void>;
-    getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]>;
+    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
     deleteByIds(table: string, ids: string[]): Promise<void>;
-    saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void>;
+    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues<V>(table: string, limit?: number): ReadableTyped<V>;
-    streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>>;
+    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
+    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
     incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/package.json

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

package/src/datastore.db.ts

@@ -350,7 +350,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
 
     await pMap(
       _chunk(keys, MAX_ITEMS),
-      // eslint-disable-next-line @typescript-eslint/return-await
+
       async batch => await ((opt.tx as DatastoreDBTransaction)?.tx || this.ds()).delete(batch),
       {
         concurrency: DATASTORE_RECOMMENDED_CONCURRENCY,
@@ -374,7 +374,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
       await fn(tx)
       await datastoreTx.commit()
     } catch (err) {
-      await datastoreTx.rollback()
+      await this.rollback(datastoreTx)
       throw err
     }
   }
@@ -549,6 +549,19 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
       },
     }
   }
+
+  /**
+   * Silently rollback the transaction.
+   * It may happen that transaction is already committed/rolled back, so we don't want to throw an error here.
+   */
+  private async rollback(datastoreTx: Transaction): Promise<void> {
+    try {
+      await datastoreTx.rollback()
+    } catch (err) {
+      // log the error, but don't re-throw, as this should be a graceful rollback
+      this.cfg.logger.error(err)
+    }
+  }
 }
 
 /**

package/src/datastoreKeyValueDB.ts

@@ -1,16 +1,21 @@
-import { CommonKeyValueDB, commonKeyValueDBFullSupport, DBQuery } from '@naturalcycles/db-lib'
+import {
+  CommonKeyValueDB,
+  commonKeyValueDBFullSupport,
+  DBQuery,
+  KeyValueDBTuple,
+} from '@naturalcycles/db-lib'
 import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB'
-import { AppError, KeyValueTuple, ObjectWithId } from '@naturalcycles/js-lib'
+import { AppError, ObjectWithId } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { DatastoreDB } from './datastore.db'
 import { DatastoreDBCfg } from './datastore.model'
 
-interface KVObject<V> {
+interface KVObject {
   id: string
-  v: V
+  v: Buffer
 }
 
-const excludeFromIndexes: (keyof KVObject<any>)[] = ['v']
+const excludeFromIndexes: (keyof KVObject)[] = ['v']
 
 export interface DatastoreKeyValueDBCfg extends DatastoreDBCfg {}
 
@@ -32,16 +37,16 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
 
   async createTable(): Promise<void> {}
 
-  async getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]> {
-    return (await this.db.getByIds<KVObject<V>>(table, ids)).map(r => [r.id, r.v])
+  async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
+    return (await this.db.getByIds<KVObject>(table, ids)).map(r => [r.id, r.v])
   }
 
   async deleteByIds(table: string, ids: string[]): Promise<void> {
     await this.db.deleteByIds(table, ids)
   }
 
-  async saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void> {
-    await this.db.saveBatch<KVObject<V>>(
+  async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
+    await this.db.saveBatch<KVObject>(
       table,
       entries.map(([id, v]) => ({ id, v })),
       {
@@ -63,9 +68,9 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
     )
   }
 
-  streamValues<V>(table: string, limit?: number): ReadableTyped<V> {
+  streamValues(table: string, limit?: number): ReadableTyped<Buffer> {
     // `select v` doesn't work for some reason
-    const q = DBQuery.create<KVObject<V>>(table).limit(limit || 0)
+    const q = DBQuery.create<KVObject>(table).limit(limit || 0)
 
     return (
       this.db
@@ -75,8 +80,8 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
     )
   }
 
-  streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>> {
-    const q = DBQuery.create<KVObject<V>>(table).limit(limit || 0)
+  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
+    const q = DBQuery.create<KVObject>(table).limit(limit || 0)
 
     return (
       this.db