@pluv/platform-pluv 0.30.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+    root: true,
+    extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,18 @@
+
+> @pluv/platform-pluv@0.30.0 build /home/runner/work/pluv/pluv/packages/platform-pluv
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.3.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 3.57 KB
+ESM ⚡️ Build success in 61ms
+CJS dist/index.js 4.75 KB
+CJS ⚡️ Build success in 59ms
+DTS Build start
+DTS ⚡️ Build success in 6690ms
+DTS dist/index.d.mts 2.24 KB
+DTS dist/index.d.ts  2.24 KB

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @pluv/platform-pluv
+
+## 0.30.0
+
+### Minor Changes
+
+- fa496a2: Add new package `@pluv/platform-pluv`.
+
+### Patch Changes
+
+- Updated dependencies [7246a9e]
+  - @pluv/io@0.30.0
+  - @pluv/crdt@0.30.0
+  - @pluv/types@0.30.0

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/dist/index.d.mts

@@ -0,0 +1,48 @@
+import { AbstractPlatform, WebSocketRegistrationMode, AbstractWebSocket, ConvertWebSocketConfig, WebSocketSerializedState, AbstractPlatformConfig, PluvIOListeners, GetInitialStorageFn, JWTEncodeParams, BaseUser as BaseUser$1 } from '@pluv/io';
+import * as hono_types from 'hono/types';
+import * as hono from 'hono';
+import { BaseUser, InputZodLike } from '@pluv/types';
+
+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>;
+}
+type PluvIOConfig<TUser extends BaseUser> = Partial<Pick<PluvIOListeners<PluvPlatform, PluvAuthorize<TUser>, {}, {}>, "onRoomDeleted">> & {
+    authorize: {
+        user: InputZodLike<TUser>;
+    };
+    basePath: string;
+    getInitialStorage?: GetInitialStorageFn<PluvPlatform>;
+    secretKey: string;
+};
+declare class PluvIO<TUser extends BaseUser> {
+    private readonly _authorize;
+    private readonly _basePath;
+    private readonly _getInitialStorage?;
+    private readonly _listeners;
+    private readonly _secretKey;
+    get fetch(): (request: Request, Env?: unknown, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
+    get handler(): (req: Request, requestContext: hono_types.FetchEventLike) => Response | Promise<Response>;
+    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>;
+
+export { PluvIO, type PluvIOConfig, PluvPlatform, createIO };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { AbstractPlatform, WebSocketRegistrationMode, AbstractWebSocket, ConvertWebSocketConfig, WebSocketSerializedState, AbstractPlatformConfig, PluvIOListeners, GetInitialStorageFn, JWTEncodeParams, BaseUser as BaseUser$1 } from '@pluv/io';
+import * as hono_types from 'hono/types';
+import * as hono from 'hono';
+import { BaseUser, InputZodLike } from '@pluv/types';
+
+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>;
+}
+type PluvIOConfig<TUser extends BaseUser> = Partial<Pick<PluvIOListeners<PluvPlatform, PluvAuthorize<TUser>, {}, {}>, "onRoomDeleted">> & {
+    authorize: {
+        user: InputZodLike<TUser>;
+    };
+    basePath: string;
+    getInitialStorage?: GetInitialStorageFn<PluvPlatform>;
+    secretKey: string;
+};
+declare class PluvIO<TUser extends BaseUser> {
+    private readonly _authorize;
+    private readonly _basePath;
+    private readonly _getInitialStorage?;
+    private readonly _listeners;
+    private readonly _secretKey;
+    get fetch(): (request: Request, Env?: unknown, executionCtx?: hono.ExecutionContext) => Response | Promise<Response>;
+    get handler(): (req: Request, requestContext: hono_types.FetchEventLike) => Response | Promise<Response>;
+    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>;
+
+export { PluvIO, type PluvIOConfig, PluvPlatform, createIO };

package/dist/index.js

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 src_exports = {};
+__export(src_exports, {
+  createIO: () => createIO
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PluvIO.ts
+var import_hono = require("hono");
+var import_vercel = require("hono/vercel");
+
+// src/schemas.ts
+var import_zod = require("zod");
+var ZodEventInitialStorage = import_zod.z.object({
+  event: import_zod.z.literal("initial-storage"),
+  data: import_zod.z.object({
+    room: import_zod.z.string().nullable()
+  })
+});
+var ZodEventRoomDeleted = import_zod.z.object({
+  event: import_zod.z.literal("room-deleted"),
+  data: import_zod.z.object({
+    room: import_zod.z.string(),
+    storage: import_zod.z.string().nullable()
+  })
+});
+var ZodEvent = import_zod.z.discriminatedUnion("event", [ZodEventInitialStorage, ZodEventRoomDeleted]);
+
+// 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;
+      const body = yield c.req.json();
+      const parsed = ZodEvent.safeParse(body);
+      if (!parsed.success) return c.json({ data: { ok: true } }, 200);
+      const { event, data } = parsed.data;
+      switch (event) {
+        case "initial-storage": {
+          const room = data.room;
+          const storage = typeof room === "string" ? (_b = yield (_a = this._getInitialStorage) == null ? void 0 : _a.call(this, { room })) != null ? _b : null : null;
+          return c.json({ data: { storage } }, 200);
+        }
+        case "room-deleted": {
+          const room = data.room;
+          const encodedState = data.storage;
+          yield Promise.resolve(this._listeners.onRoomDeleted({ context: {}, encodedState, room }));
+          return c.json({ data: { room } }, 200);
+        }
+        default:
+          return c.json({ data: { ok: true } }, 200);
+      }
+    }));
+    const { authorize, basePath, onRoomDeleted, getInitialStorage, secretKey } = options;
+    this._authorize = {
+      required: true,
+      secret: "",
+      user: authorize.user
+    };
+    this._basePath = basePath;
+    this._getInitialStorage = getInitialStorage;
+    this._listeners = { onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event) };
+    this._secretKey = secretKey;
+  }
+  get fetch() {
+    const app = new import_hono.Hono().basePath(this._basePath).route("/", this._webhooks);
+    return app.fetch;
+  }
+  get handler() {
+    const app = new import_hono.Hono().basePath(this._basePath).route("/", this._webhooks);
+    return (0, import_vercel.handle)(app);
+  }
+  createToken(params) {
+    return __async(this, null, function* () {
+      var _a;
+      const parsed = this._authorize.user.parse(params.user);
+      const res = yield fetch("https://pluv.io/api/participant/authorize", {
+        method: "post",
+        body: JSON.stringify({
+          maxAge: (_a = params.maxAge) != null ? _a : null,
+          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;
+    });
+  }
+};
+
+// src/createIO.ts
+var createIO = (config) => {
+  return new PluvIO(config);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createIO
+});

package/dist/index.mjs

@@ -0,0 +1,118 @@
+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/PluvIO.ts
+import { Hono } from "hono";
+import { handle } from "hono/vercel";
+
+// src/schemas.ts
+import { z } from "zod";
+var ZodEventInitialStorage = z.object({
+  event: z.literal("initial-storage"),
+  data: z.object({
+    room: z.string().nullable()
+  })
+});
+var ZodEventRoomDeleted = z.object({
+  event: z.literal("room-deleted"),
+  data: z.object({
+    room: z.string(),
+    storage: z.string().nullable()
+  })
+});
+var ZodEvent = z.discriminatedUnion("event", [ZodEventInitialStorage, ZodEventRoomDeleted]);
+
+// src/PluvIO.ts
+var PluvIO = class {
+  constructor(options) {
+    this._webhooks = new Hono().basePath("/").post("/event", (c) => __async(this, null, function* () {
+      var _a, _b;
+      const body = yield c.req.json();
+      const parsed = ZodEvent.safeParse(body);
+      if (!parsed.success) return c.json({ data: { ok: true } }, 200);
+      const { event, data } = parsed.data;
+      switch (event) {
+        case "initial-storage": {
+          const room = data.room;
+          const storage = typeof room === "string" ? (_b = yield (_a = this._getInitialStorage) == null ? void 0 : _a.call(this, { room })) != null ? _b : null : null;
+          return c.json({ data: { storage } }, 200);
+        }
+        case "room-deleted": {
+          const room = data.room;
+          const encodedState = data.storage;
+          yield Promise.resolve(this._listeners.onRoomDeleted({ context: {}, encodedState, room }));
+          return c.json({ data: { room } }, 200);
+        }
+        default:
+          return c.json({ data: { ok: true } }, 200);
+      }
+    }));
+    const { authorize, basePath, onRoomDeleted, getInitialStorage, secretKey } = options;
+    this._authorize = {
+      required: true,
+      secret: "",
+      user: authorize.user
+    };
+    this._basePath = basePath;
+    this._getInitialStorage = getInitialStorage;
+    this._listeners = { onRoomDeleted: (event) => onRoomDeleted == null ? void 0 : onRoomDeleted(event) };
+    this._secretKey = secretKey;
+  }
+  get fetch() {
+    const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
+    return app.fetch;
+  }
+  get handler() {
+    const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
+    return handle(app);
+  }
+  createToken(params) {
+    return __async(this, null, function* () {
+      var _a;
+      const parsed = this._authorize.user.parse(params.user);
+      const res = yield fetch("https://pluv.io/api/participant/authorize", {
+        method: "post",
+        body: JSON.stringify({
+          maxAge: (_a = params.maxAge) != null ? _a : null,
+          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;
+    });
+  }
+};
+
+// src/createIO.ts
+var createIO = (config) => {
+  return new PluvIO(config);
+};
+export {
+  createIO
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@pluv/platform-pluv",
+  "version": "0.30.0",
+  "description": "@pluv/io adapter for pluv.io",
+  "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/platform-pluv"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^22.5.5",
+    "hono": "^4.6.3",
+    "zod": "^3.23.8",
+    "@pluv/types": "^0.30.0",
+    "@pluv/io": "^0.30.0",
+    "@pluv/crdt": "^0.30.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "@pluv/tsconfig": "^0.30.0",
+    "eslint-config-pluv": "^0.30.0"
+  },
+  "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",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/PluvIO.ts

@@ -0,0 +1,111 @@
+import type { GetInitialStorageFn, JWTEncodeParams, PluvIOListeners } from "@pluv/io";
+import type { BaseUser, InputZodLike } from "@pluv/types";
+import { Hono } from "hono";
+import { handle } from "hono/vercel";
+import type { PluvPlatform } from "./PluvPlatform";
+import { ZodEvent } from "./schemas";
+
+interface PluvAuthorize<TUser extends BaseUser> {
+    required: true;
+    secret: string;
+    user: InputZodLike<TUser>;
+}
+
+export type PluvIOConfig<TUser extends BaseUser> = Partial<
+    Pick<PluvIOListeners<PluvPlatform, PluvAuthorize<TUser>, {}, {}>, "onRoomDeleted">
+> & {
+    authorize: {
+        user: InputZodLike<TUser>;
+    };
+    basePath: string;
+    getInitialStorage?: GetInitialStorageFn<PluvPlatform>;
+    secretKey: string;
+};
+
+export class PluvIO<TUser extends BaseUser> {
+    private readonly _authorize: PluvAuthorize<TUser>;
+    private readonly _basePath: string;
+    private readonly _getInitialStorage?: GetInitialStorageFn<PluvPlatform>;
+    private readonly _listeners: Pick<PluvIOListeners<PluvPlatform, PluvAuthorize<TUser>, {}, {}>, "onRoomDeleted">;
+    private readonly _secretKey: string;
+
+    public get fetch() {
+        const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
+
+        return app.fetch;
+    }
+
+    public get handler() {
+        const app = new Hono().basePath(this._basePath).route("/", this._webhooks);
+
+        return handle(app);
+    }
+
+    private _webhooks = new Hono().basePath("/").post("/event", async (c) => {
+        const body = await c.req.json();
+        const parsed = ZodEvent.safeParse(body);
+
+        if (!parsed.success) return c.json({ data: { ok: true } }, 200);
+
+        const { event, data } = parsed.data;
+
+        switch (event) {
+            case "initial-storage": {
+                const room = data.room;
+                const storage = typeof room === "string" ? ((await this._getInitialStorage?.({ room })) ?? null) : null;
+
+                return c.json({ data: { storage } }, 200);
+            }
+            case "room-deleted": {
+                const room = data.room;
+                const encodedState = data.storage;
+
+                await Promise.resolve(this._listeners.onRoomDeleted({ context: {}, encodedState, room }));
+
+                return c.json({ data: { room } }, 200);
+            }
+            default:
+                return c.json({ data: { ok: true } }, 200);
+        }
+    });
+
+    constructor(options: PluvIOConfig<TUser>) {
+        const { authorize, basePath, onRoomDeleted, getInitialStorage, secretKey } = options;
+
+        this._authorize = {
+            required: true,
+            secret: "",
+            user: authorize.user,
+        };
+        this._basePath = basePath;
+        this._getInitialStorage = getInitialStorage;
+        this._listeners = { onRoomDeleted: (event) => onRoomDeleted?.(event) };
+        this._secretKey = secretKey;
+    }
+
+    public async createToken(params: JWTEncodeParams<TUser, PluvPlatform>): Promise<string> {
+        const parsed = this._authorize.user.parse(params.user);
+
+        const res = await fetch("https://pluv.io/api/participant/authorize", {
+            method: "post",
+            body: JSON.stringify({
+                maxAge: params.maxAge ?? null,
+                room: params.room,
+                secretKey: this._secretKey,
+                user: parsed,
+            }),
+        }).catch(() => null);
+
+        if (!res || !res.ok || res.status !== 200) {
+            throw new Error("Authorization failed");
+        }
+
+        const token = await res.text().catch(() => null);
+
+        if (typeof token !== "string") {
+            throw new Error("Authorization failed");
+        }
+
+        return token;
+    }
+}

package/src/PluvPlatform.ts

@@ -0,0 +1,52 @@
+import {
+    AbstractPlatform,
+    AbstractPlatformConfig,
+    AbstractWebSocket,
+    ConvertWebSocketConfig,
+    WebSocketRegistrationMode,
+    WebSocketSerializedState,
+} from "@pluv/io";
+
+export class PluvPlatform extends AbstractPlatform {
+    _registrationMode: WebSocketRegistrationMode = "attached";
+
+    public acceptWebSocket(webSocket: AbstractWebSocket): Promise<void> {
+        throw new Error("Not implemented");
+    }
+
+    public convertWebSocket(webSocket: any, config: ConvertWebSocketConfig): AbstractWebSocket {
+        throw new Error("Not implemented");
+    }
+
+    public getLastPing(webSocket: AbstractWebSocket): number | null {
+        throw new Error("Not implemented");
+    }
+
+    public getSerializedState(webSocket: any): WebSocketSerializedState | null {
+        throw new Error("Not implemented");
+    }
+
+    public getSessionId(webSocket: any): string | null {
+        throw new Error("Not implemented");
+    }
+
+    public getWebSockets(): readonly any[] {
+        throw new Error("Not implemented");
+    }
+
+    public initialize(config: AbstractPlatformConfig<{}, {}>): this {
+        throw new Error("Not implemented");
+    }
+
+    public parseData(data: string | ArrayBuffer): Record<string, any> {
+        throw new Error("Not implemented");
+    }
+
+    public randomUUID(): string {
+        throw new Error("Not implemented");
+    }
+
+    public setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): void {
+        throw new Error("Not implemented");
+    }
+}

package/src/createIO.ts

@@ -0,0 +1,7 @@
+import type { BaseUser } from "@pluv/io";
+import type { PluvIOConfig } from "./PluvIO";
+import { PluvIO } from "./PluvIO";
+
+export const createIO = <TUser extends BaseUser>(config: PluvIOConfig<TUser>): PluvIO<TUser> => {
+    return new PluvIO(config);
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createIO } from "./createIO";
+export type { PluvIO, PluvIOConfig } from "./PluvIO";
+export type { PluvPlatform } from "./PluvPlatform";

package/src/schemas.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+const ZodEventInitialStorage = z.object({
+    event: z.literal("initial-storage"),
+    data: z.object({
+        room: z.string().nullable(),
+    }),
+});
+
+const ZodEventRoomDeleted = z.object({
+    event: z.literal("room-deleted"),
+    data: z.object({
+        room: z.string(),
+        storage: z.string().nullable(),
+    }),
+});
+
+export const ZodEvent = z.discriminatedUnion("event", [ZodEventInitialStorage, ZodEventRoomDeleted]);

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["**/*.ts"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"types": ["@types/node"]
+	}
+}