@naturalcycles/datastore-lib 3.38.0 → 3.38.1

package/dist/datastoreKeyValueDB.d.ts

@@ -1,5 +1,6 @@
-import { CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-lib';
-import { StringMap } from '@naturalcycles/js-lib';
+import { CommonKeyValueDB } 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';
@@ -15,13 +16,12 @@ export declare class DatastoreKeyValueDB implements CommonKeyValueDB {
     };
     ping(): Promise<void>;
     createTable(): Promise<void>;
-    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
+    getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]>;
     deleteByIds(table: string, ids: string[]): Promise<void>;
-    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
+    saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    streamValues<V>(table: string, limit?: number): ReadableTyped<V>;
+    streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>>;
     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.1",
   "description": "Opinionated library to work with Google Datastore",
   "scripts": {
     "prepare": "husky",

package/src/datastoreKeyValueDB.ts

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