@naturalcycles/datastore-lib 3.37.0 → 3.38.1

package/dist/datastore.db.js

@@ -38,7 +38,8 @@ class DatastoreDB extends db_lib_1.BaseCommonDB {
         super();
         this.support = {
             ...db_lib_1.commonDBFullSupport,
-            updateByQuery: false,
+            patchByQuery: false,
+            increment: false,
         };
         this.cfg = {
             logger: console,

package/dist/datastoreKeyValueDB.d.ts

@@ -1,4 +1,6 @@
-import { CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-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';
@@ -8,14 +10,18 @@ export declare class DatastoreKeyValueDB implements CommonKeyValueDB {
     cfg: DatastoreKeyValueDBCfg;
     constructor(cfg: DatastoreKeyValueDBCfg);
     db: DatastoreDB;
+    support: {
+        increment: boolean;
+        count?: boolean;
+    };
     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, _entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/datastoreKeyValueDB.js

@@ -8,6 +8,10 @@ const excludeFromIndexes = ['v'];
 class DatastoreKeyValueDB {
     constructor(cfg) {
         this.cfg = cfg;
+        this.support = {
+            ...db_lib_1.commonKeyValueDBFullSupport,
+            increment: false,
+        };
         this.db = new datastore_db_1.DatastoreDB(cfg);
     }
     async ping() {
@@ -53,8 +57,8 @@ 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, _entries) {
+        throw new js_lib_1.AppError('DatastoreKeyValueDB.incrementBatch() is not implemented');
     }
 }
 exports.DatastoreKeyValueDB = DatastoreKeyValueDB;

package/package.json

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

package/src/datastore.db.ts

@@ -80,7 +80,8 @@ const methodMap: Record<CommonDBSaveMethod, string> = {
 export class DatastoreDB extends BaseCommonDB implements CommonDB {
   override support: CommonDBSupport = {
     ...commonDBFullSupport,
-    updateByQuery: false,
+    patchByQuery: false,
+    increment: false,
   }
 
   constructor(cfg: DatastoreDBCfg = {}) {

package/src/datastoreKeyValueDB.ts

@@ -1,15 +1,16 @@
-import { CommonKeyValueDB, DBQuery, KeyValueDBTuple } from '@naturalcycles/db-lib'
-import { AppError } 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 {}
 
@@ -20,22 +21,27 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
 
   db: DatastoreDB
 
+  support = {
+    ...commonKeyValueDBFullSupport,
+    increment: false,
+  }
+
   async ping(): Promise<void> {
     await this.db.ping()
   }
 
   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 })),
       {
@@ -45,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)
 
@@ -57,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
@@ -69,23 +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, _entries: IncrementTuple[]): Promise<IncrementTuple[]> {
+    throw new AppError('DatastoreKeyValueDB.incrementBatch() is not implemented')
   }
 }