sonamu 0.9.5 → 0.9.7

package/dist/utils/utils.js

@@ -92,5 +92,5 @@ var init_utils = __esmMin((() => {}));
 
 //#endregion
 init_utils();
-export { assertDefined, assertExists, assertNotNull, convertFastifyHeadersToStandard, differenceWith, exhaustive, findApiRootPath, findAppRootPath, init_utils, intersectionBy, merge, nonNullable };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils/utils.ts"],"sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\n\nimport { type FastifyRequest } from \"fastify\";\n\nimport { type AbsolutePath } from \"./path-utils\";\n\nexport function findAppRootPath(): AbsolutePath {\n  const apiRootPath = findApiRootPath();\n  return path.dirname(apiRootPath) as AbsolutePath;\n}\n\nexport function findApiRootPath(): AbsolutePath {\n  // NOTE: for support npm / yarn / pnpm workspaces\n  // 하지만 workspace 쓰면 process.cwd() 하면 되는데... 이건 나중에 협의 후 수정하는걸로\n  const workspacePath = process.env.PNPM_SCRIPT_SRC_DIR ?? process.env.INIT_CWD;\n  if (nonNullable(workspacePath)) {\n    return workspacePath as AbsolutePath;\n  }\n\n  if (nonNullable(process.env.PNPM_PACKAGE_NAME)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const cwdPackagePath = path.join(process.cwd(), \"package.json\");\n  if (fs.existsSync(cwdPackagePath)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const basePath = import.meta.filename;\n  let dir = path.dirname(basePath);\n  if (dir.includes(\"/.yarn/\")) {\n    dir = dir.split(\"/.yarn/\")[0];\n  }\n\n  do {\n    if (fs.existsSync(path.join(dir, \"/package.json\"))) {\n      return dir.split(path.sep).join(path.sep) as AbsolutePath;\n    }\n    dir = dir.split(path.sep).slice(0, -1).join(path.sep);\n  } while (dir.split(path.sep).length > 1);\n  throw new Error(\"Cannot find AppRoot using Sonamu -2\");\n}\n\nexport function nonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== null && value !== undefined;\n}\n\nexport function exhaustive(_param: never) {\n  throw new Error(`exhaustive`);\n}\n\n// 일반 버전\nexport function assertExists<T>(value: T | null | undefined, message?: string): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? \"Value must exist\");\n  }\n  return value;\n}\n\n// null만 체크\nexport function assertNotNull<T>(value: T | null, message?: string): T {\n  if (value === null) {\n    throw new Error(message ?? \"Value must not be null\");\n  }\n  return value;\n}\n// undefined만 체크\nexport function assertDefined<T>(value: T | undefined, message?: string): T {\n  if (value === undefined) {\n    throw new Error(message ?? \"Value must be defined\");\n  }\n  return value;\n}\n\n// lodash intersectionBy 대체\nexport function intersectionBy<T, K>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  iteratee: (item: T) => K,\n): T[] {\n  const arr2Keys = new Set(arr2.map(iteratee));\n  return arr1.filter((item) => arr2Keys.has(iteratee(item)));\n}\n// lodash differenceWith 대체\nexport function differenceWith<T>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  comparator: (a: T, b: T) => boolean,\n): T[] {\n  return arr1.filter((itemA) => !arr2.some((itemB) => comparator(itemA, itemB)));\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: dynamic property access\nexport function merge<T extends Record<string, any>>(defaultObj: T, userObj: T): T {\n  // 원본 보존을 위해 defaultObj 복사\n  const result = { ...defaultObj };\n\n  // userObj의 각 속성을 순회\n  for (const key in userObj) {\n    // userObj의 own property만 처리 (프로토타입 체인 제외)\n    if (Object.hasOwn(userObj, key)) {\n      const userValue = userObj[key];\n      const defaultValue = result[key];\n\n      // 두 값이 모두 객체이고, 배열이 아닌 경우 재귀적으로 병합\n      if (isPlainObject(userValue) && isPlainObject(defaultValue)) {\n        result[key] = merge(defaultValue, userValue);\n      } else {\n        // 그 외의 경우 userObj의 값으로 덮어쓰기\n        result[key] = userValue;\n      }\n    }\n  }\n\n  return result;\n}\n\n// plain object 판별 헬퍼 함수\n// (배열, null, Date 등을 제외한 순수 객체만 true)\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.prototype.toString.call(value) === \"[object Object]\"\n  );\n}\n\n// Convert Fastify headers to standard Headers object\nexport function convertFastifyHeadersToStandard(headers: FastifyRequest[\"headers\"]): Headers {\n  const headersObj = new Headers();\n  Object.entries(headers).forEach(([key, value]) => {\n    if (value) headersObj.append(key, value.toString());\n  });\n  return headersObj;\n}\n"],"mappings":";;;;;AAOA,SAAgB,kBAAgC;CAC9C,MAAM,cAAc,iBAAiB;AACrC,QAAO,KAAK,QAAQ,YAAY;;AAGlC,SAAgB,kBAAgC;CAG9C,MAAM,gBAAgB,QAAQ,IAAI,uBAAuB,QAAQ,IAAI;AACrE,KAAI,YAAY,cAAc,EAAE;AAC9B,SAAO;;AAGT,KAAI,YAAY,QAAQ,IAAI,kBAAkB,EAAE;AAC9C,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,KAAK,EAAE,eAAe;AAC/D,KAAI,GAAG,WAAW,eAAe,EAAE;AACjC,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,WAAW,OAAO,KAAK;CAC7B,IAAI,MAAM,KAAK,QAAQ,SAAS;AAChC,KAAI,IAAI,SAAS,UAAU,EAAE;AAC3B,QAAM,IAAI,MAAM,UAAU,CAAC;;AAG7B,IAAG;AACD,MAAI,GAAG,WAAW,KAAK,KAAK,KAAK,gBAAgB,CAAC,EAAE;AAClD,UAAO,IAAI,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;AAE3C,QAAM,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI;UAC9C,IAAI,MAAM,KAAK,IAAI,CAAC,SAAS;AACtC,OAAM,IAAI,MAAM,sCAAsC;;AAGxD,SAAgB,YAAe,OAAmC;AAChE,QAAO,UAAU,QAAQ,UAAU;;AAGrC,SAAgB,WAAW,QAAe;AACxC,OAAM,IAAI,MAAM,aAAa;;AAI/B,SAAgB,aAAgB,OAA6B,SAAqB;AAChF,KAAI,UAAU,QAAQ,UAAU,WAAW;AACzC,QAAM,IAAI,MAAM,WAAW,mBAAmB;;AAEhD,QAAO;;AAIT,SAAgB,cAAiB,OAAiB,SAAqB;AACrE,KAAI,UAAU,MAAM;AAClB,QAAM,IAAI,MAAM,WAAW,yBAAyB;;AAEtD,QAAO;;AAGT,SAAgB,cAAiB,OAAsB,SAAqB;AAC1E,KAAI,UAAU,WAAW;AACvB,QAAM,IAAI,MAAM,WAAW,wBAAwB;;AAErD,QAAO;;AAIT,SAAgB,eACd,MACA,MACA,UACK;CACL,MAAM,WAAW,IAAI,IAAI,KAAK,IAAI,SAAS,CAAC;AAC5C,QAAO,KAAK,QAAQ,SAAS,SAAS,IAAI,SAAS,KAAK,CAAC,CAAC;;AAG5D,SAAgB,eACd,MACA,MACA,YACK;AACL,QAAO,KAAK,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,WAAW,OAAO,MAAM,CAAC,CAAC;;AAIhF,SAAgB,MAAqC,YAAe,SAAe;CAEjF,MAAM,SAAS,EAAE,GAAG,YAAY;AAGhC,MAAK,MAAM,OAAO,SAAS;AAEzB,MAAI,OAAO,OAAO,SAAS,IAAI,EAAE;GAC/B,MAAM,YAAY,QAAQ;GAC1B,MAAM,eAAe,OAAO;AAG5B,OAAI,cAAc,UAAU,IAAI,cAAc,aAAa,EAAE;AAC3D,WAAO,OAAO,MAAM,cAAc,UAAU;UACvC;AAEL,WAAO,OAAO;;;;AAKpB,QAAO;;AAKT,SAAS,cAAc,OAAkD;AACvE,QACE,UAAU,QACV,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,MAAM,IACrB,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK;;AAK9C,SAAgB,gCAAgC,SAA6C;CAC3F,MAAM,aAAa,IAAI,SAAS;AAChC,QAAO,QAAQ,QAAQ,CAAC,SAAS,CAAC,KAAK,WAAW;AAChD,MAAI,MAAO,YAAW,OAAO,KAAK,MAAM,UAAU,CAAC;GACnD;AACF,QAAO"}
+export { assertDefined, assertExists, assertNotNull, convertFastifyHeadersToStandard, differenceWith, exhaustive, findApiRootPath, findAppRootPath, init_utils, intersectionBy, isPlainObject, merge, nonNullable };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils/utils.ts"],"sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\n\nimport { type FastifyRequest } from \"fastify\";\n\nimport { type AbsolutePath } from \"./path-utils\";\n\nexport function findAppRootPath(): AbsolutePath {\n  const apiRootPath = findApiRootPath();\n  return path.dirname(apiRootPath) as AbsolutePath;\n}\n\nexport function findApiRootPath(): AbsolutePath {\n  // NOTE: for support npm / yarn / pnpm workspaces\n  // 하지만 workspace 쓰면 process.cwd() 하면 되는데... 이건 나중에 협의 후 수정하는걸로\n  const workspacePath = process.env.PNPM_SCRIPT_SRC_DIR ?? process.env.INIT_CWD;\n  if (nonNullable(workspacePath)) {\n    return workspacePath as AbsolutePath;\n  }\n\n  if (nonNullable(process.env.PNPM_PACKAGE_NAME)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const cwdPackagePath = path.join(process.cwd(), \"package.json\");\n  if (fs.existsSync(cwdPackagePath)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const basePath = import.meta.filename;\n  let dir = path.dirname(basePath);\n  if (dir.includes(\"/.yarn/\")) {\n    dir = dir.split(\"/.yarn/\")[0];\n  }\n\n  do {\n    if (fs.existsSync(path.join(dir, \"/package.json\"))) {\n      return dir.split(path.sep).join(path.sep) as AbsolutePath;\n    }\n    dir = dir.split(path.sep).slice(0, -1).join(path.sep);\n  } while (dir.split(path.sep).length > 1);\n  throw new Error(\"Cannot find AppRoot using Sonamu -2\");\n}\n\nexport function nonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== null && value !== undefined;\n}\n\nexport function exhaustive(_param: never) {\n  throw new Error(`exhaustive`);\n}\n\n// 일반 버전\nexport function assertExists<T>(value: T | null | undefined, message?: string): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? \"Value must exist\");\n  }\n  return value;\n}\n\n// null만 체크\nexport function assertNotNull<T>(value: T | null, message?: string): T {\n  if (value === null) {\n    throw new Error(message ?? \"Value must not be null\");\n  }\n  return value;\n}\n// undefined만 체크\nexport function assertDefined<T>(value: T | undefined, message?: string): T {\n  if (value === undefined) {\n    throw new Error(message ?? \"Value must be defined\");\n  }\n  return value;\n}\n\n// lodash intersectionBy 대체\nexport function intersectionBy<T, K>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  iteratee: (item: T) => K,\n): T[] {\n  const arr2Keys = new Set(arr2.map(iteratee));\n  return arr1.filter((item) => arr2Keys.has(iteratee(item)));\n}\n// lodash differenceWith 대체\nexport function differenceWith<T>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  comparator: (a: T, b: T) => boolean,\n): T[] {\n  return arr1.filter((itemA) => !arr2.some((itemB) => comparator(itemA, itemB)));\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: dynamic property access\nexport function merge<T extends Record<string, any>>(defaultObj: T, userObj: T): T {\n  // 원본 보존을 위해 defaultObj 복사\n  const result = { ...defaultObj };\n\n  // userObj의 각 속성을 순회\n  for (const key in userObj) {\n    // userObj의 own property만 처리 (프로토타입 체인 제외)\n    if (Object.hasOwn(userObj, key)) {\n      const userValue = userObj[key];\n      const defaultValue = result[key];\n\n      // 두 값이 모두 객체이고, 배열이 아닌 경우 재귀적으로 병합\n      if (isPlainObject(userValue) && isPlainObject(defaultValue)) {\n        result[key] = merge(defaultValue, userValue);\n      } else {\n        // 그 외의 경우 userObj의 값으로 덮어쓰기\n        result[key] = userValue;\n      }\n    }\n  }\n\n  return result;\n}\n\n// plain object 판별 헬퍼 함수\n// (배열, null, Date 등을 제외한 순수 객체만 true)\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.prototype.toString.call(value) === \"[object Object]\"\n  );\n}\n\n// Convert Fastify headers to standard Headers object\nexport function convertFastifyHeadersToStandard(headers: FastifyRequest[\"headers\"]): Headers {\n  const headersObj = new Headers();\n  Object.entries(headers).forEach(([key, value]) => {\n    if (value) headersObj.append(key, value.toString());\n  });\n  return headersObj;\n}\n"],"mappings":";;;;;AAOA,SAAgB,kBAAgC;CAC9C,MAAM,cAAc,iBAAiB;AACrC,QAAO,KAAK,QAAQ,YAAY;;AAGlC,SAAgB,kBAAgC;CAG9C,MAAM,gBAAgB,QAAQ,IAAI,uBAAuB,QAAQ,IAAI;AACrE,KAAI,YAAY,cAAc,EAAE;AAC9B,SAAO;;AAGT,KAAI,YAAY,QAAQ,IAAI,kBAAkB,EAAE;AAC9C,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,KAAK,EAAE,eAAe;AAC/D,KAAI,GAAG,WAAW,eAAe,EAAE;AACjC,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,WAAW,OAAO,KAAK;CAC7B,IAAI,MAAM,KAAK,QAAQ,SAAS;AAChC,KAAI,IAAI,SAAS,UAAU,EAAE;AAC3B,QAAM,IAAI,MAAM,UAAU,CAAC;;AAG7B,IAAG;AACD,MAAI,GAAG,WAAW,KAAK,KAAK,KAAK,gBAAgB,CAAC,EAAE;AAClD,UAAO,IAAI,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;AAE3C,QAAM,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI;UAC9C,IAAI,MAAM,KAAK,IAAI,CAAC,SAAS;AACtC,OAAM,IAAI,MAAM,sCAAsC;;AAGxD,SAAgB,YAAe,OAAmC;AAChE,QAAO,UAAU,QAAQ,UAAU;;AAGrC,SAAgB,WAAW,QAAe;AACxC,OAAM,IAAI,MAAM,aAAa;;AAI/B,SAAgB,aAAgB,OAA6B,SAAqB;AAChF,KAAI,UAAU,QAAQ,UAAU,WAAW;AACzC,QAAM,IAAI,MAAM,WAAW,mBAAmB;;AAEhD,QAAO;;AAIT,SAAgB,cAAiB,OAAiB,SAAqB;AACrE,KAAI,UAAU,MAAM;AAClB,QAAM,IAAI,MAAM,WAAW,yBAAyB;;AAEtD,QAAO;;AAGT,SAAgB,cAAiB,OAAsB,SAAqB;AAC1E,KAAI,UAAU,WAAW;AACvB,QAAM,IAAI,MAAM,WAAW,wBAAwB;;AAErD,QAAO;;AAIT,SAAgB,eACd,MACA,MACA,UACK;CACL,MAAM,WAAW,IAAI,IAAI,KAAK,IAAI,SAAS,CAAC;AAC5C,QAAO,KAAK,QAAQ,SAAS,SAAS,IAAI,SAAS,KAAK,CAAC,CAAC;;AAG5D,SAAgB,eACd,MACA,MACA,YACK;AACL,QAAO,KAAK,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,WAAW,OAAO,MAAM,CAAC,CAAC;;AAIhF,SAAgB,MAAqC,YAAe,SAAe;CAEjF,MAAM,SAAS,EAAE,GAAG,YAAY;AAGhC,MAAK,MAAM,OAAO,SAAS;AAEzB,MAAI,OAAO,OAAO,SAAS,IAAI,EAAE;GAC/B,MAAM,YAAY,QAAQ;GAC1B,MAAM,eAAe,OAAO;AAG5B,OAAI,cAAc,UAAU,IAAI,cAAc,aAAa,EAAE;AAC3D,WAAO,OAAO,MAAM,cAAc,UAAU;UACvC;AAEL,WAAO,OAAO;;;;AAKpB,QAAO;;AAKT,SAAgB,cAAc,OAAkD;AAC9E,QACE,UAAU,QACV,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,MAAM,IACrB,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK;;AAK9C,SAAgB,gCAAgC,SAA6C;CAC3F,MAAM,aAAa,IAAI,SAAS;AAChC,QAAO,QAAQ,QAAQ,CAAC,SAAS,CAAC,KAAK,WAAW;AAChD,MAAI,MAAO,YAAW,OAAO,KAAK,MAAM,UAAU,CAAC;GACnD;AACF,QAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",
@@ -95,11 +95,13 @@
     "@fastify/multipart": "^8",
     "@fastify/passport": "^2.2.0",
     "@fastify/static": "^7",
+    "@fastify/websocket": "^8.3.0",
     "@logtape/fastify": "2.0.0",
     "@logtape/logtape": "2.0.0",
     "@logtape/pretty": "2.0.0",
     "@logtape/redaction": "2.0.0",
     "@sheetkit/node": "^0.5.0",
+    "@types/ws": "^8.18.1",
     "bcrypt": "^6.0.0",
     "bentocache": "^1.5.0",
     "better-auth": "~1.6.0",

package/src/api/__tests__/sonamu.websocket.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import { type AnyWebSocketConnection } from "../../stream/ws";
+import { type WebSocketContext } from "../context";
+import { Sonamu } from "../sonamu";
+
+describe("Sonamu websocket context scoping", () => {
+  it("restores websocket context inside deferred message handlers", async () => {
+    const messageHandlers = new Map<string, (data: unknown) => void | Promise<void>>();
+
+    const rawWs = {
+      id: "ws-1",
+      namespace: "chat",
+      transport: "ws" as const,
+      closed: false,
+      publishUntyped() {},
+      close() {},
+      onClose() {},
+      onMessage(event, handler) {
+        messageHandlers.set(String(event), handler as (data: unknown) => void | Promise<void>);
+      },
+      publish() {},
+      waitForClose() {
+        return Promise.resolve();
+      },
+      join() {},
+      leave() {},
+      setUserId() {},
+      clearUserId() {},
+    } satisfies AnyWebSocketConnection;
+
+    let context: WebSocketContext | null = null;
+    const scopedWs = (
+      Sonamu as unknown as {
+        createScopedWebSocketConnection(
+          ws: AnyWebSocketConnection,
+          getContext: () => WebSocketContext | null,
+        ): AnyWebSocketConnection;
+      }
+    ).createScopedWebSocketConnection(rawWs, () => context);
+
+    context = {
+      transport: "ws",
+      request: {} as WebSocketContext["request"],
+      headers: {},
+      ws: scopedWs,
+      naiteStore: new Map(),
+      locale: "ko",
+      user: null,
+      session: null,
+    };
+
+    let seenTransport: WebSocketContext["transport"] | null = null;
+    scopedWs.onMessage("joinRoom", async () => {
+      seenTransport = Sonamu.getContext<WebSocketContext>().transport;
+    });
+
+    await messageHandlers.get("joinRoom")?.({
+      roomId: "room-1",
+    });
+
+    expect(seenTransport).toBe("ws");
+  });
+});

package/src/api/__tests__/websocket-context.types.test.ts

@@ -0,0 +1,58 @@
+import { describe, expectTypeOf, it } from "vitest";
+
+import { type WebSocketContext } from "../context";
+
+type ChatOutEvents = {
+  ready: {
+    history: string[];
+  };
+  typingUsers: Array<{
+    id: string;
+    name: string;
+  }>;
+};
+
+type ChatInEvents = {
+  sendMessage: {
+    content: string;
+  };
+  typing: {
+    active: boolean;
+  };
+};
+
+function assertTypedWebSocketContext(ctx: WebSocketContext<ChatOutEvents, ChatInEvents>) {
+  ctx.ws.onMessage("sendMessage", (data) => {
+    expectTypeOf(data).toEqualTypeOf<{ content: string }>();
+    expectTypeOf(data.content).toEqualTypeOf<string>();
+  });
+
+  ctx.ws.onMessage("typing", (data) => {
+    expectTypeOf(data).toEqualTypeOf<{ active: boolean }>();
+    expectTypeOf(data.active).toEqualTypeOf<boolean>();
+  });
+
+  ctx.ws.publish("ready", { history: ["hello"] });
+  ctx.ws.publish("typingUsers", [{ id: "u1", name: "Kim" }]);
+
+  // @ts-expect-error invalid inbound event name
+  ctx.ws.onMessage("unknown", () => {});
+  // @ts-expect-error invalid outbound payload
+  ctx.ws.publish("ready", { nope: true });
+}
+
+function assertDefaultWebSocketContext(ctx: WebSocketContext) {
+  ctx.ws.onMessage("sendMessage", (data) => {
+    expectTypeOf(data).toEqualTypeOf<unknown>();
+  });
+}
+
+describe("WebSocketContext typing", () => {
+  it("narrows ws handlers and publish payloads from generic event maps", () => {
+    expectTypeOf(assertTypedWebSocketContext).toBeFunction();
+  });
+
+  it("defaults handler payloads to unknown when generics are omitted", () => {
+    expectTypeOf(assertDefaultWebSocketContext).toBeFunction();
+  });
+});

package/src/api/config.ts

@@ -3,6 +3,7 @@ import { type FastifyCorsOptions } from "@fastify/cors";
 import { type FastifyFormbodyOptions } from "@fastify/formbody";
 import { type FastifyMultipartOptions } from "@fastify/multipart";
 import { type FastifyStaticOptions } from "@fastify/static";
+import { type WebsocketPluginOptions } from "@fastify/websocket";
 import { type BetterAuthOptions } from "better-auth";
 import {
   type FastifyInstance,
@@ -18,9 +19,10 @@ import { type CacheConfig } from "../cache/types";
 import { type SonamuDBConfig } from "../database/db";
 import { type SonamuLoggingOptions } from "../logger/configure";
 import { type StorageConfig } from "../storage/types";
+import { type WebSocketRuntimeOptions } from "../stream/ws";
 import { type WorkflowOptions } from "../tasks/workflow-manager";
 import { type Executable, type SonamuFastifyConfig } from "../types/types";
-import { type Context } from "./context";
+import { type Context, type WebSocketContext } from "./context";
 
 export type DatabaseConfig = Omit<Knex.Config, "connection"> & {
   connection?: Knex.PgConnectionConfig;
@@ -180,6 +182,7 @@ export type SonamuServerOptions = {
     qs?: boolean | QsPluginOptions;
     sse?: boolean | SsePluginOptions;
     static?: boolean | FastifyStaticOptions;
+    ws?: boolean | WebsocketPluginOptions;
 
     custom?: (server: FastifyInstance) => void;
   };
@@ -200,6 +203,14 @@ export type SonamuServerOptions = {
     };
   };
 
+  /**
+   * WebSocket runtime 설정.
+   *
+   * 단일 인스턴스에서는 기본값으로 충분하며, 멀티 인스턴스/대규모 환경에서는
+   * presence store와 cluster bus를 여기서 주입합니다.
+   */
+  websocket?: WebSocketRuntimeOptions;
+
   apiConfig: SonamuFastifyConfig;
 
   /**
@@ -255,9 +266,24 @@ export type SonamuTaskOptions = {
   contextProvider: (
     defaultContext: Pick<
       Context,
-      "reply" | "request" | "headers" | "createSSE" | "naiteStore" | "locale" | "user" | "session"
+      | "transport"
+      | "reply"
+      | "request"
+      | "headers"
+      | "createSSE"
+      | "naiteStore"
+      | "locale"
+      | "user"
+      | "session"
     >,
   ) => Context | Promise<Context>;
+  websocketContextProvider?: (
+    defaultContext: Pick<
+      WebSocketContext,
+      "transport" | "request" | "headers" | "ws" | "naiteStore" | "locale" | "user" | "session"
+    >,
+    request: FastifyRequest,
+  ) => WebSocketContext | Promise<WebSocketContext>;
 };
 
 export type SonamuSSROptions = {

package/src/api/context.ts

@@ -14,24 +14,38 @@ import { type NaiteStore } from "../naite/naite";
 import { type BufferedFile } from "../storage/buffered-file";
 import { type UploadedFile } from "../storage/uploaded-file";
 import { type createSSEFactory } from "../stream/sse";
+import { type WebSocketConnection, type WebSocketEventMap } from "../stream/ws";
 
 // oxlint-disable-next-line @typescript-eslint/no-empty-interface -- Context 확장 타입
 export interface ContextExtend {}
-export type Context = {
+type BaseContext = {
   request: FastifyRequest;
-  reply: FastifyReply<Server, IncomingMessage, ServerResponse, RouteGenericInterface>;
   headers: IncomingHttpHeaders;
-  createSSE: <T extends ZodObject>(events: T) => ReturnType<typeof createSSEFactory<T>>;
   naiteStore: NaiteStore;
   /** 현재 요청의 locale */
   locale: string;
+  /** 현재 로그인한 사용자 (null이면 미인증) */
+  user: User | null;
+  /** 현재 세션 정보 (null이면 미인증) */
+  session: Session | null;
+};
+
+export type Context = BaseContext & {
+  transport: "http";
+  reply: FastifyReply<Server, IncomingMessage, ServerResponse, RouteGenericInterface>;
+  createSSE: <T extends ZodObject>(events: T) => ReturnType<typeof createSSEFactory<T>>;
   /** buffer 모드에서 업로드된 파일 */
   bufferedFiles?: BufferedFile[];
   /** stream 모드에서 업로드된 파일 */
   uploadedFiles?: UploadedFile[];
+} & ContextExtend;
 
-  /** 현재 로그인한 사용자 (null이면 미인증) */
-  user: User | null;
-  /** 현재 세션 정보 (null이면 미인증) */
-  session: Session | null;
+export type WebSocketContext<
+  TOut extends WebSocketEventMap = WebSocketEventMap,
+  TIn extends WebSocketEventMap = WebSocketEventMap,
+> = BaseContext & {
+  transport: "ws";
+  ws: WebSocketConnection<TOut, TIn>;
 } & ContextExtend;
+
+export type RuntimeContext = Context | WebSocketContext;

package/src/api/decorators.ts

@@ -53,7 +53,7 @@ export type ApiDecoratorOptions = {
   compress?: CompressConfig;
 };
 export type StreamDecoratorOptions = {
-  type: "sse"; // | 'ws
+  type: "sse";
   // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 이벤트 키별로 넘겨주는 값이므로 어떤 타입이든 상관없음
   events: z.ZodObject<any>;
   path?: string;
@@ -61,6 +61,24 @@ export type StreamDecoratorOptions = {
   guards?: GuardKey[];
   description?: string;
 };
+export type WebSocketDecoratorOptions = {
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 이벤트 키별로 넘겨주는 값이므로 어떤 타입이든 상관없음
+  outEvents: z.ZodObject<any>;
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 이벤트 키별로 넘겨주는 값이므로 어떤 타입이든 상관없음
+  inEvents: z.ZodObject<any>;
+  path?: string;
+  resourceName?: string;
+  guards?: GuardKey[];
+  description?: string;
+  heartbeat?: number;
+  maxPayload?: number;
+  namespace?: string;
+};
+export type ResolvedWebSocketDecoratorOptions = WebSocketDecoratorOptions & {
+  // codegen이 타입 이름을 재사용할 수 있도록 syncer가 AST에서 보강하는 메타데이터
+  outEventsTypeRef?: ApiParamType.Ref;
+  inEventsTypeRef?: ApiParamType.Ref;
+};
 
 type BufferUploadOptions = {
   consume?: "buffer";
@@ -85,6 +103,7 @@ export const registeredApis: {
   path: string;
   options: ApiDecoratorOptions;
   streamOptions?: StreamDecoratorOptions;
+  websocketOptions?: ResolvedWebSocketDecoratorOptions;
   uploadOptions?: UploadDecoratorOptions;
 }[] = [];
 export type ExtendedApi = {
@@ -93,6 +112,7 @@ export type ExtendedApi = {
   path: string;
   options: ApiDecoratorOptions;
   streamOptions?: StreamDecoratorOptions;
+  websocketOptions?: ResolvedWebSocketDecoratorOptions;
   uploadOptions?: UploadDecoratorOptions;
   typeParameters: ApiParamType.TypeParam[];
   parameters: ApiParam[];
@@ -103,6 +123,7 @@ type DecoratorTarget = { constructor: { name: string } };
 const DECORATOR_TYPES = {
   API: Symbol("api"),
   STREAM: Symbol("stream"),
+  WEBSOCKET: Symbol("websocket"),
   UPLOAD: Symbol("upload"),
 } as const;
 
@@ -110,7 +131,7 @@ function checkSingleDecorator(target: DecoratorTarget, propertyKey: string, deco
   const method = target[propertyKey as keyof typeof target] as { __decoratorType?: symbol };
   if (method?.__decoratorType && method?.__decoratorType !== decoratorType) {
     throw new Error(
-      `@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api or @stream decorator on the same method.`,
+      `@${decoratorType.description ?? String(decoratorType)} decorator can only be used once on ${target.constructor.name}.${propertyKey}. You can use only one of @api, @stream, @websocket, or @upload decorator on the same method.`,
     );
   } else {
     method.__decoratorType = decoratorType;
@@ -278,6 +299,85 @@ export function stream(options: StreamDecoratorOptions) {
   };
 }
 
+export function websocket(options: WebSocketDecoratorOptions) {
+  return (target: DecoratorTarget, propertyKey: string, descriptor: PropertyDescriptor) => {
+    const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
+    assert(
+      modelName,
+      `modelName is required on @websocket decorator on ${target.constructor.name}.${propertyKey}`,
+    );
+    const methodName = propertyKey;
+
+    checkSingleDecorator(target, propertyKey, DECORATOR_TYPES.WEBSOCKET);
+
+    const defaultPath = `/${inflection.camelize(
+      modelName.replace(/Model$/, "").replace(/Frame$/, ""),
+      true,
+    )}/${inflection.camelize(propertyKey, true)}`;
+    const path = options.path ?? defaultPath;
+    const { outEvents: _outEvents, inEvents: _inEvents, ...apiOptions } = options;
+    const optionsWithDefaults = {
+      ...apiOptions,
+      httpMethod: "GET" as HTTPMethods,
+    };
+
+    const existingApi = registeredApis.find(
+      (api) => api.modelName === modelName && api.methodName === methodName,
+    );
+    if (existingApi) {
+      assertNoConflictingPath("websocket", modelName, methodName, existingApi.path, path);
+      existingApi.path = path;
+
+      assertNoConflictingOptions(
+        "websocket",
+        modelName,
+        methodName,
+        existingApi.options,
+        optionsWithDefaults,
+      );
+      existingApi.options = {
+        ...existingApi.options,
+        ...optionsWithDefaults,
+      };
+
+      existingApi.websocketOptions = options;
+    } else {
+      registeredApis.push({
+        modelName,
+        methodName,
+        path,
+        options: optionsWithDefaults,
+        websocketOptions: options,
+      });
+    }
+
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (this: BaseModelClass | BaseFrameClass, ...args: unknown[]) {
+      if (this instanceof BaseModelClass) {
+        getLogger(convertDomainToCategory(this.modelName, "model")).debug(
+          "websocket: {model}.{method}",
+          {
+            model: modelName,
+            method: methodName,
+          },
+        );
+      }
+
+      if (this instanceof BaseFrameClass) {
+        getLogger(convertDomainToCategory(this.frameName, "frame")).debug(
+          "websocket: {model}.{method}",
+          {
+            model: modelName,
+            method: methodName,
+          },
+        );
+      }
+
+      return originalMethod.apply(this, args);
+    };
+  };
+}
+
 export function transactional(options: TransactionalOptions = {}) {
   const { isolation, readOnly, dbPreset = "w" } = options;
 
@@ -286,7 +386,7 @@ export function transactional(options: TransactionalOptions = {}) {
     const modelName = target.constructor.name.match(/(.+)Class$/)?.[1];
     assert(
       modelName,
-      `modelName is required on @stream decorator on ${target.constructor.name}.${propertyKey}`,
+      `modelName is required on @transactional decorator on ${target.constructor.name}.${propertyKey}`,
     );
     const methodName = propertyKey;