@pluv/io 0.22.0 → 0.24.0

package/src/PluvIO.ts

@@ -1,14 +1,6 @@
 import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import { noop } from "@pluv/crdt";
-import type {
-    BaseIOAuthorize,
-    IOAuthorize,
-    IOLike,
-    InferIOAuthorize,
-    InferIOAuthorizeUser,
-    JsonObject,
-    Maybe,
-} from "@pluv/types";
+import type { BaseIOAuthorize, IOAuthorize, InferIOAuthorizeUser, JsonObject } from "@pluv/types";
 import type { AbstractPlatform, InferPlatformContextType, WebSocketRegistrationMode } from "./AbstractPlatform";
 import { PluvProcedure } from "./PluvProcedure";
 import type { MergedRouter, PluvRouterEventConfig } from "./PluvRouter";
@@ -16,7 +8,6 @@ import { PluvRouter } from "./PluvRouter";
 import { PluvServer } from "./PluvServer";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
-import { PING_TIMEOUT_MS } from "./constants";
 import type { GetInitialStorageFn, PluvIOListeners } from "./types";
 import { __PLUV_VERSION } from "./version";
 
@@ -24,187 +15,43 @@ export type PluvIOConfig<
     TPlatform extends AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
     TContext extends JsonObject,
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = {
     authorize?: TAuthorize;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
-    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
-export interface ServerConfig<
+export type ServerConfig<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> {
+> = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-}
+};
 
 export class PluvIO<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
-> implements IOLike<TAuthorize, {}>
-{
-    private _router: PluvRouter<TPlatform, TAuthorize, TContext, {}> = new PluvRouter({
-        $GET_OTHERS: this.procedure.sync((data, { room, session, sessions }) => {
-            const currentTime = new Date().getTime();
-
-            const others = sessions
-                .filter((wsSession) => {
-                    if (wsSession.id === session?.id) return false;
-                    if (wsSession.quit) return false;
-                    if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
-
-                    return true;
-                })
-                .reduce<{
-                    [connectionId: string]: {
-                        connectionId: string;
-                        room: string | null;
-                        user: JsonObject;
-                    };
-                }>(
-                    (acc, { id, presence, user }) => ({
-                        ...acc,
-                        [id]: {
-                            connectionId: id,
-                            presence,
-                            room,
-                            user,
-                        },
-                    }),
-                    {},
-                );
-
-            return { $OTHERS_RECEIVED: { others } };
-        }),
-        $INITIALIZE_SESSION: this.procedure
-            .broadcast((data, { session }) => {
-                const presence = (data as any)?.presence;
-
-                if (!session) return {};
-
-                session.presence = presence;
-
-                return {
-                    $USER_JOINED: {
-                        connectionId: session.id,
-                        user: session.user,
-                        presence,
-                    },
-                };
-            })
-            .self(async (data, { context, doc, room }) => {
-                const oldState = await this._platform.persistance.getStorageState(room);
-                const update = (data as any)?.update as Maybe<string>;
-
-                const updates: readonly Maybe<string>[] = [
-                    oldState
-                        ? null
-                        : await this._getInitialStorage?.({
-                              ...context,
-                              room,
-                          }),
-                    update,
-                ];
-
-                if (updates.some((_update) => !!_update)) {
-                    const encodedState = doc.batchApplyEncodedState(updates).getEncodedState();
-
-                    await this._platform.persistance.setStorageState(room, encodedState);
-
-                    this._listeners.onStorageUpdated({ ...context, encodedState, room });
-                }
-
-                const state = (await this._platform.persistance.getStorageState(room)) ?? doc.getEncodedState();
-
-                return { $STORAGE_RECEIVED: { state } };
-            }),
-        $PING: this.procedure.self((data, { session }) => {
-            if (!session) return {};
-
-            const currentTime = new Date().getTime();
-            const prevState = session.webSocket.state;
-
-            session.webSocket.state = {
-                ...prevState,
-                timers: {
-                    ...prevState.timers,
-                    ping: currentTime,
-                },
-            };
-
-            return { $PONG: {} };
-        }),
-        $UPDATE_PRESENCE: this.procedure.broadcast((data, { session }) => {
-            const presence = (data as any)?.presence;
-
-            if (!session) return {};
-
-            const updated = Object.assign(Object.create(null), session.presence, presence);
-
-            session.webSocket.presence = updated;
-
-            return { $PRESENCE_UPDATED: { presence: updated } };
-        }),
-        $UPDATE_STORAGE: this.procedure.broadcast((data, { context, doc, room }) => {
-            const origin = (data as any)?.origin as Maybe<string>;
-            const update: string | null = (data as any)?.update ?? null;
-
-            if (origin === "$INITIALIZED" && Object.keys(doc.toJson()).length) {
-                return {};
-            }
-
-            const updated = update === null ? doc : doc.applyEncodedState({ update });
-            const encodedState = updated.getEncodedState();
-
-            this._platform.persistance.setStorageState(room, encodedState).then(() => {
-                this._listeners.onStorageUpdated({
-                    ...context,
-                    encodedState,
-                    room,
-                });
-            });
-
-            return { $STORAGE_UPDATED: { state: encodedState } };
-        }),
-    });
-
-    readonly _authorize: TAuthorize | null = null;
-    readonly _context: TContext = {} as TContext;
-    readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
-    readonly _debug: boolean;
-    readonly _getInitialStorage: GetInitialStorageFn<TPlatform> | null = null;
-    readonly _listeners: PluvIOListeners<TPlatform>;
-    readonly _platform: TPlatform;
-    readonly _version: string = __PLUV_VERSION as any;
-
-    public get _events() {
-        return this._router._events;
-    }
+> {
+    public readonly version: string = __PLUV_VERSION as any;
+    public readonly _authorize: TAuthorize | null = null;
 
-    public get _registrationMode(): WebSocketRegistrationMode {
-        return this._platform._registrationMode;
-    }
+    private readonly _context: TContext = {} as TContext;
+    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    private readonly _debug: boolean;
+    private readonly _platform: TPlatform;
 
     public get procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
         return new PluvProcedure();
     }
 
     constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext>) {
-        const {
-            authorize,
-            context,
-            crdt = noop,
-            debug = false,
-            getInitialStorage,
-            onRoomDeleted,
-            onStorageUpdated,
-            platform,
-        } = options;
+        const { authorize, context, crdt = noop, debug = false, platform } = options;
 
         this._crdt = crdt;
         this._debug = debug;
@@ -212,17 +59,9 @@ export class PluvIO<
 
         if (authorize) this._authorize = authorize;
         if (context) this._context = context;
-        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
-
-        this._listeners = {
-            onRoomDeleted: (event) => onRoomDeleted?.(event),
-            onStorageUpdated: (event) => onStorageUpdated?.(event),
-        };
     }
 
-    public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
-    ): Promise<string> {
+    public async createToken(params: JWTEncodeParams<InferIOAuthorizeUser<TAuthorize>, TPlatform>): Promise<string> {
         if (!this._authorize) throw new Error("IO does not specify authorize during initialization.");
 
         const ioAuthorize =
@@ -251,21 +90,13 @@ export class PluvIO<
     public server<TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>>(
         config: ServerConfig<TPlatform, TAuthorize, TContext, TEvents> = {},
     ): PluvServer<TPlatform, TAuthorize, TContext, TEvents> {
-        const router = (config.router ? this.mergeRouters(this._router, config.router) : this._router) as PluvRouter<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TEvents
-        >;
-
         return new PluvServer<TPlatform, TAuthorize, TContext, TEvents>({
-            ...this._listeners,
+            ...config,
             authorize: this._authorize ?? undefined,
             context: this._context,
             crdt: this._crdt,
             debug: this._debug,
             platform: this._platform,
-            router,
         });
     }
 }

package/src/PluvRouter.ts

@@ -6,9 +6,7 @@ export type PluvRouterEventConfig<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
-> = {
-    [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config">;
-};
+> = { [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config"> };
 
 export type MergedRouter<
     TRouters extends PluvRouter<TPlatform, TAuthorize, TContext, any>[] = [],

package/src/PluvServer.ts

@@ -8,6 +8,7 @@ import type {
     InferIOAuthorize,
     InferIOAuthorizeUser,
     JsonObject,
+    Maybe,
 } from "@pluv/types";
 import colors from "kleur";
 import type {
@@ -16,12 +17,15 @@ import type {
     InferRoomContextType,
     WebSocketRegistrationMode,
 } from "./AbstractPlatform";
+import type { IORoomListeners } from "./IORoom";
 import { IORoom } from "./IORoom";
+import { PluvProcedure } from "./PluvProcedure";
 import type { PluvRouterEventConfig } from "./PluvRouter";
 import { PluvRouter } from "./PluvRouter";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
-import type { IORoomListenerEvent, PluvIOListeners } from "./types";
+import { PING_TIMEOUT_MS } from "./constants";
+import type { GetInitialStorageFn, PluvIOListeners } from "./types";
 import { __PLUV_VERSION } from "./version";
 
 export type InferIORoom<TServer extends PluvServer<any, any, any, any>> =
@@ -34,18 +38,33 @@ export type PluvServerConfig<
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
     authorize?: TAuthorize;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 };
 
-export type GetRoomOptions<TPlatform extends AbstractPlatform> = keyof InferRoomContextType<TPlatform> extends never
-    ? [{ debug?: boolean }] | []
-    : [Id<{ debug?: boolean } & InferRoomContextType<TPlatform>>];
+type BaseCreateRoomOptions<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = Partial<IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
+    debug?: boolean;
+};
+
+export type CreateRoomOptions<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = keyof InferRoomContextType<TPlatform> extends never
+    ? [BaseCreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents>] | []
+    : [Id<BaseCreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents> & InferRoomContextType<TPlatform>>];
 
 export class PluvServer<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
@@ -54,16 +73,134 @@ export class PluvServer<
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
 > implements IORouterLike<TEvents>
 {
-    private _rooms = new Map<string, IORoom<TPlatform, TAuthorize, TContext, TEvents>>();
+    public _listeners: PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>;
+
+    public readonly version: string = __PLUV_VERSION as any;
+    public readonly _authorize: TAuthorize | null = null;
+
+    private readonly _baseRouter: PluvRouter<TPlatform, TAuthorize, TContext, {}> = new PluvRouter({
+        $GET_OTHERS: this._procedure.sync((data, { room, session, sessions }) => {
+            const currentTime = new Date().getTime();
+
+            const others = sessions
+                .filter((wsSession) => {
+                    if (wsSession.id === session?.id) return false;
+                    if (wsSession.quit) return false;
+                    if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
+
+                    return true;
+                })
+                .reduce<{
+                    [connectionId: string]: {
+                        connectionId: string;
+                        room: string | null;
+                        user: JsonObject;
+                    };
+                }>(
+                    (acc, { id, presence, user }) => ({
+                        ...acc,
+                        [id]: {
+                            connectionId: id,
+                            presence,
+                            room,
+                            user,
+                        },
+                    }),
+                    {},
+                );
+
+            return { $OTHERS_RECEIVED: { others } };
+        }),
+        $INITIALIZE_SESSION: this._procedure
+            .broadcast((data, { session }) => {
+                const presence = (data as any)?.presence;
+
+                if (!session) return {};
+
+                session.presence = presence;
+
+                return {
+                    $USER_JOINED: {
+                        connectionId: session.id,
+                        user: session.user,
+                        presence,
+                    },
+                };
+            })
+            .self(async (data, { context, doc, room }) => {
+                const oldState = await this._platform.persistance.getStorageState(room);
+                const update = (data as any)?.update as Maybe<string>;
+
+                const updates: readonly Maybe<string>[] = [
+                    oldState ? null : await this._getInitialStorage?.({ ...context, room }),
+                    update,
+                ];
+
+                if (updates.some((_update) => !!_update)) {
+                    const encodedState = doc.batchApplyEncodedState(updates).getEncodedState();
+
+                    await this._platform.persistance.setStorageState(room, encodedState);
+
+                    this._listeners.onStorageUpdated({ context, encodedState, room });
+                }
+
+                const state = (await this._platform.persistance.getStorageState(room)) ?? doc.getEncodedState();
+
+                return { $STORAGE_RECEIVED: { state } };
+            }),
+        $PING: this._procedure.self((data, { session }) => {
+            if (!session) return {};
+
+            const currentTime = new Date().getTime();
+            const prevState = session.webSocket.state;
+
+            session.webSocket.state = {
+                ...prevState,
+                timers: {
+                    ...prevState.timers,
+                    ping: currentTime,
+                },
+            };
+
+            return { $PONG: {} };
+        }),
+        $UPDATE_PRESENCE: this._procedure.broadcast((data, { session }) => {
+            const presence = (data as any)?.presence;
 
-    readonly _authorize: TAuthorize | null = null;
-    readonly _context: TContext = {} as TContext;
-    readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
-    readonly _debug: boolean;
-    readonly _listeners: PluvIOListeners<TPlatform>;
-    readonly _platform: TPlatform;
-    readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-    readonly _version: string = __PLUV_VERSION as any;
+            if (!session) return {};
+
+            const updated = Object.assign(Object.create(null), session.presence, presence);
+
+            session.webSocket.presence = updated;
+
+            return { $PRESENCE_UPDATED: { presence: updated } };
+        }),
+        $UPDATE_STORAGE: this._procedure.broadcast((data, { context, doc, room }) => {
+            const origin = (data as any)?.origin as Maybe<string>;
+            const update: string | null = (data as any)?.update ?? null;
+
+            if (origin === "$INITIALIZED" && Object.keys(doc.toJson()).length) return {};
+
+            const updated = update === null ? doc : doc.applyEncodedState({ update });
+            const encodedState = updated.getEncodedState();
+
+            this._platform.persistance.setStorageState(room, encodedState).then(() => {
+                this._listeners.onStorageUpdated({
+                    context,
+                    encodedState,
+                    room,
+                });
+            });
+
+            return { $STORAGE_UPDATED: { state: encodedState } };
+        }),
+    });
+    private readonly _context: TContext = {} as TContext;
+    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    private readonly _debug: boolean;
+    private readonly _getInitialStorage: GetInitialStorageFn<TPlatform> | null = null;
+    private readonly _platform: TPlatform;
+    private readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 
     public get _events() {
         return this._router._events;
@@ -73,13 +210,19 @@ export class PluvServer<
         return this._platform._registrationMode;
     }
 
+    private get _procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
+        return new PluvProcedure();
+    }
+
     constructor(options: PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>) {
         const {
             authorize,
             context,
             crdt = noop,
             debug = false,
+            getInitialStorage,
             onRoomDeleted,
+            onRoomMessage,
             onStorageUpdated,
             platform,
             router = new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>({} as TEvents),
@@ -88,52 +231,34 @@ export class PluvServer<
         this._crdt = crdt;
         this._debug = debug;
         this._platform = platform;
-        this._router = router ?? null;
+        this._router = (router ? this._baseRouter : PluvRouter.merge(this._baseRouter, router)) as PluvRouter<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TEvents
+        >;
 
         if (authorize) this._authorize = authorize;
         if (context) this._context = context;
+        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
 
         this._listeners = {
             onRoomDeleted: (event) => onRoomDeleted?.(event),
+            onRoomMessage: (event) => onRoomMessage?.(event),
             onStorageUpdated: (event) => onStorageUpdated?.(event),
         };
     }
 
-    public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
-    ): Promise<string> {
-        if (!this._authorize) {
-            throw new Error("IO does not specify authorize during initialization.");
-        }
-
-        const ioAuthorize =
-            typeof this._authorize === "function" ? this._authorize(params) : (this._authorize as { secret: string });
-
-        const secret = ioAuthorize.secret;
-
-        return await authorize({
-            platform: this._platform,
-            secret,
-        }).encode(params);
-    }
-
-    public getRoom(
+    public createRoom(
         room: string,
-        ...options: GetRoomOptions<TPlatform>
+        ...options: CreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents>
     ): IORoom<TPlatform, TAuthorize, TContext, TEvents> {
-        const { debug, ...platformRoomContext } = options[0] ?? {};
-
-        this._purgeEmptyRooms();
+        const { debug, onDestroy, onMessage, ...platformRoomContext } = options[0] ?? {};
 
         if (!/^[a-z0-9]+[a-z0-9\-_]+[a-z0-9]+$/i.test(room)) {
             throw new Error("Unsupported room name");
         }
 
-        const platform = this._platform;
-        const oldRoom = this._rooms.get(room);
-
-        if (oldRoom) return oldRoom;
-
         const roomContext = {
             ...this._context,
             ...platformRoomContext,
@@ -144,54 +269,47 @@ export class PluvServer<
             context: roomContext,
             crdt: this._crdt,
             debug: debug ?? this._debug,
-            onDestroy: async ({ encodedState, room }) => {
+            onDestroy: async (event) => {
                 this._logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
 
-                const roomContext = {
-                    room,
-                    encodedState,
-                    ...platformRoomContext,
-                } as IORoomListenerEvent<TPlatform> & InferRoomContextType<TPlatform>;
-
-                this._rooms.delete(room);
-
-                await Promise.resolve(this._listeners.onRoomDeleted(roomContext));
+                await Promise.resolve(onDestroy?.(event));
+                await Promise.resolve(this._listeners.onRoomDeleted(event));
                 await this._platform.persistance.deleteStorageState(room);
 
-                if (this._debug) {
-                    const rooms = Array.from(this._rooms.keys());
-
-                    this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
-                    this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
-                }
+                this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
             },
-            platform,
+            onMessage: async (event) => {
+                await Promise.resolve(onMessage?.(event));
+                await Promise.resolve(this._listeners.onRoomMessage(event));
+            },
+            platform: this._platform,
             router: this._router,
         });
 
-        this._rooms.set(room, newRoom);
+        this._logDebug(`${colors.blue("Created room:")} ${room}`);
 
-        if (this._debug) {
-            const rooms = Array.from(this._rooms.keys());
+        return newRoom;
+    }
 
-            this._logDebug(`${colors.blue("Created room:")} ${room}`);
-            this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
+    public async createToken(
+        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
+    ): Promise<string> {
+        if (!this._authorize) {
+            throw new Error("IO does not specify authorize during initialization.");
         }
 
-        return newRoom;
+        const ioAuthorize =
+            typeof this._authorize === "function" ? this._authorize(params) : (this._authorize as { secret: string });
+
+        const secret = ioAuthorize.secret;
+
+        return await authorize({
+            platform: this._platform,
+            secret,
+        }).encode(params);
     }
 
     private _logDebug(...data: any[]): void {
         this._debug && console.log(...data);
     }
-
-    private _purgeEmptyRooms(): void {
-        const rooms = Array.from(this._rooms.entries());
-
-        rooms.forEach(([id, room]) => {
-            if (!!room?.getSize()) return;
-
-            this._rooms.delete(id);
-        });
-    }
 }

package/src/createIO.ts

@@ -2,19 +2,18 @@ import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import type { BaseUser, IOAuthorize, JsonObject } from "@pluv/types";
 import type { AbstractPlatform, InferPlatformContextType } from "./AbstractPlatform";
 import { PluvIO } from "./PluvIO";
-import type { GetInitialStorageFn, PluvIOListeners } from "./types";
+import type { GetInitialStorageFn } from "./types";
 
 export type CreateIOParams<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TContext extends JsonObject = {},
     TAuthorizeUser extends BaseUser = BaseUser,
     TAuthorizeRequired extends boolean = false,
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = {
     authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformContextType<TPlatform>>;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
-    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
@@ -30,7 +29,7 @@ export const createIO = <
     IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformContextType<TPlatform>>,
     TContext
 > => {
-    const { authorize, context, crdt, debug, getInitialStorage, onRoomDeleted, onStorageUpdated, platform } = params;
+    const { authorize, context, crdt, debug, platform } = params;
 
     return new PluvIO<
         TPlatform,
@@ -41,9 +40,6 @@ export const createIO = <
         context,
         crdt,
         debug,
-        getInitialStorage,
-        onRoomDeleted,
-        onStorageUpdated,
         platform,
     });
 };