@naturalcycles/datastore-lib 3.35.2 → 3.37.0

package/dist/datastore.db.d.ts

@@ -66,7 +66,7 @@ export declare class DatastoreDBTransaction implements DBTransaction {
     tx: Transaction;
     constructor(db: DatastoreDB, tx: Transaction);
     rollback(): Promise<void>;
-    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<ROW[]>;
-    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW> | undefined): Promise<void>;
-    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions | undefined): Promise<number>;
+    getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: CommonDBOptions): Promise<ROW[]>;
+    saveBatch<ROW extends ObjectWithId>(table: string, rows: ROW[], opt?: CommonDBSaveOptions<ROW>): Promise<void>;
+    deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number>;
 }

package/dist/datastoreKeyValueDB.d.ts

@@ -17,4 +17,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>;
 }

package/dist/datastoreKeyValueDB.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatastoreKeyValueDB = void 0;
 const db_lib_1 = require("@naturalcycles/db-lib");
+const js_lib_1 = require("@naturalcycles/js-lib");
 const datastore_db_1 = require("./datastore.db");
 const excludeFromIndexes = ['v'];
 class DatastoreKeyValueDB {
@@ -52,5 +53,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');
+    }
 }
 exports.DatastoreKeyValueDB = DatastoreKeyValueDB;

package/dist/query.util.js

@@ -13,16 +13,25 @@ const OP_MAP = {
 function dbQueryToDatastoreQuery(dbQuery, emptyQuery) {
     let q = emptyQuery;
     // filter
-    // eslint-disable-next-line unicorn/no-array-reduce
-    q = dbQuery._filters.reduce(
-    // keeping "previous syntax" commented out
-    // (q, f) => q.filter(f.name as string, OP_MAP[f.op] || (f.op as any), f.val),
-    (q, f) => q.filter(new datastore_1.PropertyFilter(f.name, OP_MAP[f.op] || f.op, f.val)), q);
+    for (const f of dbQuery._filters) {
+        // keeping "previous syntax" commented out
+        // (q, f) => q.filter(f.name as string, OP_MAP[f.op] || (f.op as any), f.val),
+        // Datastore doesn't allow `undefined` as filter value.
+        // We don't want to throw on it, so instead we'll replace it with valid value of `null`.
+        // `a > null` will return anything that's indexed
+        // `a < null` should return nothing
+        // `a == null` will return just that - rows with null values
+        let { op, val } = f;
+        if (val === undefined)
+            val = null;
+        q = q.filter(new datastore_1.PropertyFilter(f.name, OP_MAP[op] || op, val));
+    }
     // limit
     q = q.limit(dbQuery._limitValue || 0);
     // order
-    // eslint-disable-next-line unicorn/no-array-reduce
-    q = dbQuery._orders.reduce((q, ord) => q.order(ord.name, { descending: ord.descending }), q);
+    for (const ord of dbQuery._orders) {
+        q = q.order(ord.name, { descending: ord.descending });
+    }
     // select
     if (dbQuery._selectedFieldNames) {
         const fields = dbQuery._selectedFieldNames.map(f => FNAME_MAP[f] || f);

package/package.json

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

package/src/datastore.db.ts

@@ -571,7 +571,7 @@ export class DatastoreDBTransaction implements DBTransaction {
   async getByIds<ROW extends ObjectWithId>(
     table: string,
     ids: string[],
-    opt?: CommonDBOptions | undefined,
+    opt?: CommonDBOptions,
   ): Promise<ROW[]> {
     return await this.db.getByIds(table, ids, { ...opt, tx: this })
   }
@@ -579,16 +579,12 @@ export class DatastoreDBTransaction implements DBTransaction {
   async saveBatch<ROW extends ObjectWithId>(
     table: string,
     rows: ROW[],
-    opt?: CommonDBSaveOptions<ROW> | undefined,
+    opt?: CommonDBSaveOptions<ROW>,
   ): Promise<void> {
     await this.db.saveBatch(table, rows, { ...opt, tx: this })
   }
 
-  async deleteByIds(
-    table: string,
-    ids: string[],
-    opt?: CommonDBOptions | undefined,
-  ): Promise<number> {
+  async deleteByIds(table: string, ids: string[], opt?: CommonDBOptions): Promise<number> {
     return await this.db.deleteByIds(table, ids, { ...opt, tx: this })
   }
 }

package/src/datastoreKeyValueDB.ts

@@ -1,4 +1,5 @@
 import { CommonKeyValueDB, DBQuery, KeyValueDBTuple } from '@naturalcycles/db-lib'
+import { AppError } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { DatastoreDB } from './datastore.db'
 import { DatastoreDBCfg } from './datastore.model'
@@ -83,4 +84,8 @@ export class DatastoreKeyValueDB implements CommonKeyValueDB {
     const q = DBQuery.create<KVObject>(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')
+  }
 }

package/src/query.util.ts

@@ -19,23 +19,27 @@ export function dbQueryToDatastoreQuery<ROW extends ObjectWithId>(
   let q = emptyQuery
 
   // filter
-  // eslint-disable-next-line unicorn/no-array-reduce
-  q = dbQuery._filters.reduce(
+  for (const f of dbQuery._filters) {
     // keeping "previous syntax" commented out
     // (q, f) => q.filter(f.name as string, OP_MAP[f.op] || (f.op as any), f.val),
-    (q, f) => q.filter(new PropertyFilter(f.name as string, OP_MAP[f.op] || (f.op as any), f.val)),
-    q,
-  )
+
+    // Datastore doesn't allow `undefined` as filter value.
+    // We don't want to throw on it, so instead we'll replace it with valid value of `null`.
+    // `a > null` will return anything that's indexed
+    // `a < null` should return nothing
+    // `a == null` will return just that - rows with null values
+    let { op, val } = f
+    if (val === undefined) val = null
+    q = q.filter(new PropertyFilter(f.name as string, OP_MAP[op] || (op as any), val))
+  }
 
   // limit
   q = q.limit(dbQuery._limitValue || 0)
 
   // order
-  // eslint-disable-next-line unicorn/no-array-reduce
-  q = dbQuery._orders.reduce(
-    (q, ord) => q.order(ord.name as string, { descending: ord.descending }),
-    q,
-  )
+  for (const ord of dbQuery._orders) {
+    q = q.order(ord.name as string, { descending: ord.descending })
+  }
 
   // select
   if (dbQuery._selectedFieldNames) {