@pluv/platform-pluv 0.32.9 → 0.34.0

package/dist/index.d.ts

@@ -1,27 +1,5 @@
-import { AbstractPlatform, WebSocketRegistrationMode, AbstractWebSocket, ConvertWebSocketConfig, WebSocketSerializedState, AbstractPlatformConfig, JWTEncodeParams, GetInitialStorageFn, BaseUser as BaseUser$1 } from '@pluv/io';
-import * as hono from 'hono';
-import { BaseUser, InputZodLike, IOLike } from '@pluv/types';
-import { z } from 'zod';
+import { AbstractPlatform, JWTEncodeParams, AbstractWebSocket, ConvertWebSocketConfig, WebSocketSerializedState, AbstractPlatformConfig } from '@pluv/io';
 
-declare class PluvPlatform extends AbstractPlatform {
-    _registrationMode: WebSocketRegistrationMode;
-    acceptWebSocket(webSocket: AbstractWebSocket): Promise<void>;
-    convertWebSocket(webSocket: any, config: ConvertWebSocketConfig): AbstractWebSocket;
-    getLastPing(webSocket: AbstractWebSocket): number | null;
-    getSerializedState(webSocket: any): WebSocketSerializedState | null;
-    getSessionId(webSocket: any): string | null;
-    getWebSockets(): readonly any[];
-    initialize(config: AbstractPlatformConfig<{}>): this;
-    parseData(data: string | ArrayBuffer): Record<string, any>;
-    randomUUID(): string;
-    setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): void;
-}
-
-interface PluvAuthorize<TUser extends BaseUser> {
-    required: true;
-    secret: string;
-    user: InputZodLike<TUser>;
-}
 interface PluvIOEndpoints {
     createToken: string;
 }
@@ -29,30 +7,18 @@ type RoomDeletedMessageEventData = {
     encodedState: string | null;
     room: string;
 };
-type UserConnectedEventData<TUser extends BaseUser> = {
+type UserConnectedEventData = {
     encodedState: string | null;
     room: string;
-    user: TUser;
+    user: any;
 };
-type UserDisconnectedEventData<TUser extends BaseUser> = {
+type UserDisconnectedEventData = {
     encodedState: string | null;
     room: string;
-    user: TUser;
-};
-type PluvIOListeners<TUser extends BaseUser> = {
-    getInitialStorage?: GetInitialStorageFn<{}>;
-    onRoomDeleted: (event: RoomDeletedMessageEventData) => void;
-    onUserConnected: (event: UserConnectedEventData<TUser>) => void;
-    onUserDisconnected: (event: UserDisconnectedEventData<TUser>) => void;
+    user: any;
 };
-type WebhooksConfig<TUser extends BaseUser> = ({
-    webhookSecret?: undefined;
-} & {
-    [P in keyof PluvIOListeners<TUser>]?: undefined;
-}) | ({
-    webhookSecret: string;
-} & Partial<PluvIOListeners<TUser>>);
-type PluvIOConfig<TUser extends BaseUser> = WebhooksConfig<TUser> & {
+
+interface PluvPlatformConfig {
     /**
      * @ignore
      * @readonly
@@ -61,187 +27,68 @@ type PluvIOConfig<TUser extends BaseUser> = WebhooksConfig<TUser> & {
     _defs?: {
         endpoints?: PluvIOEndpoints;
     };
-    authorize: {
-        user: InputZodLike<TUser>;
-    };
     basePath: string;
     publicKey: string;
     secretKey: string;
-};
-declare class PluvIO<TUser extends BaseUser> implements IOLike<PluvAuthorize<TUser>, {}> {
-    private readonly _authorize;
+    webhookSecret?: string;
+}
+declare class PluvPlatform extends AbstractPlatform<any, {}, {}, {
+    authorize: {
+        required: false;
+        secret: false;
+    };
+    handleMode: "fetch";
+    registrationMode: "attached";
+    requireAuth: true;
+    listeners: {
+        onRoomDeleted: true;
+        onRoomMessage: false;
+        onStorageUpdated: false;
+        onUserConnected: true;
+        onUserDisconnected: true;
+    };
+}> {
+    readonly _config: {
+        authorize: {
+            required: false;
+            secret: false;
+        };
+        handleMode: "fetch";
+        registrationMode: "attached";
+        requireAuth: true;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: false;
+            onStorageUpdated: false;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+    };
+    readonly _name = "platformPluv";
+    private _authorize;
     private readonly _basePath;
     private readonly _endpoints;
-    private readonly _getInitialStorage?;
-    private readonly _listeners;
+    private _getInitialStorage?;
+    private _listeners?;
     private readonly _publicKey;
     private readonly _secretKey;
     private readonly _webhookSecret?;
-    /**
-     * @ignore
-     * @readonly
-     * @deprecated Internal use only. Changes to this will never be marked as breaking.
-     */
-    get _defs(): {
-        authorize: PluvAuthorize<TUser>;
-        context: {};
-        events: {};
-        readonly platform: void;
-    };
-    get fetch(): (request: Request, Env?: unknown, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
-    get handler(): (req: Request) => Response | Promise<Response>;
+    _createToken: (params: JWTEncodeParams<any, any>) => Promise<string>;
+    constructor(params: PluvPlatformConfig);
+    acceptWebSocket(webSocket: AbstractWebSocket): Promise<void>;
+    convertWebSocket(webSocket: any, config: ConvertWebSocketConfig): AbstractWebSocket;
+    getLastPing(webSocket: AbstractWebSocket): number | null;
+    getSerializedState(webSocket: any): WebSocketSerializedState | null;
+    getSessionId(webSocket: any): string | null;
+    getWebSockets(): readonly any[];
+    initialize(config: AbstractPlatformConfig<{}>): this;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+    setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): void;
+    validateConfig(config: any): void;
     private _webhooks;
-    constructor(options: PluvIOConfig<TUser>);
-    createToken(params: JWTEncodeParams<TUser, PluvPlatform>): Promise<string>;
 }
 
-declare const createIO: <TUser extends BaseUser$1>(config: PluvIOConfig<TUser>) => PluvIO<TUser>;
-
-declare const ZodEvent: z.ZodDiscriminatedUnion<"event", [z.ZodObject<{
-    event: z.ZodLiteral<"initial-storage">;
-    data: z.ZodObject<{
-        room: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        room: string | null;
-    }, {
-        room: string | null;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    event: "initial-storage";
-    data: {
-        room: string | null;
-    };
-}, {
-    event: "initial-storage";
-    data: {
-        room: string | null;
-    };
-}>, z.ZodObject<{
-    event: z.ZodLiteral<"room-deleted">;
-    data: z.ZodObject<{
-        room: z.ZodString;
-        storage: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        room: string;
-        storage: string | null;
-    }, {
-        room: string;
-        storage: string | null;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    event: "room-deleted";
-    data: {
-        room: string;
-        storage: string | null;
-    };
-}, {
-    event: "room-deleted";
-    data: {
-        room: string;
-        storage: string | null;
-    };
-}>, z.ZodObject<{
-    event: z.ZodLiteral<"user-connected">;
-    data: z.ZodObject<{
-        room: z.ZodString;
-        storage: z.ZodNullable<z.ZodString>;
-        user: z.ZodObject<{
-            id: z.ZodString;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            id: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            id: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">>;
-    }, "strip", z.ZodTypeAny, {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    }, {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    }>;
-}, "strip", z.ZodTypeAny, {
-    event: "user-connected";
-    data: {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    };
-}, {
-    event: "user-connected";
-    data: {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    };
-}>, z.ZodObject<{
-    event: z.ZodLiteral<"user-disconnected">;
-    data: z.ZodObject<{
-        room: z.ZodString;
-        storage: z.ZodNullable<z.ZodString>;
-        user: z.ZodObject<{
-            id: z.ZodString;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            id: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            id: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">>;
-    }, "strip", z.ZodTypeAny, {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    }, {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    }>;
-}, "strip", z.ZodTypeAny, {
-    event: "user-disconnected";
-    data: {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    };
-}, {
-    event: "user-disconnected";
-    data: {
-        room: string;
-        storage: string | null;
-        user: {
-            id: string;
-        } & {
-            [k: string]: unknown;
-        };
-    };
-}>]>;
+declare const platformPluv: (config: PluvPlatformConfig) => PluvPlatform;
 
-export { PluvIO, type PluvIOConfig, PluvPlatform, ZodEvent, createIO };
+export { type PluvIOEndpoints, PluvPlatform, type RoomDeletedMessageEventData, type UserConnectedEventData, type UserDisconnectedEventData, platformPluv };

package/dist/index.js

@@ -52,16 +52,16 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ZodEvent: () => ZodEvent,
-  createIO: () => createIO
+var index_exports = {};
+__export(index_exports, {
+  PluvPlatform: () => PluvPlatform,
+  platformPluv: () => platformPluv
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// src/PluvIO.ts
+// src/PluvPlatform.ts
+var import_io = require("@pluv/io");
 var import_hono = require("hono");
-var import_vercel = require("hono/vercel");
 
 // src/constants.ts
 var SIGNATURE_HEADER = "x-pluv-signature-256";
@@ -160,11 +160,50 @@ var verifyWebhook = (params) => __async(void 0, null, function* () {
   return timingSafeEqual(verificationBytes, signatureBytes);
 });
 
-// src/PluvIO.ts
-var PluvIO = class {
-  constructor(options) {
-    this._webhooks = new import_hono.Hono().basePath("/").post("/event", (c) => __async(this, null, function* () {
-      var _a, _b;
+// src/PluvPlatform.ts
+var PluvPlatform = class extends import_io.AbstractPlatform {
+  constructor(params) {
+    super();
+    this._config = {
+      authorize: {
+        required: false,
+        secret: false
+      },
+      handleMode: "fetch",
+      registrationMode: "attached",
+      requireAuth: true,
+      listeners: {
+        onRoomDeleted: true,
+        onRoomMessage: false,
+        onStorageUpdated: false,
+        onUserConnected: true,
+        onUserDisconnected: true
+      }
+    };
+    this._name = "platformPluv";
+    this._createToken = (params) => __async(this, null, function* () {
+      var _a;
+      const parsed = this._authorize.user.parse(params.user);
+      const res = yield fetch(this._endpoints.createToken, {
+        headers: { "content-type": "application/json" },
+        method: "post",
+        body: JSON.stringify({
+          maxAge: (_a = params.maxAge) != null ? _a : null,
+          publicKey: this._publicKey,
+          room: params.room,
+          secretKey: this._secretKey,
+          user: parsed
+        })
+      }).catch(() => null);
+      if (!res || !res.ok || res.status !== 200) {
+        throw new Error("Authorization failed");
+      }
+      const token = yield res.text().catch(() => null);
+      if (typeof token !== "string") throw new Error("Authorization failed");
+      return token;
+    });
+    this._webhooks = new import_hono.Hono().basePath("/").post("/", (c) => __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
       const signature = c.req.header(SIGNATURE_HEADER);
       if (!this._webhookSecret || !signature) return c.json({ error: "Unauthorized" }, 401);
       const payload = yield c.req.json();
@@ -186,110 +225,88 @@ var PluvIO = class {
         case "room-deleted": {
           const room = data.room;
           const encodedState = data.storage;
-          yield Promise.resolve(this._listeners.onRoomDeleted({ encodedState, room }));
+          yield Promise.resolve((_c = this._listeners) == null ? void 0 : _c.onRoomDeleted({ encodedState, room }));
           return c.json({ data: { room } }, 200);
         }
         case "user-connected": {
           const room = data.room;
           const encodedState = data.storage;
           const user = data.user;
-          yield Promise.resolve(this._listeners.onUserConnected({ encodedState, room, user }));
+          yield Promise.resolve((_d = this._listeners) == null ? void 0 : _d.onUserConnected({ encodedState, room, user }));
         }
         case "user-disconnected": {
           const room = data.room;
           const encodedState = data.storage;
           const user = data.user;
-          yield Promise.resolve(this._listeners.onUserDisconnected({ encodedState, room, user }));
+          yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onUserDisconnected({ encodedState, room, user }));
         }
         default:
           return c.json({ data: { ok: true } }, 200);
       }
     }));
-    const {
-      _defs,
-      authorize,
-      basePath,
-      getInitialStorage,
-      onRoomDeleted,
-      onUserConnected,
-      onUserDisconnected,
-      publicKey,
-      secretKey,
-      webhookSecret
-    } = options;
-    this._authorize = {
-      required: true,
-      secret: "",
-      user: authorize.user
-    };
+    const { _defs, basePath, publicKey, secretKey, webhookSecret } = params;
     this._basePath = basePath;
     this._endpoints = __spreadValues({
       createToken: "https://pluv.io/api/room/token"
     }, _defs == null ? void 0 : _defs.endpoints);
-    this._getInitialStorage = getInitialStorage;
-    this._listeners = {
-      onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event),
-      onUserConnected: (event) => onUserConnected == null ? void 0 : onUserConnected(event),
-      onUserDisconnected: (event) => onUserDisconnected == null ? void 0 : onUserDisconnected(event)
-    };
     this._publicKey = publicKey;
     this._secretKey = secretKey;
     this._webhookSecret = webhookSecret;
+    this._fetch = new import_hono.Hono().basePath(this._basePath).route("/", this._webhooks).fetch;
   }
-  /**
-   * @ignore
-   * @readonly
-   * @deprecated Internal use only. Changes to this will never be marked as breaking.
-   */
-  get _defs() {
-    return {
-      authorize: this._authorize,
-      context: {},
-      events: {},
-      get platform() {
-        throw new Error("Invalid platform reference");
-      }
-    };
+  acceptWebSocket(webSocket) {
+    throw new Error("Not implemented");
   }
-  get fetch() {
-    const app = new import_hono.Hono().basePath(this._basePath).route("/", this._webhooks);
-    return app.fetch;
+  convertWebSocket(webSocket, config) {
+    throw new Error("Not implemented");
   }
-  get handler() {
-    const app = new import_hono.Hono().basePath(this._basePath).route("/", this._webhooks);
-    return (0, import_vercel.handle)(app);
+  getLastPing(webSocket) {
+    throw new Error("Not implemented");
   }
-  createToken(params) {
-    return __async(this, null, function* () {
-      var _a;
-      const parsed = this._authorize.user.parse(params.user);
-      const res = yield fetch(this._endpoints.createToken, {
-        headers: { "content-type": "application/json" },
-        method: "post",
-        body: JSON.stringify({
-          maxAge: (_a = params.maxAge) != null ? _a : null,
-          publicKey: this._publicKey,
-          room: params.room,
-          secretKey: this._secretKey,
-          user: parsed
-        })
-      }).catch(() => null);
-      if (!res || !res.ok || res.status !== 200) {
-        throw new Error("Authorization failed");
-      }
-      const token = yield res.text().catch(() => null);
-      if (typeof token !== "string") throw new Error("Authorization failed");
-      return token;
-    });
+  getSerializedState(webSocket) {
+    throw new Error("Not implemented");
+  }
+  getSessionId(webSocket) {
+    throw new Error("Not implemented");
+  }
+  getWebSockets() {
+    throw new Error("Not implemented");
+  }
+  initialize(config) {
+    throw new Error("Not implemented");
+  }
+  parseData(data) {
+    throw new Error("Not implemented");
+  }
+  randomUUID() {
+    throw new Error("Not implemented");
+  }
+  setSerializedState(webSocket, state) {
+    throw new Error("Not implemented");
+  }
+  validateConfig(config) {
+    if (!config.authorize) throw new Error("Config `authorize` must be provided to `platformPluv`");
+    if (!!config.onRoomMessage) throw new Error("Config `onRoomMessage` is not supported on `platformPluv`");
+    if (!!config.onStorageUpdated) throw new Error("Config `onStorageUpdated` is not supported on `platformPluv`");
+    if (!!config.authorize.required) {
+      throw new Error("Config `authorize.required` is not allowed to be false on `platformPluv`");
+    }
+    this._authorize = config.authorize;
+    this._getInitialStorage = config.getInitialStorage;
+    this._listeners = {
+      onRoomDeleted: config.onRoomDeleted,
+      onUserConnected: config.onUserConnected,
+      onUserDisconnected: config.onUserDisconnected
+    };
   }
 };
 
-// src/createIO.ts
-var createIO = (config) => {
-  return new PluvIO(config);
+// src/platformPluv.ts
+var platformPluv = (config) => {
+  return new PluvPlatform(config);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ZodEvent,
-  createIO
+  PluvPlatform,
+  platformPluv
 });