@pluv/persistence-redis 0.41.7 → 0.43.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/persistence-redis@0.41.7 build /home/runner/work/pluv/pluv/packages/persistence-redis
+> @pluv/persistence-redis@0.43.0 build /home/runner/work/pluv/pluv/packages/persistence-redis
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 4.38 KB
+ESM dist/index.mjs 4.81 KB
+ESM ⚡️ Build success in 60ms
+CJS dist/index.js 5.83 KB
 CJS ⚡️ Build success in 61ms
-ESM dist/index.mjs 3.37 KB
-ESM ⚡️ Build success in 61ms
 DTS Build start
-DTS ⚡️ Build success in 4719ms
-DTS dist/index.d.mts 1.09 KB
-DTS dist/index.d.ts  1.09 KB
+DTS ⚡️ Build success in 4934ms
+DTS dist/index.d.mts 1.17 KB
+DTS dist/index.d.ts  1.17 KB

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @pluv/persistence-redis
 
+## 0.43.0
+
+### Patch Changes
+
+- Updated dependencies [e60a677]
+- Updated dependencies [0063e80]
+- Updated dependencies [244a973]
+- Updated dependencies [4b0fbb3]
+  - @pluv/io@0.43.0
+  - @pluv/types@0.43.0
+
+## 0.42.0
+
+### Minor Changes
+
+- 4ce32ee: **BREAKING** `Persistence.getUsers` now returns a map of connection id strings to user JSON objects instead of an array of user JSON objects. This change is intended to be internal only and generally non-breaking.
+
+### Patch Changes
+
+- Updated dependencies [cf1529a]
+  - @pluv/io@0.42.0
+  - @pluv/types@0.42.0
+
 ## 0.41.7
 
 ### Patch Changes

package/dist/index.d.mts

@@ -8,6 +8,7 @@ interface PersistenceRedisOptions {
 }
 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>;
@@ -16,8 +17,9 @@ declare class PersistenceRedis extends AbstractPersistence {
     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<readonly (JsonObject | null)[]>;
+    getUsers(room: string): Promise<Map<[connectionId: string][0], JsonObject | null>>;
     getUsersSize(room: string): Promise<number>;
+    initialize(roomContext: {}): this;
     private _getClusterKey;
     private _getRoomStorageKey;
     private _getRoomUsersKey;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ interface PersistenceRedisOptions {
 }
 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>;
@@ -16,8 +17,9 @@ declare class PersistenceRedis extends AbstractPersistence {
     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<readonly (JsonObject | null)[]>;
+    getUsers(room: string): Promise<Map<[connectionId: string][0], JsonObject | null>>;
     getUsersSize(room: string): Promise<number>;
+    initialize(roomContext: {}): this;
     private _getClusterKey;
     private _getRoomStorageKey;
     private _getRoomUsersKey;

package/dist/index.js

@@ -46,26 +46,44 @@ 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 extends import_io.AbstractPersistence {
   constructor(options) {
     super();
+    this._initialized = null;
     const { client } = options;
     this._client = client;
   }
   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) {
@@ -76,6 +94,8 @@ var PersistenceRedis = class extends import_io.AbstractPersistence {
   }
   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) => {
@@ -87,31 +107,53 @@ var PersistenceRedis = class extends import_io.AbstractPersistence {
   }
   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));
-      return yield Promise.all(members.map((connectionId) => this.getUser(room, connectionId)));
+      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) {
+    this._initialized = Promise.resolve(true);
+    return this;
+  }
   _getClusterKey(key) {
     return `${HASH_TAG}${key}`;
   }

package/dist/index.mjs

@@ -21,26 +21,44 @@ var __async = (__this, __arguments, generator) => {
 
 // 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 extends AbstractPersistence {
   constructor(options) {
     super();
+    this._initialized = null;
     const { client } = options;
     this._client = client;
   }
   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) {
@@ -51,6 +69,8 @@ var PersistenceRedis = class extends AbstractPersistence {
   }
   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) => {
@@ -62,31 +82,53 @@ var PersistenceRedis = class extends AbstractPersistence {
   }
   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));
-      return yield Promise.all(members.map((connectionId) => this.getUser(room, connectionId)));
+      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) {
+    this._initialized = Promise.resolve(true);
+    return this;
+  }
   _getClusterKey(key) {
     return `${HASH_TAG}${key}`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/persistence-redis",
-  "version": "0.41.7",
+  "version": "0.43.0",
   "description": "@pluv/io crdt storage persistence for node.js",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,20 +17,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^22.14.1",
-    "@pluv/io": "^0.41.7",
-    "@pluv/types": "^0.41.7"
+    "@types/node": "^22.15.3",
+    "@pluv/io": "^0.43.0",
+    "@pluv/types": "^0.43.0"
   },
   "peerDependencies": {
     "ioredis": "^5.0.0"
   },
   "devDependencies": {
-    "eslint": "^9.25.0",
+    "eslint": "^9.25.1",
     "ioredis": "^5.6.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^0.41.7",
-    "eslint-config-pluv": "^0.41.7"
+    "@pluv/tsconfig": "^0.43.0",
+    "eslint-config-pluv": "^0.43.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/PersistenceRedis.ts

@@ -1,10 +1,13 @@
 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 {
@@ -13,6 +16,7 @@ export interface PersistenceRedisOptions {
 
 export class PersistenceRedis extends AbstractPersistence {
     private _client: RedisClient;
+    private _initialized: Promise<true> | null = null;
 
     constructor(options: PersistenceRedisOptions) {
         super();
@@ -23,6 +27,10 @@ export class PersistenceRedis extends AbstractPersistence {
     }
 
     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)
@@ -31,10 +39,18 @@ export class PersistenceRedis extends AbstractPersistence {
     }
 
     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
@@ -50,6 +66,10 @@ export class PersistenceRedis extends AbstractPersistence {
     }
 
     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
@@ -63,29 +83,66 @@ export class PersistenceRedis extends AbstractPersistence {
     }
 
     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<readonly (JsonObject | null)[]> {
+    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));
+            });
 
-        return await Promise.all(members.map((connectionId) => 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: {}): this {
+        this._initialized = Promise.resolve(true as const);
+
+        return this;
+    }
+
     private _getClusterKey(key: string): string {
         return `${HASH_TAG}${key}`;
     }

package/src/utils/index.ts

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

package/src/utils/partitionByLength.ts

@@ -0,0 +1,8 @@
+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)];
+};