@pluv/platform-pluv 0.38.8 → 0.38.10

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/platform-pluv@0.38.8 build /home/runner/work/pluv/pluv/packages/platform-pluv
+> @pluv/platform-pluv@0.38.10 build /home/runner/work/pluv/pluv/packages/platform-pluv
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-ESM dist/index.mjs 10.72 KB
-ESM ⚡️ Build success in 110ms
-CJS dist/index.js 12.26 KB
-CJS ⚡️ Build success in 113ms
+ESM dist/index.mjs 12.35 KB
+ESM ⚡️ Build success in 86ms
+CJS dist/index.js 14.09 KB
+CJS ⚡️ Build success in 87ms
 DTS Build start
-DTS ⚡️ Build success in 5913ms
+DTS ⚡️ Build success in 6301ms
 DTS dist/index.d.mts 3.43 KB
 DTS dist/index.d.ts  3.43 KB

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @pluv/platform-pluv
 
+## 0.38.10
+
+### Patch Changes
+
+- @pluv/crdt@0.38.10
+- @pluv/io@0.38.10
+- @pluv/types@0.38.10
+
+## 0.38.9
+
+### Patch Changes
+
+- 9b3af07: Updated internal event handlers to return more meaningful status codes and room identifiers.
+  - @pluv/crdt@0.38.9
+  - @pluv/io@0.38.9
+  - @pluv/types@0.38.9
+
 ## 0.38.8
 
 ### Patch Changes

package/dist/index.js

@@ -80,10 +80,16 @@ var SIGNATURE_HEADER = "x-pluv-signature-256";
 
 // src/schemas.ts
 var import_zod = require("zod");
+var ZodEventKind = import_zod.z.union([
+  import_zod.z.literal("initial-storage"),
+  import_zod.z.literal("room-deleted"),
+  import_zod.z.literal("user-connected"),
+  import_zod.z.literal("user-disconnected")
+]);
 var ZodEventInitialStorage = import_zod.z.object({
   event: import_zod.z.literal("initial-storage"),
   data: import_zod.z.object({
-    room: import_zod.z.string().nullable()
+    room: import_zod.z.string()
   })
 });
 var ZodEventRoomDeleted = import_zod.z.object({
@@ -119,6 +125,34 @@ var ZodEvent = import_zod.z.discriminatedUnion("event", [
   ZodEventUserConnected,
   ZodEventUserDisconnected
 ]);
+var ZodInitialStorageResponse = import_zod.z.object({
+  event: import_zod.z.literal("initial-storage"),
+  room: import_zod.z.string(),
+  storage: import_zod.z.string().nullable()
+});
+var ZodRoomDeletedResponse = import_zod.z.object({
+  event: import_zod.z.literal("room-deleted"),
+  room: import_zod.z.string()
+});
+var ZodUserConnectedResponse = import_zod.z.object({
+  event: import_zod.z.literal("user-connected"),
+  room: import_zod.z.string()
+});
+var ZodUserDisconnectedResponse = import_zod.z.object({
+  event: import_zod.z.literal("user-disconnected"),
+  room: import_zod.z.string()
+});
+var ZodEventResponse = import_zod.z.discriminatedUnion("event", [
+  ZodInitialStorageResponse,
+  ZodRoomDeletedResponse,
+  ZodUserConnectedResponse,
+  ZodUserDisconnectedResponse
+]);
+
+// src/shared/createErrorResponse.ts
+var createErrorResponse = (c, error, status) => {
+  return c.json({ ok: false, error: { message: error.message } }, status);
+};
 
 // src/shared/getCrypto.ts
 var getCrypto = () => {
@@ -147,6 +181,25 @@ var createHmac = (params) => __async(void 0, null, function* () {
   return { algorithm: "sha256", hmac };
 });
 
+// src/shared/createSuccessResponse.ts
+var createSuccessResponse = (c, data, status = 200) => {
+  return c.json(
+    {
+      ok: true,
+      data: ZodEventResponse.parse(data)
+    },
+    status
+  );
+};
+
+// src/shared/HttpError.ts
+var HttpError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+};
+
 // src/shared/timingSafeEqual.ts
 var timingSafeEqual = (a, b) => {
   if (a.length !== b.length) return false;
@@ -217,48 +270,55 @@ var PluvPlatform = class extends import_io.AbstractPlatform {
     this._webhooksRouter = new import_hono.Hono().basePath("/").post("/", (c) => __async(this, null, function* () {
       var _a, _b, _c, _d, _e, _f, _g;
       const [algorithm, signature] = (_b = (_a = c.req.header(SIGNATURE_HEADER)) == null ? void 0 : _a.split("=")) != null ? _b : [];
-      if (!this._webhookSecret) return c.json({ error: "Unauthorized" }, 401);
-      if (algorithm !== SIGNATURE_ALGORITHM) return c.json({ error: "Unauthorized" }, 401);
-      if (!signature) return c.json({ error: "Unauthorized" }, 401);
-      const payload = yield c.req.json();
-      const verified = yield verifyWebhook({
-        payload: (0, import_fast_json_stable_stringify.default)(payload),
-        signature,
-        secret: this._webhookSecret
-      });
-      if (!verified) return c.json({ error: "Unauthorized" }, 401);
-      const parsed = ZodEvent.safeParse(payload);
-      if (!parsed.success) return c.json({ data: { ok: true } }, 200);
-      const { event, data } = parsed.data;
-      const context = this._context;
-      switch (event) {
-        case "initial-storage": {
-          const room = data.room;
-          const storage = typeof room === "string" ? (_d = yield (_c = this._getInitialStorage) == null ? void 0 : _c.call(this, { context, room })) != null ? _d : null : null;
-          return c.json({ data: { storage } }, 200);
-        }
-        case "room-deleted": {
-          const room = data.room;
-          const encodedState = data.storage;
-          yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, 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((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
-          return c.json({ data: { ok: true } }, 200);
-        }
-        case "user-disconnected": {
-          const room = data.room;
-          const encodedState = data.storage;
-          const user = data.user;
-          yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
-          return c.json({ data: { ok: true } }, 200);
+      try {
+        if (!this._webhookSecret) throw new HttpError("Unauthorized", 401);
+        if (algorithm !== SIGNATURE_ALGORITHM) throw new HttpError("Unauthorized", 401);
+        if (!signature) throw new HttpError("Unauthorized", 401);
+        const payload = yield c.req.json();
+        const verified = yield verifyWebhook({
+          payload: (0, import_fast_json_stable_stringify.default)(payload),
+          signature,
+          secret: this._webhookSecret
+        });
+        if (!verified) throw new HttpError("Unauthorized", 401);
+        const parsed = ZodEvent.safeParse(payload);
+        if (!parsed.success) throw new HttpError("Invalid request", 400);
+        const { event, data } = parsed.data;
+        const context = this._context;
+        switch (event) {
+          case "initial-storage": {
+            const room = data.room;
+            const storage = typeof room === "string" ? (_d = yield (_c = this._getInitialStorage) == null ? void 0 : _c.call(this, { context, room })) != null ? _d : null : null;
+            return createSuccessResponse(c, { event, room, storage });
+          }
+          case "room-deleted": {
+            const room = data.room;
+            const encodedState = data.storage;
+            yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room }));
+            return createSuccessResponse(c, { event, room });
+          }
+          case "user-connected": {
+            const room = data.room;
+            const encodedState = data.storage;
+            const user = data.user;
+            yield Promise.resolve((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
+            return createSuccessResponse(c, { event, room });
+          }
+          case "user-disconnected": {
+            const room = data.room;
+            const encodedState = data.storage;
+            const user = data.user;
+            yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
+            return createSuccessResponse(c, { event, room });
+          }
+          default: {
+            throw new HttpError("Unknown event", 400);
+          }
         }
-        default:
-          return c.json({ data: { ok: true } }, 200);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unexpected error";
+        const status = error instanceof HttpError ? error.status : 500;
+        return createErrorResponse(c, { message }, status);
       }
     }));
     const { _defs, context, basePath, publicKey, secretKey, webhookSecret } = params;

package/dist/index.mjs

@@ -52,10 +52,16 @@ var SIGNATURE_HEADER = "x-pluv-signature-256";
 
 // src/schemas.ts
 import { z } from "zod";
+var ZodEventKind = z.union([
+  z.literal("initial-storage"),
+  z.literal("room-deleted"),
+  z.literal("user-connected"),
+  z.literal("user-disconnected")
+]);
 var ZodEventInitialStorage = z.object({
   event: z.literal("initial-storage"),
   data: z.object({
-    room: z.string().nullable()
+    room: z.string()
   })
 });
 var ZodEventRoomDeleted = z.object({
@@ -91,6 +97,34 @@ var ZodEvent = z.discriminatedUnion("event", [
   ZodEventUserConnected,
   ZodEventUserDisconnected
 ]);
+var ZodInitialStorageResponse = z.object({
+  event: z.literal("initial-storage"),
+  room: z.string(),
+  storage: z.string().nullable()
+});
+var ZodRoomDeletedResponse = z.object({
+  event: z.literal("room-deleted"),
+  room: z.string()
+});
+var ZodUserConnectedResponse = z.object({
+  event: z.literal("user-connected"),
+  room: z.string()
+});
+var ZodUserDisconnectedResponse = z.object({
+  event: z.literal("user-disconnected"),
+  room: z.string()
+});
+var ZodEventResponse = z.discriminatedUnion("event", [
+  ZodInitialStorageResponse,
+  ZodRoomDeletedResponse,
+  ZodUserConnectedResponse,
+  ZodUserDisconnectedResponse
+]);
+
+// src/shared/createErrorResponse.ts
+var createErrorResponse = (c, error, status) => {
+  return c.json({ ok: false, error: { message: error.message } }, status);
+};
 
 // src/shared/getCrypto.ts
 var getCrypto = () => {
@@ -119,6 +153,25 @@ var createHmac = (params) => __async(void 0, null, function* () {
   return { algorithm: "sha256", hmac };
 });
 
+// src/shared/createSuccessResponse.ts
+var createSuccessResponse = (c, data, status = 200) => {
+  return c.json(
+    {
+      ok: true,
+      data: ZodEventResponse.parse(data)
+    },
+    status
+  );
+};
+
+// src/shared/HttpError.ts
+var HttpError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+};
+
 // src/shared/timingSafeEqual.ts
 var timingSafeEqual = (a, b) => {
   if (a.length !== b.length) return false;
@@ -189,48 +242,55 @@ var PluvPlatform = class extends AbstractPlatform {
     this._webhooksRouter = new Hono().basePath("/").post("/", (c) => __async(this, null, function* () {
       var _a, _b, _c, _d, _e, _f, _g;
       const [algorithm, signature] = (_b = (_a = c.req.header(SIGNATURE_HEADER)) == null ? void 0 : _a.split("=")) != null ? _b : [];
-      if (!this._webhookSecret) return c.json({ error: "Unauthorized" }, 401);
-      if (algorithm !== SIGNATURE_ALGORITHM) return c.json({ error: "Unauthorized" }, 401);
-      if (!signature) return c.json({ error: "Unauthorized" }, 401);
-      const payload = yield c.req.json();
-      const verified = yield verifyWebhook({
-        payload: stringify(payload),
-        signature,
-        secret: this._webhookSecret
-      });
-      if (!verified) return c.json({ error: "Unauthorized" }, 401);
-      const parsed = ZodEvent.safeParse(payload);
-      if (!parsed.success) return c.json({ data: { ok: true } }, 200);
-      const { event, data } = parsed.data;
-      const context = this._context;
-      switch (event) {
-        case "initial-storage": {
-          const room = data.room;
-          const storage = typeof room === "string" ? (_d = yield (_c = this._getInitialStorage) == null ? void 0 : _c.call(this, { context, room })) != null ? _d : null : null;
-          return c.json({ data: { storage } }, 200);
-        }
-        case "room-deleted": {
-          const room = data.room;
-          const encodedState = data.storage;
-          yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, 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((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
-          return c.json({ data: { ok: true } }, 200);
-        }
-        case "user-disconnected": {
-          const room = data.room;
-          const encodedState = data.storage;
-          const user = data.user;
-          yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
-          return c.json({ data: { ok: true } }, 200);
+      try {
+        if (!this._webhookSecret) throw new HttpError("Unauthorized", 401);
+        if (algorithm !== SIGNATURE_ALGORITHM) throw new HttpError("Unauthorized", 401);
+        if (!signature) throw new HttpError("Unauthorized", 401);
+        const payload = yield c.req.json();
+        const verified = yield verifyWebhook({
+          payload: stringify(payload),
+          signature,
+          secret: this._webhookSecret
+        });
+        if (!verified) throw new HttpError("Unauthorized", 401);
+        const parsed = ZodEvent.safeParse(payload);
+        if (!parsed.success) throw new HttpError("Invalid request", 400);
+        const { event, data } = parsed.data;
+        const context = this._context;
+        switch (event) {
+          case "initial-storage": {
+            const room = data.room;
+            const storage = typeof room === "string" ? (_d = yield (_c = this._getInitialStorage) == null ? void 0 : _c.call(this, { context, room })) != null ? _d : null : null;
+            return createSuccessResponse(c, { event, room, storage });
+          }
+          case "room-deleted": {
+            const room = data.room;
+            const encodedState = data.storage;
+            yield Promise.resolve((_e = this._listeners) == null ? void 0 : _e.onRoomDeleted({ context, encodedState, room }));
+            return createSuccessResponse(c, { event, room });
+          }
+          case "user-connected": {
+            const room = data.room;
+            const encodedState = data.storage;
+            const user = data.user;
+            yield Promise.resolve((_f = this._listeners) == null ? void 0 : _f.onUserConnected({ context, encodedState, room, user }));
+            return createSuccessResponse(c, { event, room });
+          }
+          case "user-disconnected": {
+            const room = data.room;
+            const encodedState = data.storage;
+            const user = data.user;
+            yield Promise.resolve((_g = this._listeners) == null ? void 0 : _g.onUserDisconnected({ context, encodedState, room, user }));
+            return createSuccessResponse(c, { event, room });
+          }
+          default: {
+            throw new HttpError("Unknown event", 400);
+          }
         }
-        default:
-          return c.json({ data: { ok: true } }, 200);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unexpected error";
+        const status = error instanceof HttpError ? error.status : 500;
+        return createErrorResponse(c, { message }, status);
       }
     }));
     const { _defs, context, basePath, publicKey, secretKey, webhookSecret } = params;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-pluv",
-  "version": "0.38.8",
+  "version": "0.38.10",
   "description": "@pluv/io adapter for pluv.io",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,20 +17,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^22.13.10",
+    "@types/node": "^22.14.0",
     "fast-json-stable-stringify": "^2.1.0",
-    "hono": "^4.7.4",
+    "hono": "^4.7.5",
     "zod": "^3.24.2",
-    "@pluv/crdt": "^0.38.8",
-    "@pluv/io": "^0.38.8",
-    "@pluv/types": "^0.38.8"
+    "@pluv/crdt": "^0.38.10",
+    "@pluv/io": "^0.38.10",
+    "@pluv/types": "^0.38.10"
   },
   "devDependencies": {
     "eslint": "^8.57.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
-    "@pluv/tsconfig": "^0.38.8",
-    "eslint-config-pluv": "^0.38.8"
+    "@pluv/tsconfig": "^0.38.10",
+    "eslint-config-pluv": "^0.38.10"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/PluvPlatform.ts

@@ -14,7 +14,7 @@ import { Hono } from "hono";
 import type { BlankEnv, BlankInput } from "hono/types";
 import { SIGNATURE_ALGORITHM, SIGNATURE_HEADER } from "./constants";
 import { ZodEvent } from "./schemas";
-import { verifyWebhook } from "./shared";
+import { createErrorResponse, createSuccessResponse, HttpError, verifyWebhook } from "./shared";
 import type { PluvIOEndpoints, PluvIOListeners } from "./types";
 
 export interface PluvPlatformConfig<TContext extends Record<string, any> = {}> {
@@ -194,64 +194,74 @@ export class PluvPlatform<
     private _webhooksRouter = new Hono().basePath("/").post("/", async (c: Context<BlankEnv, "/", BlankInput>) => {
         const [algorithm, signature] = c.req.header(SIGNATURE_HEADER)?.split("=") ?? [];
 
-        if (!this._webhookSecret) return c.json({ error: "Unauthorized" }, 401);
-        if (algorithm !== SIGNATURE_ALGORITHM) return c.json({ error: "Unauthorized" }, 401);
-        if (!signature) return c.json({ error: "Unauthorized" }, 401);
+        try {
+            if (!this._webhookSecret) throw new HttpError("Unauthorized", 401);
+            if (algorithm !== SIGNATURE_ALGORITHM) throw new HttpError("Unauthorized", 401);
+            if (!signature) throw new HttpError("Unauthorized", 401);
 
-        const payload = await c.req.json();
+            const payload = await c.req.json();
 
-        const verified = await verifyWebhook({
-            payload: stringify(payload),
-            signature,
-            secret: this._webhookSecret,
-        });
+            const verified = await verifyWebhook({
+                payload: stringify(payload),
+                signature,
+                secret: this._webhookSecret,
+            });
 
-        if (!verified) return c.json({ error: "Unauthorized" }, 401);
+            if (!verified) throw new HttpError("Unauthorized", 401);
 
-        const parsed = ZodEvent.safeParse(payload);
+            const parsed = ZodEvent.safeParse(payload);
 
-        if (!parsed.success) return c.json({ data: { ok: true } }, 200);
+            if (!parsed.success) throw new HttpError("Invalid request", 400);
 
-        const { event, data } = parsed.data;
+            const { event, data } = parsed.data;
 
-        const context = this._context;
+            const context = this._context;
 
-        switch (event) {
-            case "initial-storage": {
-                const room = data.room;
-                const storage =
-                    typeof room === "string" ? ((await this._getInitialStorage?.({ context, room })) ?? null) : null;
+            switch (event) {
+                case "initial-storage": {
+                    const room = data.room;
+                    const storage =
+                        typeof room === "string"
+                            ? ((await this._getInitialStorage?.({ context, room })) ?? null)
+                            : null;
 
-                return c.json({ data: { storage } }, 200);
-            }
-            case "room-deleted": {
-                const room = data.room;
-                const encodedState = data.storage;
+                    return createSuccessResponse(c, { event, room, storage });
+                }
+                case "room-deleted": {
+                    const room = data.room;
+                    const encodedState = data.storage;
 
-                await Promise.resolve(this._listeners?.onRoomDeleted({ context, encodedState, room }));
+                    await Promise.resolve(this._listeners?.onRoomDeleted({ context, encodedState, room }));
 
-                return c.json({ data: { room } }, 200);
-            }
-            case "user-connected": {
-                const room = data.room;
-                const encodedState = data.storage;
-                const user = data.user as any;
+                    return createSuccessResponse(c, { event, room });
+                }
+                case "user-connected": {
+                    const room = data.room;
+                    const encodedState = data.storage;
+                    const user = data.user as any;
 
-                await Promise.resolve(this._listeners?.onUserConnected({ context, encodedState, room, user }));
+                    await Promise.resolve(this._listeners?.onUserConnected({ context, encodedState, room, user }));
 
-                return c.json({ data: { ok: true } }, 200);
-            }
-            case "user-disconnected": {
-                const room = data.room;
-                const encodedState = data.storage;
-                const user = data.user as any;
+                    return createSuccessResponse(c, { event, room });
+                }
+                case "user-disconnected": {
+                    const room = data.room;
+                    const encodedState = data.storage;
+                    const user = data.user as any;
 
-                await Promise.resolve(this._listeners?.onUserDisconnected({ context, encodedState, room, user }));
+                    await Promise.resolve(this._listeners?.onUserDisconnected({ context, encodedState, room, user }));
 
-                return c.json({ data: { ok: true } }, 200);
+                    return createSuccessResponse(c, { event, room });
+                }
+                default: {
+                    throw new HttpError("Unknown event", 400);
+                }
             }
-            default:
-                return c.json({ data: { ok: true } }, 200);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : "Unexpected error";
+            const status = error instanceof HttpError ? error.status : 500;
+
+            return createErrorResponse(c, { message }, status);
         }
     });
 }

package/src/schemas.ts

@@ -1,13 +1,20 @@
 import { z } from "zod";
 
-const ZodEventInitialStorage = z.object({
+export const ZodEventKind = z.union([
+    z.literal("initial-storage"),
+    z.literal("room-deleted"),
+    z.literal("user-connected"),
+    z.literal("user-disconnected"),
+]);
+
+export const ZodEventInitialStorage = z.object({
     event: z.literal("initial-storage"),
     data: z.object({
-        room: z.string().nullable(),
+        room: z.string(),
     }),
 });
 
-const ZodEventRoomDeleted = z.object({
+export const ZodEventRoomDeleted = z.object({
     event: z.literal("room-deleted"),
     data: z.object({
         room: z.string(),
@@ -15,7 +22,7 @@ const ZodEventRoomDeleted = z.object({
     }),
 });
 
-const ZodEventUserConnected = z.object({
+export const ZodEventUserConnected = z.object({
     event: z.literal("user-connected"),
     data: z.object({
         room: z.string(),
@@ -28,7 +35,7 @@ const ZodEventUserConnected = z.object({
     }),
 });
 
-const ZodEventUserDisconnected = z.object({
+export const ZodEventUserDisconnected = z.object({
     event: z.literal("user-disconnected"),
     data: z.object({
         room: z.string(),
@@ -47,3 +54,31 @@ export const ZodEvent = z.discriminatedUnion("event", [
     ZodEventUserConnected,
     ZodEventUserDisconnected,
 ]);
+
+export const ZodInitialStorageResponse = z.object({
+    event: z.literal("initial-storage"),
+    room: z.string(),
+    storage: z.string().nullable(),
+});
+
+export const ZodRoomDeletedResponse = z.object({
+    event: z.literal("room-deleted"),
+    room: z.string(),
+});
+
+export const ZodUserConnectedResponse = z.object({
+    event: z.literal("user-connected"),
+    room: z.string(),
+});
+
+export const ZodUserDisconnectedResponse = z.object({
+    event: z.literal("user-disconnected"),
+    room: z.string(),
+});
+
+export const ZodEventResponse = z.discriminatedUnion("event", [
+    ZodInitialStorageResponse,
+    ZodRoomDeletedResponse,
+    ZodUserConnectedResponse,
+    ZodUserDisconnectedResponse,
+]);

package/src/shared/HttpError.ts

@@ -0,0 +1,11 @@
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+
+export class HttpError extends Error {
+    readonly status: ContentfulStatusCode;
+
+    constructor(message: string, status: ContentfulStatusCode) {
+        super(message);
+
+        this.status = status;
+    }
+}

package/src/shared/createErrorResponse.ts

@@ -0,0 +1,11 @@
+import type { Context } from "hono";
+import type { BlankEnv, BlankInput } from "hono/types";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+
+export const createErrorResponse = <TStatus extends ContentfulStatusCode>(
+    c: Context<BlankEnv, "/", BlankInput>,
+    error: { message: string },
+    status: TStatus,
+) => {
+    return c.json({ ok: false, error: { message: error.message } }, status);
+};

package/src/shared/createSuccessResponse.ts

@@ -0,0 +1,24 @@
+import type { Context } from "hono";
+import type { BlankEnv, BlankInput } from "hono/types";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { ZodEventResponse } from "../schemas";
+import type { EventResponse } from "../types";
+
+export interface CreateSuccessResponseParams<TStatus extends ContentfulStatusCode> {
+    data: EventResponse;
+    status?: TStatus;
+}
+
+export const createSuccessResponse = <TStatus extends ContentfulStatusCode = 200>(
+    c: Context<BlankEnv, "/", BlankInput>,
+    data: EventResponse,
+    status: TStatus = 200 as TStatus,
+) => {
+    return c.json(
+        {
+            ok: true,
+            data: ZodEventResponse.parse(data),
+        },
+        status,
+    );
+};

package/src/shared/index.ts

@@ -1,6 +1,11 @@
+export { createErrorResponse } from "./createErrorResponse";
+export type { CreateErrorResponseParams } from "./createErrorResponse";
 export { createHmac } from "./createHmac";
 export type { CreateHmacParams } from "./createHmac";
+export { createSuccessResponse } from "./createSuccessResponse";
+export type { CreateSuccessResponseParams } from "./createSuccessResponse";
 export { getCrypto } from "./getCrypto";
+export { HttpError } from "./HttpError";
 export { signWebhook } from "./signWebhook";
 export type { SignWebhookParams } from "./signWebhook";
 export { timingSafeEqual } from "./timingSafeEqual";

package/src/types.ts

@@ -6,7 +6,16 @@ import type {
     IOUserDisconnectedEvent,
 } from "@pluv/io";
 import type { InputZodLike } from "@pluv/types";
+import type { z } from "zod";
 import type { PluvPlatform } from "./PluvPlatform";
+import type {
+    ZodEventKind,
+    ZodEventResponse,
+    ZodInitialStorageResponse,
+    ZodRoomDeletedResponse,
+    ZodUserConnectedResponse,
+    ZodUserDisconnectedResponse,
+} from "./schemas";
 
 export interface PluvIOEndpoints {
     createToken: string;
@@ -22,3 +31,12 @@ export type PluvIOListeners<TContext extends Record<string, any> = {}, TUser ext
         event: IOUserDisconnectedEvent<PluvPlatform<TContext>, { user: InputZodLike<TUser> }, TContext>,
     ) => void;
 };
+
+export type EventKind = z.output<typeof ZodEventKind>;
+
+export type InitialStorageResponse = z.output<typeof ZodInitialStorageResponse>;
+export type RoomDeletedResponse = z.output<typeof ZodRoomDeletedResponse>;
+export type UserConnectedResponse = z.output<typeof ZodUserConnectedResponse>;
+export type UserDisconnectedResponse = z.output<typeof ZodUserDisconnectedResponse>;
+
+export type EventResponse = z.output<typeof ZodEventResponse>;