@pluv/persistence-redis 0.0.0-experimental-20250527040415

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+## `@pluv/persistence-redis`
+
+> Crdt storage persistence for [@pluv/io](https://www.npmjs.com/package/@pluv/io) rooms on distributed systems. Available for [Node.js](https://nodejs.org/) only.
+
+**👉 See full documentation on [pluv.io](https://pluv.io/docs/introduction). 👈**
+
+## Installation
+
+```bash
+# npm
+npm install @pluv/persistence-redis ioredis
+
+# yarn
+yarn add @pluv/persistence-redis ioredis
+
+# pnpm
+pnpm add @pluv/persistence-redis ioredis
+```

package/dist/index.d.mts

@@ -0,0 +1,29 @@
+import { AbstractPersistence } from '@pluv/io';
+import { JsonObject } from '@pluv/types';
+import { Cluster, Redis } from 'ioredis';
+
+type RedisClient = Cluster | Redis;
+interface PersistenceRedisOptions {
+    client: RedisClient;
+}
+declare class PersistenceRedis extends AbstractPersistence {
+    private _client;
+    private _initialized;
+    constructor(options: PersistenceRedisOptions);
+    addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    deleteStorageState(room: string): Promise<void>;
+    deleteUser(room: string, connectionId: string): Promise<void>;
+    deleteUsers(room: string): Promise<void>;
+    getStorageState(room: string): Promise<string | null>;
+    setStorageState(room: string, state: string): Promise<void>;
+    getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    getUsers(room: string): Promise<Map<[connectionId: string][0], JsonObject | null>>;
+    getUsersSize(room: string): Promise<number>;
+    initialize(roomContext: {}): typeof this;
+    private _getClusterKey;
+    private _getRoomStorageKey;
+    private _getRoomUsersKey;
+    private _getRoomUsersUserKey;
+}
+
+export { PersistenceRedis, type RedisClient };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { AbstractPersistence } from '@pluv/io';
+import { JsonObject } from '@pluv/types';
+import { Cluster, Redis } from 'ioredis';
+
+type RedisClient = Cluster | Redis;
+interface PersistenceRedisOptions {
+    client: RedisClient;
+}
+declare class PersistenceRedis extends AbstractPersistence {
+    private _client;
+    private _initialized;
+    constructor(options: PersistenceRedisOptions);
+    addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    deleteStorageState(room: string): Promise<void>;
+    deleteUser(room: string, connectionId: string): Promise<void>;
+    deleteUsers(room: string): Promise<void>;
+    getStorageState(room: string): Promise<string | null>;
+    setStorageState(room: string, state: string): Promise<void>;
+    getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    getUsers(room: string): Promise<Map<[connectionId: string][0], JsonObject | null>>;
+    getUsersSize(room: string): Promise<number>;
+    initialize(roomContext: {}): typeof this;
+    private _getClusterKey;
+    private _getRoomStorageKey;
+    private _getRoomUsersKey;
+    private _getRoomUsersUserKey;
+}
+
+export { PersistenceRedis, type RedisClient };

package/dist/index.js

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PersistenceRedis: () => PersistenceRedis
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/PersistenceRedis.ts
+var import_io = require("@pluv/io");
+
+// src/utils/partitionByLength.ts
+var partitionByLength = (arr, length) => {
+  if (!arr.length) return [];
+  const head = arr.slice(0, length);
+  const tail = arr.slice(length);
+  return [head, ...partitionByLength(tail, length)];
+};
+
+// src/PersistenceRedis.ts
+var DELIMITER = ":::";
+var HASH_TAG = "{PluvPersistenceRedis}";
+var GET_USERS_CONCURRENCY = 4;
+var PersistenceRedis = class _PersistenceRedis extends import_io.AbstractPersistence {
+  constructor(options) {
+    super();
+    this._initialized = null;
+    const { client } = options;
+    this._client = client;
+    this._initialized = options._initialized;
+  }
+  addUser(room, connectionId, user) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.multi().sadd(this._getRoomUsersKey(room), connectionId).set(this._getRoomUsersUserKey(room, connectionId), JSON.stringify(user)).exec();
+    });
+  }
+  deleteStorageState(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.del(this._getRoomStorageKey(room));
+    });
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      const size = yield this.getUsersSize(room);
+      let multi = this._client.multi().srem(this._getRoomUsersKey(room), connectionId).del(this._getRoomUsersUserKey(room, connectionId));
+      if (size === 1) {
+        multi = multi.del(this._getRoomStorageKey(room)).del(this._getRoomUsersKey(room));
+      }
+      yield multi.exec();
+    });
+  }
+  deleteUsers(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      const members = yield this._client.smembers(this._getRoomUsersKey(room));
+      yield members.reduce(
+        (commands, connectionId) => {
+          return commands.del(this._getRoomUsersUserKey(room, connectionId));
+        },
+        this._client.multi().del(this._getRoomUsersKey(room))
+      ).exec();
+    });
+  }
+  getStorageState(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return null;
+      yield this._initialized;
+      return yield this._client.get(this._getRoomStorageKey(room));
+    });
+  }
+  setStorageState(room, state) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.set(this._getRoomStorageKey(room), state);
+    });
+  }
+  getUser(room, connectionId) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return null;
+      yield this._initialized;
+      const data = yield this._client.get(this._getRoomUsersUserKey(room, connectionId));
+      return !data ? null : JSON.parse(data);
+    });
+  }
+  getUsers(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return /* @__PURE__ */ new Map();
+      yield this._initialized;
+      const members = yield this._client.smembers(this._getRoomUsersKey(room));
+      const partitions = partitionByLength(members, GET_USERS_CONCURRENCY);
+      return yield partitions.reduce((promise, partition) => __async(this, null, function* () {
+        const map = yield promise;
+        const promises = partition.map((connectionId) => __async(this, null, function* () {
+          map.set(connectionId, yield this.getUser(room, connectionId));
+        }));
+        yield Promise.all(promises);
+        return map;
+      }), Promise.resolve(/* @__PURE__ */ new Map()));
+    });
+  }
+  getUsersSize(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return 0;
+      yield this._initialized;
+      return yield this._client.scard(this._getRoomUsersKey(room));
+    });
+  }
+  initialize(roomContext) {
+    return new _PersistenceRedis(__spreadValues({
+      client: this._client
+    }, { _initialized: Promise.resolve(true) }));
+  }
+  _getClusterKey(key) {
+    return `${HASH_TAG}${key}`;
+  }
+  _getRoomStorageKey(room) {
+    return this._getClusterKey(`room_storage${DELIMITER}${room}`);
+  }
+  _getRoomUsersKey(room) {
+    return this._getClusterKey(`room_users${DELIMITER}${room}`);
+  }
+  _getRoomUsersUserKey(room, connectionId) {
+    return this._getClusterKey(`${this._getRoomUsersKey(room)}${DELIMITER}${connectionId}`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PersistenceRedis
+});

package/dist/index.mjs

@@ -0,0 +1,165 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/PersistenceRedis.ts
+import { AbstractPersistence } from "@pluv/io";
+
+// src/utils/partitionByLength.ts
+var partitionByLength = (arr, length) => {
+  if (!arr.length) return [];
+  const head = arr.slice(0, length);
+  const tail = arr.slice(length);
+  return [head, ...partitionByLength(tail, length)];
+};
+
+// src/PersistenceRedis.ts
+var DELIMITER = ":::";
+var HASH_TAG = "{PluvPersistenceRedis}";
+var GET_USERS_CONCURRENCY = 4;
+var PersistenceRedis = class _PersistenceRedis extends AbstractPersistence {
+  constructor(options) {
+    super();
+    this._initialized = null;
+    const { client } = options;
+    this._client = client;
+    this._initialized = options._initialized;
+  }
+  addUser(room, connectionId, user) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.multi().sadd(this._getRoomUsersKey(room), connectionId).set(this._getRoomUsersUserKey(room, connectionId), JSON.stringify(user)).exec();
+    });
+  }
+  deleteStorageState(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.del(this._getRoomStorageKey(room));
+    });
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      const size = yield this.getUsersSize(room);
+      let multi = this._client.multi().srem(this._getRoomUsersKey(room), connectionId).del(this._getRoomUsersUserKey(room, connectionId));
+      if (size === 1) {
+        multi = multi.del(this._getRoomStorageKey(room)).del(this._getRoomUsersKey(room));
+      }
+      yield multi.exec();
+    });
+  }
+  deleteUsers(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      const members = yield this._client.smembers(this._getRoomUsersKey(room));
+      yield members.reduce(
+        (commands, connectionId) => {
+          return commands.del(this._getRoomUsersUserKey(room, connectionId));
+        },
+        this._client.multi().del(this._getRoomUsersKey(room))
+      ).exec();
+    });
+  }
+  getStorageState(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return null;
+      yield this._initialized;
+      return yield this._client.get(this._getRoomStorageKey(room));
+    });
+  }
+  setStorageState(room, state) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return;
+      yield this._initialized;
+      yield this._client.set(this._getRoomStorageKey(room), state);
+    });
+  }
+  getUser(room, connectionId) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return null;
+      yield this._initialized;
+      const data = yield this._client.get(this._getRoomUsersUserKey(room, connectionId));
+      return !data ? null : JSON.parse(data);
+    });
+  }
+  getUsers(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return /* @__PURE__ */ new Map();
+      yield this._initialized;
+      const members = yield this._client.smembers(this._getRoomUsersKey(room));
+      const partitions = partitionByLength(members, GET_USERS_CONCURRENCY);
+      return yield partitions.reduce((promise, partition) => __async(this, null, function* () {
+        const map = yield promise;
+        const promises = partition.map((connectionId) => __async(this, null, function* () {
+          map.set(connectionId, yield this.getUser(room, connectionId));
+        }));
+        yield Promise.all(promises);
+        return map;
+      }), Promise.resolve(/* @__PURE__ */ new Map()));
+    });
+  }
+  getUsersSize(room) {
+    return __async(this, null, function* () {
+      if (!this._initialized) return 0;
+      yield this._initialized;
+      return yield this._client.scard(this._getRoomUsersKey(room));
+    });
+  }
+  initialize(roomContext) {
+    return new _PersistenceRedis(__spreadValues({
+      client: this._client
+    }, { _initialized: Promise.resolve(true) }));
+  }
+  _getClusterKey(key) {
+    return `${HASH_TAG}${key}`;
+  }
+  _getRoomStorageKey(room) {
+    return this._getClusterKey(`room_storage${DELIMITER}${room}`);
+  }
+  _getRoomUsersKey(room) {
+    return this._getClusterKey(`room_users${DELIMITER}${room}`);
+  }
+  _getRoomUsersUserKey(room, connectionId) {
+    return this._getClusterKey(`${this._getRoomUsersKey(room)}${DELIMITER}${connectionId}`);
+  }
+};
+export {
+  PersistenceRedis
+};

package/eslint.config.mjs

@@ -0,0 +1,4 @@
+import { config } from "eslint-config-pluv/base";
+
+/** @type {import("eslint").Linter.Config} */
+export default config;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pluv/persistence-redis",
+  "version": "0.0.0-experimental-20250527040415",
+  "description": "@pluv/io crdt storage persistence for node.js",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/persistence-redis"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^22.15.21",
+    "@pluv/io": "^0.0.0-experimental-20250527040415",
+    "@pluv/types": "^0.0.0-experimental-20250527040415"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.27.0",
+    "ioredis": "^5.6.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "eslint-config-pluv": "^0.0.0-experimental-20250527040415",
+    "@pluv/tsconfig": "^0.0.0-experimental-20250527040415"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint \"src/**/*.ts*\" --fix --max-warnings 0",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/PersistenceRedis.ts

@@ -0,0 +1,169 @@
+import { AbstractPersistence } from "@pluv/io";
+import type { JsonObject } from "@pluv/types";
+import type { Cluster, Redis } from "ioredis";
+import { partitionByLength } from "./utils";
+
+const DELIMITER = ":::";
+const HASH_TAG = "{PluvPersistenceRedis}";
+
+const GET_USERS_CONCURRENCY = 4;
+
+export type RedisClient = Cluster | Redis;
+
+export interface PersistenceRedisOptions {
+    client: RedisClient;
+}
+
+export class PersistenceRedis extends AbstractPersistence {
+    private _client: RedisClient;
+    private _initialized: Promise<true> | null = null;
+
+    constructor(options: PersistenceRedisOptions) {
+        super();
+
+        const { client } = options;
+
+        this._client = client;
+        this._initialized = (options as any)._initialized;
+    }
+
+    public async addUser(
+        room: string,
+        connectionId: string,
+        user: JsonObject | null,
+    ): Promise<void> {
+        if (!this._initialized) return;
+
+        await this._initialized;
+
+        await this._client
+            .multi()
+            .sadd(this._getRoomUsersKey(room), connectionId)
+            .set(this._getRoomUsersUserKey(room, connectionId), JSON.stringify(user))
+            .exec();
+    }
+
+    public async deleteStorageState(room: string): Promise<void> {
+        if (!this._initialized) return;
+
+        await this._initialized;
+
+        await this._client.del(this._getRoomStorageKey(room));
+    }
+
+    public async deleteUser(room: string, connectionId: string): Promise<void> {
+        if (!this._initialized) return;
+
+        await this._initialized;
+
+        const size = await this.getUsersSize(room);
+
+        let multi = this._client
+            .multi()
+            .srem(this._getRoomUsersKey(room), connectionId)
+            .del(this._getRoomUsersUserKey(room, connectionId));
+
+        if (size === 1) {
+            multi = multi.del(this._getRoomStorageKey(room)).del(this._getRoomUsersKey(room));
+        }
+
+        await multi.exec();
+    }
+
+    public async deleteUsers(room: string): Promise<void> {
+        if (!this._initialized) return;
+
+        await this._initialized;
+
+        const members = await this._client.smembers(this._getRoomUsersKey(room));
+
+        await members
+            .reduce(
+                (commands, connectionId) => {
+                    return commands.del(this._getRoomUsersUserKey(room, connectionId));
+                },
+                this._client.multi().del(this._getRoomUsersKey(room)),
+            )
+            .exec();
+    }
+
+    public async getStorageState(room: string): Promise<string | null> {
+        if (!this._initialized) return null;
+
+        await this._initialized;
+
+        return await this._client.get(this._getRoomStorageKey(room));
+    }
+
+    public async setStorageState(room: string, state: string): Promise<void> {
+        if (!this._initialized) return;
+
+        await this._initialized;
+
+        await this._client.set(this._getRoomStorageKey(room), state);
+    }
+
+    public async getUser(room: string, connectionId: string): Promise<JsonObject | null> {
+        if (!this._initialized) return null;
+
+        await this._initialized;
+
+        const data = await this._client.get(this._getRoomUsersUserKey(room, connectionId));
+
+        return !data ? null : JSON.parse(data);
+    }
+
+    public async getUsers(
+        room: string,
+    ): Promise<Map<[connectionId: string][0], JsonObject | null>> {
+        if (!this._initialized) return new Map();
+
+        await this._initialized;
+
+        const members = await this._client.smembers(this._getRoomUsersKey(room));
+        const partitions = partitionByLength(members, GET_USERS_CONCURRENCY);
+
+        return await partitions.reduce(async (promise, partition) => {
+            const map = await promise;
+
+            const promises = partition.map(async (connectionId) => {
+                map.set(connectionId, await this.getUser(room, connectionId));
+            });
+
+            await Promise.all(promises);
+
+            return map;
+        }, Promise.resolve(new Map<string, JsonObject | null>()));
+    }
+
+    public async getUsersSize(room: string): Promise<number> {
+        if (!this._initialized) return 0;
+
+        await this._initialized;
+
+        return await this._client.scard(this._getRoomUsersKey(room));
+    }
+
+    public initialize(roomContext: {}): typeof this {
+        return new PersistenceRedis({
+            client: this._client,
+            ...{ _initialized: Promise.resolve(true as const) },
+        }) as typeof this;
+    }
+
+    private _getClusterKey(key: string): string {
+        return `${HASH_TAG}${key}`;
+    }
+
+    private _getRoomStorageKey(room: string): string {
+        return this._getClusterKey(`room_storage${DELIMITER}${room}`);
+    }
+
+    private _getRoomUsersKey(room: string): string {
+        return this._getClusterKey(`room_users${DELIMITER}${room}`);
+    }
+
+    private _getRoomUsersUserKey(room: string, connectionId: string): string {
+        return this._getClusterKey(`${this._getRoomUsersKey(room)}${DELIMITER}${connectionId}`);
+    }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export type { RedisClient } from "./PersistenceRedis";
+export { PersistenceRedis } from "./PersistenceRedis";

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { partitionByLength } from "./partitionByLength";

package/src/utils/partitionByLength.ts

@@ -0,0 +1,11 @@
+export const partitionByLength = <T>(
+    arr: readonly T[] | T[],
+    length: number,
+): readonly (readonly T[])[] => {
+    if (!arr.length) return [];
+
+    const head = arr.slice(0, length);
+    const tail = arr.slice(length);
+
+    return [head, ...partitionByLength(tail, length)];
+};