@naturalcycles/redis-lib 3.1.1 → 3.2.0

package/dist/redisClient.d.ts

@@ -47,11 +47,13 @@ export declare class RedisClient implements CommonClient {
     hmget(key: string, fields: string[]): Promise<NullableString[]>;
     hmgetBuffer(key: string, fields: string[]): Promise<NullableBuffer[]>;
     hincr(key: string, field: string, increment?: number): Promise<number>;
+    hincrBatch(key: string, incrementTuples: [string, number][]): Promise<[string, number][]>;
     setWithTTL(key: string, value: string | number | Buffer, expireAt: UnixTimestampNumber): Promise<void>;
-    hsetWithTTL(key: string, value: AnyObject, expireAt: UnixTimestampNumber): Promise<void>;
+    hsetWithTTL(_key: string, _value: AnyObject, _expireAt: UnixTimestampNumber): Promise<void>;
     mset(obj: Record<string, string | number>): Promise<void>;
     msetBuffer(obj: Record<string, Buffer>): Promise<void>;
     incr(key: string, by?: number): Promise<number>;
+    incrBatch(incrementTuples: [string, number][]): Promise<[string, number][]>;
     ttl(key: string): Promise<number>;
     dropTable(table: string): Promise<void>;
     clearAll(): Promise<void>;

package/dist/redisClient.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
+const js_lib_1 = require("@naturalcycles/js-lib");
 /**
  Wraps the redis sdk with unified interface.
  Features:
@@ -98,17 +99,30 @@ class RedisClient {
     async hincr(key, field, increment = 1) {
         return await this.redis().hincrby(key, field, increment);
     }
+    async hincrBatch(key, incrementTuples) {
+        const results = {};
+        await this.withPipeline(async (pipeline) => {
+            for (const [field, increment] of incrementTuples) {
+                pipeline.hincrby(key, field, increment, (_err, newValue) => {
+                    results[field] = newValue;
+                });
+            }
+        });
+        const validResults = (0, js_lib_1._stringMapEntries)(results).filter(([_, v]) => v !== undefined);
+        return validResults;
+    }
     async setWithTTL(key, value, expireAt) {
         await this.redis().set(key, value, 'EXAT', expireAt);
     }
-    async hsetWithTTL(key, value, expireAt) {
-        const valueKeys = Object.keys(value);
-        const numberOfKeys = valueKeys.length;
-        const keyList = valueKeys.join(' ');
-        const commandString = `HEXPIREAT ${key} ${expireAt} FIELDS ${numberOfKeys} ${keyList}`;
-        const [command, ...args] = commandString.split(' ');
-        await this.redis().hset(key, value);
-        await this.redis().call(command, args);
+    async hsetWithTTL(_key, _value, _expireAt) {
+        throw new Error('Not supported until Redis 7.4.0');
+        // const valueKeys = Object.keys(value)
+        // const numberOfKeys = valueKeys.length
+        // const keyList = valueKeys.join(' ')
+        // const commandString = `HEXPIREAT ${key} ${expireAt} FIELDS ${numberOfKeys} ${keyList}`
+        // const [command, ...args] = commandString.split(' ')
+        // await this.redis().hset(key, value)
+        // await this.redis().call(command!, args)
     }
     async mset(obj) {
         await this.redis().mset(obj);
@@ -119,6 +133,18 @@ class RedisClient {
     async incr(key, by = 1) {
         return await this.redis().incrby(key, by);
     }
+    async incrBatch(incrementTuples) {
+        const results = {};
+        await this.withPipeline(async (pipeline) => {
+            for (const [key, increment] of incrementTuples) {
+                pipeline.incrby(key, increment, (_err, newValue) => {
+                    results[key] = newValue;
+                });
+            }
+        });
+        const validResults = (0, js_lib_1._stringMapEntries)(results).filter(([_, v]) => v !== undefined);
+        return validResults;
+    }
     async ttl(key) {
         return await this.redis().ttl(key);
     }

package/dist/redisHashKeyValueDB.d.ts

@@ -1,5 +1,4 @@
-import { CommonDBCreateOptions, CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, KeyValueDBTuple } from '@naturalcycles/db-lib';
-import { StringMap } from '@naturalcycles/js-lib';
+import { CommonDBCreateOptions, CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple, KeyValueDBTuple } from '@naturalcycles/db-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { RedisClient } from './redisClient';
 import { RedisKeyValueDBCfg } from './redisKeyValueDB';
@@ -23,8 +22,7 @@ export declare class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDispo
     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, increments: IncrementTuple[]): Promise<IncrementTuple[]>;
     createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
     private idsToKeys;
     private idToKey;

package/dist/redisHashKeyValueDB.js

@@ -94,11 +94,11 @@ class RedisHashKeyValueDB {
             match: `${table}:*`,
         });
     }
-    async increment(table, id, by = 1) {
-        return await this.client.hincr(this.keyOfHashField, this.idToKey(table, id), by);
-    }
-    async incrementBatch(_table, _incrementMap) {
-        throw new Error('Not implemented');
+    async incrementBatch(table, increments) {
+        const incrementTuplesWithInternalKeys = increments.map(([id, v]) => [this.idToKey(table, id), v]);
+        const resultsWithInternalKeys = await this.client.hincrBatch(this.keyOfHashField, incrementTuplesWithInternalKeys);
+        const results = resultsWithInternalKeys.map(([k, v]) => [this.keyToId(table, k), v]);
+        return results;
     }
     async createTable(table, opt) {
         if (!opt?.dropIfExists)

package/dist/redisKeyValueDB.d.ts

@@ -1,5 +1,4 @@
-import { CommonDBCreateOptions, CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, KeyValueDBTuple } from '@naturalcycles/db-lib';
-import { StringMap } from '@naturalcycles/js-lib';
+import { CommonDBCreateOptions, CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple, KeyValueDBTuple } from '@naturalcycles/db-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { RedisClient } from './redisClient';
 export interface RedisKeyValueDBCfg {
@@ -21,8 +20,7 @@ export declare class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposabl
     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, increments: IncrementTuple[]): Promise<IncrementTuple[]>;
     createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
     private idsToKeys;
     private idToKey;

package/dist/redisKeyValueDB.js

@@ -89,11 +89,11 @@ class RedisKeyValueDB {
             match: `${table}:*`,
         });
     }
-    async increment(table, id, by = 1) {
-        return await this.client.incr(this.idToKey(table, id), by);
-    }
-    async incrementBatch(_table, _incrementMap) {
-        throw new Error('Not implemented');
+    async incrementBatch(table, increments) {
+        const incrementTuplesWithInternalKeys = increments.map(([id, v]) => [this.idToKey(table, id), v]);
+        const resultsWithInternalKeys = await this.client.incrBatch(incrementTuplesWithInternalKeys);
+        const results = resultsWithInternalKeys.map(([k, v]) => [this.keyToId(table, k), v]);
+        return results;
     }
     async createTable(table, opt) {
         if (!opt?.dropIfExists)

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=20.13"
   },
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Redis implementation of CommonKeyValueDB interface",
   "author": "Natural Cycles Team",
   "license": "MIT"

package/src/redisClient.ts

@@ -1,9 +1,11 @@
 import {
+  _stringMapEntries,
   AnyObject,
   CommonLogger,
   NullableBuffer,
   NullableString,
   Promisable,
+  StringMap,
   UnixTimestampNumber,
 } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
@@ -157,6 +159,25 @@ export class RedisClient implements CommonClient {
     return await this.redis().hincrby(key, field, increment)
   }
 
+  async hincrBatch(key: string, incrementTuples: [string, number][]): Promise<[string, number][]> {
+    const results: StringMap<number | undefined> = {}
+
+    await this.withPipeline(async pipeline => {
+      for (const [field, increment] of incrementTuples) {
+        pipeline.hincrby(key, field, increment, (_err, newValue) => {
+          results[field] = newValue
+        })
+      }
+    })
+
+    const validResults = _stringMapEntries(results).filter(([_, v]) => v !== undefined) as [
+      string,
+      number,
+    ][]
+
+    return validResults
+  }
+
   async setWithTTL(
     key: string,
     value: string | number | Buffer,
@@ -165,14 +186,19 @@ export class RedisClient implements CommonClient {
     await this.redis().set(key, value, 'EXAT', expireAt)
   }
 
-  async hsetWithTTL(key: string, value: AnyObject, expireAt: UnixTimestampNumber): Promise<void> {
-    const valueKeys = Object.keys(value)
-    const numberOfKeys = valueKeys.length
-    const keyList = valueKeys.join(' ')
-    const commandString = `HEXPIREAT ${key} ${expireAt} FIELDS ${numberOfKeys} ${keyList}`
-    const [command, ...args] = commandString.split(' ')
-    await this.redis().hset(key, value)
-    await this.redis().call(command!, args)
+  async hsetWithTTL(
+    _key: string,
+    _value: AnyObject,
+    _expireAt: UnixTimestampNumber,
+  ): Promise<void> {
+    throw new Error('Not supported until Redis 7.4.0')
+    // const valueKeys = Object.keys(value)
+    // const numberOfKeys = valueKeys.length
+    // const keyList = valueKeys.join(' ')
+    // const commandString = `HEXPIREAT ${key} ${expireAt} FIELDS ${numberOfKeys} ${keyList}`
+    // const [command, ...args] = commandString.split(' ')
+    // await this.redis().hset(key, value)
+    // await this.redis().call(command!, args)
   }
 
   async mset(obj: Record<string, string | number>): Promise<void> {
@@ -187,6 +213,25 @@ export class RedisClient implements CommonClient {
     return await this.redis().incrby(key, by)
   }
 
+  async incrBatch(incrementTuples: [string, number][]): Promise<[string, number][]> {
+    const results: StringMap<number | undefined> = {}
+
+    await this.withPipeline(async pipeline => {
+      for (const [key, increment] of incrementTuples) {
+        pipeline.incrby(key, increment, (_err, newValue) => {
+          results[key] = newValue
+        })
+      }
+    })
+
+    const validResults = _stringMapEntries(results).filter(([_, v]) => v !== undefined) as [
+      string,
+      number,
+    ][]
+
+    return validResults
+  }
+
   async ttl(key: string): Promise<number> {
     return await this.redis().ttl(key)
   }

package/src/redisHashKeyValueDB.ts

@@ -3,6 +3,7 @@ import {
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
   CommonKeyValueDBSaveBatchOptions,
+  IncrementTuple,
   KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
 import { _chunk, StringMap } from '@naturalcycles/js-lib'
@@ -121,15 +122,18 @@ export class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     })
   }
 
-  async increment(table: string, id: string, by = 1): Promise<number> {
-    return await this.client.hincr(this.keyOfHashField, this.idToKey(table, id), by)
-  }
-
-  async incrementBatch(
-    _table: string,
-    _incrementMap: StringMap<number>,
-  ): Promise<StringMap<number>> {
-    throw new Error('Not implemented')
+  async incrementBatch(table: string, increments: IncrementTuple[]): Promise<IncrementTuple[]> {
+    const incrementTuplesWithInternalKeys = increments.map(
+      ([id, v]) => [this.idToKey(table, id), v] as [string, number],
+    )
+    const resultsWithInternalKeys = await this.client.hincrBatch(
+      this.keyOfHashField,
+      incrementTuplesWithInternalKeys,
+    )
+    const results = resultsWithInternalKeys.map(
+      ([k, v]) => [this.keyToId(table, k), v] as IncrementTuple,
+    )
+    return results
   }
 
   async createTable(table: string, opt?: CommonDBCreateOptions): Promise<void> {

package/src/redisKeyValueDB.ts

@@ -3,9 +3,10 @@ import {
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
   CommonKeyValueDBSaveBatchOptions,
+  IncrementTuple,
   KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
-import { _isTruthy, _zip, StringMap } from '@naturalcycles/js-lib'
+import { _isTruthy, _zip } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { RedisClient } from './redisClient'
 
@@ -123,15 +124,15 @@ export class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     })
   }
 
-  async increment(table: string, id: string, by = 1): Promise<number> {
-    return await this.client.incr(this.idToKey(table, id), by)
-  }
-
-  async incrementBatch(
-    _table: string,
-    _incrementMap: StringMap<number>,
-  ): Promise<StringMap<number>> {
-    throw new Error('Not implemented')
+  async incrementBatch(table: string, increments: IncrementTuple[]): Promise<IncrementTuple[]> {
+    const incrementTuplesWithInternalKeys = increments.map(
+      ([id, v]) => [this.idToKey(table, id), v] as [string, number],
+    )
+    const resultsWithInternalKeys = await this.client.incrBatch(incrementTuplesWithInternalKeys)
+    const results = resultsWithInternalKeys.map(
+      ([k, v]) => [this.keyToId(table, k), v] as IncrementTuple,
+    )
+    return results
   }
 
   async createTable(table: string, opt?: CommonDBCreateOptions): Promise<void> {