@naturalcycles/datastore-lib 3.38.1 → 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,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.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

@@ -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