@pluv/io 2.1.0 → 2.2.1

package/dist/index.mjs

@@ -613,6 +613,7 @@ var IORoom = class {
             this._listeners.onUserDisconnected({
               context: this._context,
               encodedState,
+              platform: this._platform,
               room: this.id,
               user
             })
@@ -670,6 +671,7 @@ var IORoom = class {
           this._listeners.onUserConnected({
             context: this._context,
             encodedState,
+            platform: this._platform,
             room: this.id,
             user,
             webSocket: pluvWs.webSocket
@@ -833,6 +835,7 @@ var IORoom = class {
           this._listeners.onDestroy(__spreadProps(__spreadValues({}, "_meta" in this._platform && !!this._platform._meta ? { _meta: this._platform._meta } : {}), {
             context: this._context,
             encodedState,
+            platform: this._platform,
             room: this.id
           }))
         );
@@ -871,6 +874,7 @@ var IORoom = class {
         garbageCollect: () => __async(this, null, function* () {
           yield this.garbageCollect();
         }),
+        platform: this._platform,
         get presence() {
           return session.presence;
         },
@@ -897,6 +901,7 @@ var IORoom = class {
         context: this._context,
         encodedState: doc.getEncodedState(),
         message,
+        platform: this._platform,
         room: this.id,
         user: session.user,
         webSocket: session.webSocket.webSocket
@@ -1063,6 +1068,7 @@ var IORoom = class {
         garbageCollect: () => __async(this, null, function* () {
           yield this.garbageCollect();
         }),
+        platform: this._platform,
         get presence() {
           return null;
         },
@@ -1114,14 +1120,56 @@ var pickBy = (obj, by) => {
 };
 
 // src/version.generated.ts
-var version = "2.1.0";
+var version = "2.2.1";
 
 // src/PluvServer.ts
 var PluvServer = class {
   constructor(options) {
     this.version = version;
-    this._authorize = null;
-    this._baseRouter = new PluvRouter({
+    this._config = __spreadValues({
+      crdt: noop2,
+      debug: false,
+      router: new PluvRouter({})
+    }, options);
+    const {
+      onRoomDeleted,
+      onRoomMessage,
+      onStorageUpdated,
+      onUserConnected,
+      onUserDisconnected
+    } = options;
+    this._listeners = {
+      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
+      onRoomMessage: (event) => onRoomMessage == null ? void 0 : onRoomMessage(event),
+      onStorageUpdated: (event) => onStorageUpdated == null ? void 0 : onStorageUpdated(event),
+      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
+      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
+    };
+  }
+  get fetch() {
+    const platform = this._config.platform();
+    return (...args) => {
+      if (!platform._fetch)
+        throw new Error(`\`${platform._name}\` does not support \`fetch\``);
+      return platform._fetch(...args);
+    };
+  }
+  /**
+   * @ignore
+   * @readonly
+   * @deprecated Internal use only. Changes to this will never be marked as breaking.
+   */
+  get _defs() {
+    return {
+      authorize: this._config.authorize,
+      context: this._config.context,
+      events: this._router._defs.events,
+      platform: this._config.platform()
+    };
+  }
+  get _baseRouter() {
+    const listeners = this._getListeners();
+    return new PluvRouter({
       $getOthers: this._procedure.sync((data, { room, session, sessions }) => {
         const currentTime = Date.now();
         const others = sessions.filter((wsSession) => {
@@ -1156,46 +1204,54 @@ var PluvServer = class {
             timers: { presence: timers.presence }
           }
         };
-      }).self((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, room, session }) {
-        var _a;
-        const oldState = yield this._platform.persistence.getStorageState(room);
+      }).self((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, platform, room, session }) {
+        var _a, _b;
+        const oldState = yield platform.persistence.getStorageState(room);
         const update = data == null ? void 0 : data.update;
         if (!oldState) {
-          const loadedState = yield (_a = this._getInitialStorage) == null ? void 0 : _a.call(this, { context, room });
+          const loadedState = yield (_b = (_a = this._config).getInitialStorage) == null ? void 0 : _b.call(_a, {
+            context,
+            room
+          });
           if (!!loadedState) {
             doc.applyEncodedState({ update: loadedState }).getEncodedState();
           }
         }
         if (!doc.isEmpty()) {
           const encodedState2 = doc.getEncodedState();
-          return { $storageReceived: { changeKind: "unchanged", state: encodedState2 } };
+          return {
+            $storageReceived: { changeKind: "unchanged", state: encodedState2 }
+          };
         }
         if (!!update) {
           const encodedState2 = doc.applyEncodedState({ update }).getEncodedState();
           const storageSize = new TextEncoder().encode(encodedState2).length;
-          if (!!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize) {
+          if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
             throw new Error("Storage has exceeded the size limit");
           }
-          yield this._platform.persistence.setStorageState(room, encodedState2).catch((error) => {
+          yield platform.persistence.setStorageState(room, encodedState2).catch((error) => {
             this._logDebug(error);
           });
-          this._getListeners().onStorageUpdated({
+          listeners.onStorageUpdated({
             context,
             encodedState: encodedState2,
+            platform,
             room,
             user: session == null ? void 0 : session.user,
             webSocket: session == null ? void 0 : session.webSocket.webSocket
           });
-          return { $storageReceived: { changeKind: "initialized", state: encodedState2 } };
+          return {
+            $storageReceived: { changeKind: "initialized", state: encodedState2 }
+          };
         }
         const encodedState = doc.getEncodedState();
         return { $storageReceived: { changeKind: "empty", state: encodedState } };
       })),
-      $ping: this._procedure.self((data, { session }) => {
+      $ping: this._procedure.self((data, { platform, session }) => {
         if (!session) return {};
         const currentTime = (/* @__PURE__ */ new Date()).getTime();
         const prevState = session.webSocket.state;
-        this._platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
+        platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
           timers: __spreadProps(__spreadValues({}, prevState.timers), {
             ping: currentTime
           })
@@ -1206,10 +1262,13 @@ var PluvServer = class {
         const presence = data == null ? void 0 : data.presence;
         const { session } = context;
         if (!session) return {};
-        const cleanedPatch = pickBy(presence != null ? presence : {}, (value) => typeof value !== "undefined");
+        const cleanedPatch = pickBy(
+          presence != null ? presence : {},
+          (value) => typeof value !== "undefined"
+        );
         const updated = Object.assign(/* @__PURE__ */ Object.create(null), session.presence, cleanedPatch);
         const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
-        if (!!this._limits.presenceMaxSize && bytes > this._limits.presenceMaxSize) {
+        if (!!this._config.limits.presenceMaxSize && bytes > this._config.limits.presenceMaxSize) {
           throw new Error(
             `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
           );
@@ -1222,7 +1281,7 @@ var PluvServer = class {
           }
         };
       }),
-      $updateStorage: this._procedure.broadcast((data, { context, doc, room }) => {
+      $updateStorage: this._procedure.broadcast((data, { context, doc, platform, room }) => {
         var _a;
         const origin = data == null ? void 0 : data.origin;
         const update = (_a = data == null ? void 0 : data.update) != null ? _a : null;
@@ -1230,113 +1289,72 @@ var PluvServer = class {
         const updated = update === null ? doc : doc.applyEncodedState({ update });
         const encodedState = updated.getEncodedState();
         const storageSize = new TextEncoder().encode(encodedState).length;
-        if (!!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize) {
+        if (!!this._config.limits.storageMaxSize && storageSize > this._config.limits.storageMaxSize) {
           throw new Error("Storage has exceeded the size limit");
         }
-        this._platform.persistence.setStorageState(room, encodedState).then(() => {
-          this._getListeners().onStorageUpdated({
+        platform.persistence.setStorageState(room, encodedState).then(() => {
+          listeners.onStorageUpdated({
             context,
             encodedState,
+            platform,
             room
           });
         });
         return { $storageUpdated: { state: encodedState } };
       })
     });
-    this._context = {};
-    this._getInitialStorage = null;
-    const {
-      authorize: authorize2,
-      context,
-      crdt = noop2,
-      debug = false,
-      getInitialStorage,
-      io,
-      limits,
-      platform,
-      router = new PluvRouter({})
-    } = options;
-    const {
-      onRoomDeleted,
-      onRoomMessage,
-      onStorageUpdated,
-      onUserConnected,
-      onUserDisconnected
-    } = options;
-    platform.validateConfig(options);
-    this._crdt = crdt;
-    this._debug = debug;
-    this._io = io;
-    this._limits = limits;
-    this._platform = platform;
-    this._router = router ? PluvRouter.merge(this._baseRouter, router) : this._baseRouter;
-    if (authorize2) this._authorize = authorize2;
-    if (context) this._context = context;
-    if (getInitialStorage) this._getInitialStorage = getInitialStorage;
-    this._listeners = {
-      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
-      onRoomMessage: (event) => onRoomMessage == null ? void 0 : onRoomMessage(event),
-      onStorageUpdated: (event) => onStorageUpdated == null ? void 0 : onStorageUpdated(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
-  }
-  get fetch() {
-    return (...args) => {
-      if (!this._platform._fetch)
-        throw new Error(`\`${this._platform._name}\` does not support \`fetch\``);
-      return this._platform._fetch(...args);
-    };
-  }
-  /**
-   * @ignore
-   * @readonly
-   * @deprecated Internal use only. Changes to this will never be marked as breaking.
-   */
-  get _defs() {
-    return {
-      authorize: this._authorize,
-      context: this._context,
-      events: this._router._defs.events,
-      platform: this._platform
-    };
   }
   get _procedure() {
     return new PluvProcedure();
   }
+  get _router() {
+    return this._config.router ? PluvRouter.merge(this._baseRouter, this._config.router) : this._baseRouter;
+  }
   createRoom(room, ...options) {
     var _a, _c;
     const _b = (_a = options[0]) != null ? _a : {}, { _meta, debug, onDestroy, onMessage } = _b, platformRoomContext = __objRest(_b, ["_meta", "debug", "onDestroy", "onMessage"]);
-    if (this._platform._config.handleMode !== "io") {
-      throw new Error(`\`createRoom\` is unsupported for \`${this._platform._name}\``);
+    const platform = this._config.platform();
+    platform.validateConfig(this._config);
+    if (platform._config.handleMode !== "io") {
+      throw new Error(`\`createRoom\` is unsupported for \`${platform._name}\``);
     }
     if (!/^[a-z0-9](?:[a-z0-9-_]*[a-z0-9])?$/i.test(room))
       throw new Error("Unsupported room name");
     const roomContext = platformRoomContext;
-    const context = typeof this._context === "function" ? this._context(roomContext) : this._context;
+    const context = typeof this._config.context === "function" ? this._config.context(roomContext) : this._config.context;
+    const listeners = this._getListeners();
+    const logDebug = this._logDebug.bind(this);
     const newRoom = new IORoom(room, __spreadProps(__spreadValues({}, !!_meta ? { _meta } : {}), {
-      authorize: (_c = this._authorize) != null ? _c : void 0,
+      authorize: (_c = this._config.authorize) != null ? _c : void 0,
       context,
-      crdt: this._crdt,
-      debug: debug != null ? debug : this._debug,
-      onDestroy: (event) => __async(this, null, function* () {
-        this._logDebug(`${colors2.blue("Deleting empty room:")} ${room}`);
-        yield Promise.resolve(onDestroy == null ? void 0 : onDestroy(event));
-        yield Promise.resolve(this._getListeners().onRoomDeleted(event));
-        yield this._platform.persistence.deleteStorageState(room);
-        this._logDebug(`${colors2.blue("Deleted room:")} ${room}`);
-      }),
-      onMessage: (event) => __async(this, null, function* () {
-        yield Promise.resolve(onMessage == null ? void 0 : onMessage(event));
-        yield Promise.resolve(this._getListeners().onRoomMessage(event));
-      }),
-      onUserConnected: (event) => __async(this, null, function* () {
-        yield Promise.resolve(this._getListeners().onUserConnected(event));
-      }),
-      onUserDisconnected: (event) => __async(this, null, function* () {
-        yield Promise.resolve(this._getListeners().onUserDisconnected(event));
-      }),
-      platform: this._platform,
+      crdt: this._config.crdt,
+      debug: debug != null ? debug : this._config.debug,
+      onDestroy(event) {
+        return __async(this, null, function* () {
+          logDebug(`${colors2.blue("Deleting empty room:")} ${room}`);
+          yield Promise.resolve(onDestroy == null ? void 0 : onDestroy(event));
+          yield Promise.resolve(listeners.onRoomDeleted(event));
+          yield event.platform.persistence.deleteStorageState(room);
+          logDebug(`${colors2.blue("Deleted room:")} ${room}`);
+        });
+      },
+      onMessage(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(onMessage == null ? void 0 : onMessage(event));
+          yield Promise.resolve(listeners.onRoomMessage(event));
+        });
+      },
+      onUserConnected(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(listeners.onUserConnected(event));
+        });
+      },
+      onUserDisconnected(event) {
+        return __async(this, null, function* () {
+          yield Promise.resolve(listeners.onUserDisconnected(event));
+        });
+      },
+      platform,
       roomContext,
       router: this._router
     }));
@@ -1345,14 +1363,14 @@ var PluvServer = class {
   }
   createToken(params) {
     return __async(this, null, function* () {
-      return yield this._io.createToken(params);
+      return yield this._config.io.createToken(params);
     });
   }
   _getListeners() {
     return this._listeners;
   }
   _logDebug(...data) {
-    if (this._debug) console.log(...data);
+    if (this._config.debug) console.log(...data);
   }
 };
 
@@ -1397,10 +1415,13 @@ var PluvIO = class {
           `createToken called with large payload. User must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
         );
       }
-      if (this._platform._createToken) return yield this._platform._createToken(params);
+      const platform = this._platform();
+      if (platform._createToken) {
+        return yield platform._createToken(__spreadProps(__spreadValues({}, params), { authorize: ioAuthorize }));
+      }
       const secret = (_a = ioAuthorize == null ? void 0 : ioAuthorize.secret) != null ? _a : null;
       if (!secret) throw new Error("`authorize` was specified without a valid secret");
-      return yield authorize({ platform: this._platform, secret }).encode(
+      return yield authorize({ platform, secret }).encode(
         params
       );
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/io",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "@pluv/io server-side websocket manager",
   "author": "leedavidcs",
   "license": "MIT",
@@ -21,16 +21,16 @@
     "jose": "^5.10.0",
     "kleur": "^4.1.5",
     "wonka": "^6.3.5",
-    "@pluv/crdt": "^2.1.0",
-    "@pluv/types": "^2.1.0"
+    "@pluv/crdt": "^2.2.1",
+    "@pluv/types": "^2.2.1"
   },
   "devDependencies": {
     "eslint": "^9.26.0",
     "genversion": "^3.2.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^2.1.0",
-    "eslint-config-pluv": "^2.1.0"
+    "@pluv/tsconfig": "^2.2.1",
+    "eslint-config-pluv": "^2.2.1"
   },
   "scripts": {
     "build": "pnpm run version && tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractPlatform.ts

@@ -1,10 +1,11 @@
+import type { Maybe } from "@pluv/types";
 import type { AbstractPersistence } from "./AbstractPersistence";
 import type { AbstractPubSub } from "./AbstractPubSub";
 import type { AbstractWebSocket, InferWebSocketSource } from "./AbstractWebSocket";
 import type { JWTEncodeParams } from "./authorize";
 import { Persistence } from "./Persistence";
 import { PubSub } from "./PubSub";
-import type { PlatformConfig, WebSocketSerializedState } from "./types";
+import type { PlatformConfig, ResolvedPluvIOAuthorize, WebSocketSerializedState } from "./types";
 
 export type InferPlatformWebSocketType<TPlatform extends AbstractPlatform> =
     TPlatform extends AbstractPlatform<infer IAbstractWebSocket> ? IAbstractWebSocket : never;
@@ -44,7 +45,11 @@ export abstract class AbstractPlatform<
     public persistence: AbstractPersistence;
     public pubSub: AbstractPubSub;
 
-    public readonly _createToken?: (params: JWTEncodeParams<any, any>) => Promise<string>;
+    public readonly _createToken?: (
+        params: JWTEncodeParams<any, any> & {
+            authorize: Maybe<ResolvedPluvIOAuthorize<any, any>>;
+        },
+    ) => Promise<string>;
     public _fetch?: (...args: any[]) => Promise<any>;
     public abstract readonly _config: TConfig;
     public abstract readonly _name: string;

package/src/IORoom.ts

@@ -60,7 +60,7 @@ export interface IORoomListeners<
     TContext extends Record<string, any>,
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
 > {
-    onDestroy: (event: IORoomListenerEvent<TContext>) => void;
+    onDestroy: (event: IORoomListenerEvent<TPlatform, TContext>) => void;
     onMessage: (event: IORoomMessageEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
     onUserConnected: (event: IOUserConnectedEvent<TPlatform, TAuthorize, TContext>) => void;
     onUserDisconnected: (event: IOUserDisconnectedEvent<TPlatform, TAuthorize, TContext>) => void;
@@ -87,7 +87,7 @@ export type IORoomConfig<
 > = Partial<IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
     authorize?: TAuthorize;
     context: TContext;
-    crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any, any> };
     debug: boolean;
     platform: TPlatform;
     roomContext: InferRoomContextType<TPlatform>;
@@ -124,14 +124,14 @@ export class IORoom<
 {
     public readonly id: string;
 
-    private _doc: Promise<CrdtDocLike<any>>;
+    private _doc: Promise<CrdtDocLike<any, any>>;
     private _lastGarbageCollectMs: number = -1 * (GARBAGE_COLLECT_INTERVAL_MS + 1);
     private _uninitialize: Promise<() => Promise<void>> | null = null;
 
     private readonly _authorize: TAuthorize = null as TAuthorize;
     private readonly _context: TContext;
     private readonly _debug: boolean;
-    private readonly _docFactory: AbstractCrdtDocFactory<any>;
+    private readonly _docFactory: AbstractCrdtDocFactory<any, any>;
     private readonly _listeners: IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>;
     private readonly _platform: TPlatform;
     private readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
@@ -472,6 +472,7 @@ export class IORoom<
                     this._listeners.onUserDisconnected({
                         context: this._context,
                         encodedState,
+                        platform: this._platform,
                         room: this.id,
                         user,
                     }),
@@ -538,6 +539,7 @@ export class IORoom<
                 this._listeners.onUserConnected({
                     context: this._context,
                     encodedState,
+                    platform: this._platform,
                     room: this.id,
                     user,
                     webSocket: pluvWs.webSocket,
@@ -626,7 +628,7 @@ export class IORoom<
         }
     }
 
-    private async _getInitialDoc(): Promise<CrdtDocLike<any>> {
+    private async _getInitialDoc(): Promise<CrdtDocLike<any, any>> {
         const doc = this._docFactory.getEmpty();
         const encodedState = await this._platform.persistence.getStorageState(this.id);
 
@@ -769,6 +771,7 @@ export class IORoom<
                             : {}),
                         context: this._context,
                         encodedState,
+                        platform: this._platform,
                         room: this.id,
                     }),
                 );
@@ -825,6 +828,7 @@ export class IORoom<
                 garbageCollect: async () => {
                     await this.garbageCollect();
                 },
+                platform: this._platform,
                 get presence() {
                     return session.presence as JsonObject | null;
                 },
@@ -864,6 +868,7 @@ export class IORoom<
                     InferEventsOutput<TEvents>,
                     keyof InferEventsOutput<TEvents>
                 >,
+                platform: this._platform,
                 room: this.id,
                 user: session.user,
                 webSocket: session.webSocket.webSocket,
@@ -1105,6 +1110,7 @@ export class IORoom<
             garbageCollect: async () => {
                 await this.garbageCollect();
             },
+            platform: this._platform,
             get presence() {
                 return null;
             },

package/src/PluvIO.ts

@@ -37,7 +37,7 @@ export type PluvIOConfig<
     crdt?: CrdtLibraryType;
     debug?: boolean;
     limits?: PluvIOLimits;
-    platform: TPlatform;
+    platform: () => TPlatform;
 };
 
 type ResolvedServerConfig<
@@ -90,10 +90,10 @@ export class PluvIO<
         TPlatform,
         TContext
     >;
-    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any, any> };
     private readonly _debug: boolean;
     private readonly _limits: PluvIOLimits;
-    private readonly _platform: TPlatform;
+    private readonly _platform: () => TPlatform;
 
     public get procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
         return new PluvProcedure();
@@ -141,19 +141,23 @@ export class PluvIO<
             );
         }
 
+        const platform = this._platform();
+
         /**
          * !HACK
          * @description Allow the platform to overwrite this behavior as needed. This is introduced
          * to support platformPluv
          * @date December 15, 2024
          */
-        if (this._platform._createToken) return await this._platform._createToken(params as any);
+        if (platform._createToken) {
+            return await platform._createToken({ ...params, authorize: ioAuthorize });
+        }
 
         const secret = ioAuthorize?.secret ?? null;
 
         if (!secret) throw new Error("`authorize` was specified without a valid secret");
 
-        return await authorize({ platform: this._platform, secret }).encode(
+        return await authorize({ platform, secret }).encode(
             params as JWTEncodeParams<any, TPlatform>,
         );
     }