@naturalcycles/redis-lib 3.1.0 → 3.2.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * from './redisClient';
-export * from './redisKeyValueDB';
 export * from './redisHashKeyValueDB';
+export * from './redisKeyValueDB';

package/dist/index.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./redisClient"), exports);
-tslib_1.__exportStar(require("./redisKeyValueDB"), exports);
 tslib_1.__exportStar(require("./redisHashKeyValueDB"), exports);
+tslib_1.__exportStar(require("./redisKeyValueDB"), exports);

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);
     }
@@ -158,6 +184,7 @@ class RedisClient {
      * Like scanStream, but flattens the stream of keys.
      */
     scanStreamFlat(opt) {
+        // biome-ignore lint/correctness/noFlatMapIdentity: ok
         return this.redis().scanStream(opt).flatMap(keys => keys);
     }
     async scanCount(opt) {

package/dist/redisHashKeyValueDB.d.ts

@@ -1,4 +1,4 @@
-import { CommonKeyValueDBSaveBatchOptions, CommonDBCreateOptions, CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-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';
@@ -9,6 +9,10 @@ export declare class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDispo
     client: RedisClient;
     keyOfHashField: string;
     constructor(cfg: RedisHashKeyValueDBCfg);
+    support: {
+        count?: boolean;
+        increment?: boolean;
+    };
     ping(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
@@ -16,9 +20,9 @@ export declare class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDispo
     saveBatch(table: string, entries: KeyValueDBTuple[], opt?: CommonKeyValueDBSaveBatchOptions): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number | undefined): ReadableTyped<KeyValueDBTuple>;
+    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
-    increment(table: string, id: string, by?: number): Promise<number>;
+    incrementBatch(table: string, increments: IncrementTuple[]): Promise<IncrementTuple[]>;
     createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
     private idsToKeys;
     private idToKey;

package/dist/redisHashKeyValueDB.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisHashKeyValueDB = void 0;
+const db_lib_1 = require("@naturalcycles/db-lib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 class RedisHashKeyValueDB {
     constructor(cfg) {
+        this.support = {
+            ...db_lib_1.commonKeyValueDBFullSupport,
+        };
         this.client = cfg.client;
         this.keyOfHashField = cfg.hashKey;
     }
@@ -90,8 +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, 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,4 +1,4 @@
-import { CommonKeyValueDBSaveBatchOptions, CommonDBCreateOptions, CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-lib';
+import { CommonDBCreateOptions, CommonKeyValueDB, CommonKeyValueDBSaveBatchOptions, IncrementTuple, KeyValueDBTuple } from '@naturalcycles/db-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { RedisClient } from './redisClient';
 export interface RedisKeyValueDBCfg {
@@ -7,6 +7,10 @@ export interface RedisKeyValueDBCfg {
 export declare class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     constructor(cfg: RedisKeyValueDBCfg);
     client: RedisClient;
+    support: {
+        count?: boolean;
+        increment?: boolean;
+    };
     ping(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
@@ -14,9 +18,9 @@ export declare class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposabl
     saveBatch(table: string, entries: KeyValueDBTuple[], opt?: CommonKeyValueDBSaveBatchOptions): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number | undefined): ReadableTyped<KeyValueDBTuple>;
+    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
     count(table: string): Promise<number>;
-    increment(table: string, id: string, by?: number): Promise<number>;
+    incrementBatch(table: string, increments: IncrementTuple[]): Promise<IncrementTuple[]>;
     createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
     private idsToKeys;
     private idToKey;

package/dist/redisKeyValueDB.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisKeyValueDB = void 0;
+const db_lib_1 = require("@naturalcycles/db-lib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 class RedisKeyValueDB {
     constructor(cfg) {
+        this.support = {
+            ...db_lib_1.commonKeyValueDBFullSupport,
+        };
         this.client = cfg.client;
     }
     async ping() {
@@ -85,8 +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, 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

@@ -1,7 +1,12 @@
 {
   "name": "@naturalcycles/redis-lib",
   "scripts": {
-    "prepare": "husky"
+    "prepare": "husky",
+    "build": "dev-lib build",
+    "test": "dev-lib test",
+    "lint": "dev-lib lint",
+    "bt": "dev-lib bt",
+    "lbt": "dev-lib lbt"
   },
   "dependencies": {
     "@naturalcycles/db-lib": "^9.9.2",
@@ -10,8 +15,8 @@
     "ioredis": "^5.3.2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "^13.49.2",
-    "@types/node": "^20.12.2",
+    "@naturalcycles/dev-lib": "^15.22.0",
+    "@types/node": "^22.7.5",
     "jest": "^29.7.0"
   },
   "files": [
@@ -33,9 +38,9 @@
     "url": "https://github.com/NaturalCycles/redis-lib"
   },
   "engines": {
-    "node": ">=18.12"
+    "node": ">=20.13"
   },
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Redis implementation of CommonKeyValueDB interface",
   "author": "Natural Cycles Team",
   "license": "MIT"

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from './redisClient'
-export * from './redisKeyValueDB'
 export * from './redisHashKeyValueDB'
+export * from './redisKeyValueDB'

package/src/redisClient.ts

@@ -1,15 +1,17 @@
 import {
+  _stringMapEntries,
   AnyObject,
   CommonLogger,
   NullableBuffer,
   NullableString,
   Promisable,
+  StringMap,
   UnixTimestampNumber,
 } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
-// eslint-disable-next-line import/no-duplicates
+// eslint-disable-next-line import-x/no-duplicates
 import type { Redis, RedisOptions } from 'ioredis'
-// eslint-disable-next-line import/no-duplicates
+// eslint-disable-next-line import-x/no-duplicates
 import type * as RedisLib from 'ioredis'
 import type { ScanStreamOptions } from 'ioredis/built/types'
 import type { ChainableCommander } from 'ioredis/built/utils/RedisCommander'
@@ -153,10 +155,29 @@ export class RedisClient implements CommonClient {
     return await this.redis().hmgetBuffer(key, ...fields)
   }
 
-  async hincr(key: string, field: string, increment: number = 1): Promise<number> {
+  async hincr(key: string, field: string, increment = 1): Promise<number> {
     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> {
@@ -183,10 +209,29 @@ export class RedisClient implements CommonClient {
     await this.redis().mset(obj)
   }
 
-  async incr(key: string, by: number = 1): Promise<number> {
+  async incr(key: string, by = 1): Promise<number> {
     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)
   }
@@ -234,6 +279,7 @@ export class RedisClient implements CommonClient {
    * Like scanStream, but flattens the stream of keys.
    */
   scanStreamFlat(opt: ScanStreamOptions): ReadableTyped<string> {
+    // biome-ignore lint/correctness/noFlatMapIdentity: ok
     return (this.redis().scanStream(opt) as ReadableTyped<string[]>).flatMap(keys => keys)
   }
 

package/src/redisHashKeyValueDB.ts

@@ -1,7 +1,9 @@
 import {
-  CommonKeyValueDBSaveBatchOptions,
   CommonDBCreateOptions,
   CommonKeyValueDB,
+  commonKeyValueDBFullSupport,
+  CommonKeyValueDBSaveBatchOptions,
+  IncrementTuple,
   KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
 import { _chunk, StringMap } from '@naturalcycles/js-lib'
@@ -22,6 +24,10 @@ export class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     this.keyOfHashField = cfg.hashKey
   }
 
+  support = {
+    ...commonKeyValueDBFullSupport,
+  }
+
   async ping(): Promise<void> {
     await this.client.ping()
   }
@@ -96,7 +102,7 @@ export class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
       .take(limit || Infinity)
   }
 
-  streamEntries(table: string, limit?: number | undefined): ReadableTyped<KeyValueDBTuple> {
+  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     return this.client
       .hscanStream(this.keyOfHashField, {
         match: `${table}:*`,
@@ -116,8 +122,18 @@ export class RedisHashKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     })
   }
 
-  async increment(table: string, id: string, by: number = 1): Promise<number> {
-    return await this.client.hincr(this.keyOfHashField, this.idToKey(table, id), by)
+  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

@@ -1,7 +1,9 @@
 import {
-  CommonKeyValueDBSaveBatchOptions,
   CommonDBCreateOptions,
   CommonKeyValueDB,
+  commonKeyValueDBFullSupport,
+  CommonKeyValueDBSaveBatchOptions,
+  IncrementTuple,
   KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
 import { _isTruthy, _zip } from '@naturalcycles/js-lib'
@@ -19,6 +21,10 @@ export class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
 
   client: RedisClient
 
+  support = {
+    ...commonKeyValueDBFullSupport,
+  }
+
   async ping(): Promise<void> {
     await this.client.ping()
   }
@@ -93,7 +99,7 @@ export class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
       .take(limit || Infinity)
   }
 
-  streamEntries(table: string, limit?: number | undefined): ReadableTyped<KeyValueDBTuple> {
+  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     return this.client
       .scanStream({
         match: `${table}:*`,
@@ -118,8 +124,15 @@ export class RedisKeyValueDB implements CommonKeyValueDB, AsyncDisposable {
     })
   }
 
-  async increment(table: string, id: string, by: number = 1): Promise<number> {
-    return await this.client.incr(this.idToKey(table, id), by)
+  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> {