@cinnabun/core 0.0.1 → 0.0.2

package/dist/__tests__/websocket-validation.test.js

@@ -0,0 +1,827 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import "reflect-metadata";
+import { describe, it, expect, afterEach } from "bun:test";
+import { z } from "zod";
+import { CinnabunFactory } from "../core/cinnabun-factory.js";
+import { Service } from "../decorators/service.js";
+import { RestController } from "../decorators/rest-controller.js";
+import { GetMapping } from "../decorators/routes.js";
+import { CinnabunApplication as CinnabunAppDecorator } from "../decorators/cinnabun-application.js";
+import { WsGateway } from "../decorators/ws-gateway.js";
+import { WsEvent } from "../decorators/ws-event.js";
+import { EnableWebSocketMessageBroker } from "../decorators/websocket.js";
+let app = null;
+afterEach(async () => {
+    if (app) {
+        await app.close();
+        app = null;
+    }
+});
+// Helper to create WebSocket connection
+function createWsClient(port) {
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(`ws://localhost:${port}/ws`);
+        ws.onopen = () => resolve(ws);
+        ws.onerror = (err) => reject(err);
+        // Clean up listeners after connection
+        setTimeout(() => {
+            ws.onopen = null;
+            ws.onerror = null;
+        }, 100);
+    });
+}
+// Helper to wait for WebSocket message
+function waitForMessage(ws, timeout = 1000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            ws.onmessage = null;
+            reject(new Error("Message timeout"));
+        }, timeout);
+        ws.onmessage = (event) => {
+            clearTimeout(timer);
+            ws.onmessage = null;
+            const data = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
+            resolve(data);
+        };
+    });
+}
+describe("WebSocket Validation", () => {
+    describe("@WsGateway and @WsEvent", () => {
+        it("handles valid message with validation", async () => {
+            const MessageSchema = z.object({
+                text: z.string().min(1).max(100),
+                room: z.string(),
+            });
+            const receivedMessages = [];
+            let ChatGateway = class ChatGateway {
+                async handleMessage(data, _ws) {
+                    receivedMessages.push(data);
+                    return { success: true, received: data.text };
+                }
+            };
+            __decorate([
+                WsEvent("message:send", MessageSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [void 0, Object]),
+                __metadata("design:returntype", Promise)
+            ], ChatGateway.prototype, "handleMessage", null);
+            ChatGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ChatGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ChatGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send valid message
+            ws.send(JSON.stringify({
+                event: "message:send",
+                data: {
+                    text: "Hello, world!",
+                    room: "general",
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("response");
+            expect(response.event).toBe("message:send");
+            expect(response.data.success).toBe(true);
+            expect(response.data.received).toBe("Hello, world!");
+            expect(receivedMessages).toHaveLength(1);
+            expect(receivedMessages[0]).toEqual({
+                text: "Hello, world!",
+                room: "general",
+            });
+            ws.close();
+        });
+        it("rejects invalid message (missing field)", async () => {
+            const MessageSchema = z.object({
+                text: z.string().min(1),
+                room: z.string(),
+            });
+            let ChatGateway = class ChatGateway {
+                async handleMessage(data, _ws) {
+                    return { success: true };
+                }
+            };
+            __decorate([
+                WsEvent("message:send", MessageSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], ChatGateway.prototype, "handleMessage", null);
+            ChatGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ChatGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ChatGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send invalid message (missing 'room')
+            ws.send(JSON.stringify({
+                event: "message:send",
+                data: {
+                    text: "Hello",
+                    // Missing 'room' field
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("error");
+            expect(response.error).toBe("ValidationError");
+            expect(response.message).toContain("message:send");
+            expect(response.errors).toBeDefined();
+            expect(response.errors.room).toBeDefined();
+            expect(response.timestamp).toBeDefined();
+            ws.close();
+        });
+        it("rejects invalid message (validation failed)", async () => {
+            const MessageSchema = z.object({
+                text: z.string().min(5).max(100),
+                room: z.string(),
+            });
+            let ValidationTestGateway = class ValidationTestGateway {
+                async handleMessage(data, _ws) {
+                    return { success: true };
+                }
+            };
+            __decorate([
+                WsEvent("message:validated", MessageSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], ValidationTestGateway.prototype, "handleMessage", null);
+            ValidationTestGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ValidationTestGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ValidationTestGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send invalid message (text too short)
+            ws.send(JSON.stringify({
+                event: "message:validated",
+                data: {
+                    text: "Hi", // Too short (min 5)
+                    room: "general",
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("error");
+            expect(response.error).toBe("ValidationError");
+            expect(response.errors.text).toBeDefined();
+            ws.close();
+        });
+        it("rejects unknown event", async () => {
+            let ChatGateway = class ChatGateway {
+                async handleMessage(data, _ws) {
+                    return { success: true };
+                }
+            };
+            __decorate([
+                WsEvent("message:send"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], ChatGateway.prototype, "handleMessage", null);
+            ChatGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ChatGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ChatGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send unknown event
+            ws.send(JSON.stringify({
+                event: "unknown:event",
+                data: {},
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("error");
+            expect(response.error).toBe("UnknownEvent");
+            expect(response.message).toContain("unknown:event");
+            ws.close();
+        });
+        it("handles invalid JSON", async () => {
+            let ChatGateway = class ChatGateway {
+                async handleMessage(data, _ws) {
+                    return { success: true };
+                }
+            };
+            __decorate([
+                WsEvent("message:send"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], ChatGateway.prototype, "handleMessage", null);
+            ChatGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ChatGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ChatGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send invalid JSON
+            ws.send("not valid json");
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("error");
+            expect(response.error).toBe("ParseError");
+            expect(response.message).toContain("Invalid JSON");
+            ws.close();
+        });
+        it("handles event without validation schema", async () => {
+            const receivedData = [];
+            let NotificationGateway = class NotificationGateway {
+                async handleNotify(data, _ws) {
+                    receivedData.push(data);
+                    return { acknowledged: true };
+                }
+            };
+            __decorate([
+                WsEvent("notify"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], NotificationGateway.prototype, "handleNotify", null);
+            NotificationGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], NotificationGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [NotificationGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send event without schema
+            ws.send(JSON.stringify({
+                event: "notify",
+                data: {
+                    message: "Any data is accepted",
+                    arbitrary: 123,
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("response");
+            expect(response.data.acknowledged).toBe(true);
+            expect(receivedData).toHaveLength(1);
+            expect(receivedData[0]).toEqual({
+                message: "Any data is accepted",
+                arbitrary: 123,
+            });
+            ws.close();
+        });
+        it("handles multiple events in same gateway", async () => {
+            const JoinSchema = z.object({
+                room: z.string(),
+            });
+            const MessageSchema = z.object({
+                text: z.string(),
+            });
+            const events = [];
+            let MultiEventGateway = class MultiEventGateway {
+                async handleJoin(data, _ws) {
+                    events.push(`join:${data.room}`);
+                    return { joined: data.room };
+                }
+                async handleMessage(data, _ws) {
+                    events.push(`message:${data.text}`);
+                    return { sent: true };
+                }
+            };
+            __decorate([
+                WsEvent("room:join", JoinSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [void 0, Object]),
+                __metadata("design:returntype", Promise)
+            ], MultiEventGateway.prototype, "handleJoin", null);
+            __decorate([
+                WsEvent("message", MessageSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [void 0, Object]),
+                __metadata("design:returntype", Promise)
+            ], MultiEventGateway.prototype, "handleMessage", null);
+            MultiEventGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], MultiEventGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [MultiEventGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send join event
+            ws.send(JSON.stringify({
+                event: "room:join",
+                data: { room: "general" },
+            }));
+            let response = await waitForMessage(ws);
+            expect(response.data.joined).toBe("general");
+            // Send message event
+            ws.send(JSON.stringify({
+                event: "message",
+                data: { text: "Hello!" },
+            }));
+            response = await waitForMessage(ws);
+            expect(response.data.sent).toBe(true);
+            expect(events).toEqual(["join:general", "message:Hello!"]);
+            ws.close();
+        });
+        it("handler that returns undefined does not send response", async () => {
+            let SilentGateway = class SilentGateway {
+                async handleSilent(_data, _ws) {
+                    // Explicitly return undefined
+                    return undefined;
+                }
+            };
+            __decorate([
+                WsEvent("silent"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], SilentGateway.prototype, "handleSilent", null);
+            SilentGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], SilentGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [SilentGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            const connectedMsg = await waitForMessage(ws);
+            expect(connectedMsg.type).toBe("CONNECTED");
+            let messageReceived = false;
+            ws.onmessage = () => {
+                messageReceived = true;
+            };
+            // Send event
+            ws.send(JSON.stringify({
+                event: "silent",
+                data: {},
+            }));
+            // Wait a bit to ensure no message comes back
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(messageReceived).toBe(false);
+            ws.close();
+        });
+        it("handles handler errors gracefully", async () => {
+            let FailingGateway = class FailingGateway {
+                async handleFail(_data, _ws) {
+                    throw new Error("Handler failed");
+                }
+            };
+            __decorate([
+                WsEvent("fail"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object, Object]),
+                __metadata("design:returntype", Promise)
+            ], FailingGateway.prototype, "handleFail", null);
+            FailingGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], FailingGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [FailingGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send event that will cause error
+            ws.send(JSON.stringify({
+                event: "fail",
+                data: {},
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("error");
+            expect(response.error).toBe("InternalError");
+            expect(response.errorId).toBeDefined();
+            ws.close();
+        });
+    });
+    describe("Complex Validation", () => {
+        it("validates nested objects", async () => {
+            const ProfileSchema = z.object({
+                user: z.object({
+                    name: z.string().min(1),
+                    email: z.string().email(),
+                }),
+                settings: z.object({
+                    theme: z.enum(["light", "dark"]),
+                }),
+            });
+            let ProfileGateway = class ProfileGateway {
+                async updateProfile(data, _ws) {
+                    return { updated: true, user: data.user.name };
+                }
+            };
+            __decorate([
+                WsEvent("profile:update", ProfileSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [void 0, Object]),
+                __metadata("design:returntype", Promise)
+            ], ProfileGateway.prototype, "updateProfile", null);
+            ProfileGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], ProfileGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [ProfileGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send valid nested data
+            ws.send(JSON.stringify({
+                event: "profile:update",
+                data: {
+                    user: {
+                        name: "Alice",
+                        email: "alice@example.com",
+                    },
+                    settings: {
+                        theme: "dark",
+                    },
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("response");
+            expect(response.data.updated).toBe(true);
+            expect(response.data.user).toBe("Alice");
+            ws.close();
+        });
+        it("validates arrays", async () => {
+            const BatchSchema = z.object({
+                items: z.array(z.number()).min(1).max(10),
+            });
+            let BatchGateway = class BatchGateway {
+                async processBatch(data, _ws) {
+                    return { count: data.items.length };
+                }
+            };
+            __decorate([
+                WsEvent("batch:process", BatchSchema),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [void 0, Object]),
+                __metadata("design:returntype", Promise)
+            ], BatchGateway.prototype, "processBatch", null);
+            BatchGateway = __decorate([
+                WsGateway(),
+                Service()
+            ], BatchGateway);
+            let App = class App {
+                gateway;
+                constructor(gateway) {
+                    this.gateway = gateway;
+                }
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController(),
+                __metadata("design:paramtypes", [BatchGateway])
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send valid array
+            ws.send(JSON.stringify({
+                event: "batch:process",
+                data: {
+                    items: [1, 2, 3, 4, 5],
+                },
+            }));
+            const response = await waitForMessage(ws);
+            expect(response.type).toBe("response");
+            expect(response.data.count).toBe(5);
+            ws.close();
+        });
+    });
+    describe("Backward Compatibility", () => {
+        it("still supports destination-based messages", async () => {
+            let App = class App {
+                index() {
+                    return { status: "ok" };
+                }
+            };
+            __decorate([
+                GetMapping("/"),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], App.prototype, "index", null);
+            App = __decorate([
+                CinnabunAppDecorator({ port: 0, scanPaths: [] }),
+                EnableWebSocketMessageBroker({
+                    broker: ["/topic"],
+                    appDestinationPrefixes: ["/app"],
+                    endpoints: ["/ws"],
+                }),
+                RestController()
+            ], App);
+            app = await CinnabunFactory.run(App);
+            await app.listen(0);
+            const port = app.getPort();
+            const ws = await createWsClient(port);
+            // Skip CONNECTED message
+            await waitForMessage(ws);
+            // Send old-style destination message
+            ws.send(JSON.stringify({
+                destination: "/app/unknown",
+                body: { test: "data" },
+            }));
+            const response = await waitForMessage(ws);
+            // Should get error for unknown destination (old behavior)
+            expect(response.type).toBe("ERROR");
+            ws.close();
+        });
+    });
+});
+//# sourceMappingURL=websocket-validation.test.js.map