@naturalcycles/datastore-lib 3.38.0 → 3.38.2

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;

package/dist/datastoreKeyValueDB.d.ts

@@ -1,5 +1,5 @@
 import { CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-lib';
-import { StringMap } from '@naturalcycles/js-lib';
+import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { DatastoreDB } from './datastore.db';
 import { DatastoreDBCfg } from './datastore.model';
@@ -22,6 +22,5 @@ export declare class DatastoreKeyValueDB implements CommonKeyValueDB {
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
-    increment(_table: string, _id: string, _by?: number): Promise<number>;
-    incrementBatch(_table: string, _incrementMap: StringMap<number>): Promise<StringMap<number>>;
+    incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/datastoreKeyValueDB.js

@@ -57,10 +57,7 @@ class DatastoreKeyValueDB {
         const q = db_lib_1.DBQuery.create(table);
         return await this.db.runQueryCount(q);
     }
-    async increment(_table, _id, _by) {
-        throw new js_lib_1.AppError('DatastoreKeyValueDB.increment() is not implemented');
-    }
-    async incrementBatch(_table, _incrementMap) {
+    async incrementBatch(_table, _entries) {
         throw new js_lib_1.AppError('DatastoreKeyValueDB.incrementBatch() is not implemented');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/datastore-lib",
-  "version": "3.38.0",
+  "version": "3.38.2",
   "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,

package/src/datastoreKeyValueDB.ts

@@ -4,7 +4,8 @@ import {
   DBQuery,
   KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
-import { AppError, StringMap } from '@naturalcycles/js-lib'
+import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB'
+import { AppError, ObjectWithId } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { DatastoreDB } from './datastore.db'
 import { DatastoreDBCfg } from './datastore.model'
@@ -55,7 +56,7 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
   }
 
   streamIds(table: string, limit?: number): ReadableTyped<string> {
-    const q = DBQuery.create<KVObject>(table)
+    const q = DBQuery.create<ObjectWithId>(table)
       .select(['id'])
       .limit(limit || 0)
 
@@ -86,23 +87,16 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
       this.db
         .streamQuery(q)
         // .on('error', err => stream.emit('error', err))
-        .map(r => [r.id, r.v] as KeyValueDBTuple)
+        .map(r => [r.id, r.v])
     )
   }
 
   async count(table: string): Promise<number> {
-    const q = DBQuery.create<KVObject>(table)
+    const q = DBQuery.create<ObjectWithId>(table)
     return await this.db.runQueryCount(q)
   }
 
-  async increment(_table: string, _id: string, _by?: number): Promise<number> {
-    throw new AppError('DatastoreKeyValueDB.increment() is not implemented')
-  }
-
-  async incrementBatch(
-    _table: string,
-    _incrementMap: StringMap<number>,
-  ): Promise<StringMap<number>> {
+  async incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]> {
     throw new AppError('DatastoreKeyValueDB.incrementBatch() is not implemented')
   }
 }