sonamu 0.9.4 → 0.9.6

package/dist/utils/formatter.js

@@ -1,92 +1,127 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
 import { init_controller, isTest } from "./controller.js";
-import { join } from "path";
-import { readFileSync, unlinkSync, writeFileSync } from "fs";
-import { execFileSync } from "child_process";
+import { cached, init_async_utils } from "./async-utils.js";
+import { execute, init_process_utils } from "./process-utils.js";
+import { createHash } from "crypto";
+import { readFile, unlink, writeFile } from "fs/promises";
+import path, { dirname, join } from "path";
+import { tmpdir } from "os";
 import { createRequire } from "module";
 import { format } from "oxfmt";
 
 //#region src/utils/formatter.ts
-function resolveOxlintBin() {
-	try {
-		return _require.resolve("oxlint/bin/oxlint");
-	} catch {
-		return "oxlint";
+/**
+* 캐시 없는 포맷함수 엔트리.
+*/
+async function formatCodeInternal(code, filePath) {
+	if (filePath.endsWith("json")) {
+		return runOxfmt(code, filePath);
 	}
+	return runOxfmt(await runOxlint(code), filePath);
 }
-async function formatCode(code, parser, _filePath) {
-	const fileName = parser === "json" ? "file.json" : "file.ts";
-	const formatted = await format(fileName, code, OXFMT_OPTIONS);
-	if (formatted.errors.length > 0) {
-		const errorMessages = formatted.errors.filter((e) => e.severity === "Error").map((e) => e.message);
-		if (errorMessages.length > 0) {
-			return code;
+/**
+* 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
+*/
+async function runOxfmt(code, filePath) {
+	const result = await format(path.basename(filePath), code, await loadOxfmtConfig());
+	const errors = result.errors.filter((e) => e.severity === "Error");
+	if (errors.length > 0) {
+		if (!isTest()) {
+			console.error(`oxfmt errors (${filePath}):`);
+			for (const err of errors) {
+				const label = err.labels[0];
+				if (label) {
+					const before = code.slice(Math.max(0, label.start - 80), label.start);
+					const at = code.slice(label.start, label.end);
+					const after = code.slice(label.end, Math.min(code.length, label.end + 80));
+					console.error(`  - ${err.message} (offset ${label.start}-${label.end})`);
+					console.error(`    around: ...${before}»${at}«${after}...`);
+				} else {
+					console.error(`  - ${err.message}`);
+				}
+			}
+		}
+		return code;
+	}
+	return result.code;
+}
+async function loadOxfmtConfig() {
+	if (cachedOxfmtConfig !== null) {
+		return cachedOxfmtConfig;
+	}
+	let dir = process.cwd();
+	while (true) {
+		const candidate = join(dir, ".oxfmtrc.json");
+		try {
+			cachedOxfmtConfig = JSON.parse(await readFile(candidate, "utf-8"));
+			return cachedOxfmtConfig;
+		} catch (e) {
+			if (e.code !== "ENOENT") {
+				!isTest() && console.error(`Failed to load ${candidate}:`, e);
+				break;
+			}
 		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
 	}
-	if (parser === "json") {
-		return formatted.code;
+	cachedOxfmtConfig = {};
+	return cachedOxfmtConfig;
+}
+/**
+* 프로젝트 설정에 맞춰 코드를 lint합니다.
+*
+* 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,
+* 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.
+* 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...
+*/
+async function runOxlint(code) {
+	if (isTest()) {
+		return code;
 	}
-	const tmpFile = join(process.cwd(), `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+	const tmpFile = join(tmpdir(), `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
 	try {
-		writeFileSync(tmpFile, formatted.code, "utf-8");
-		const oxlintBin = resolveOxlintBin();
+		await writeFile(tmpFile, code, "utf-8");
 		try {
-			execFileSync(oxlintBin, [
+			await execute(resolveOxlintBin(), [
 				"--fix",
 				"--fix-suggestions",
 				"--type-aware",
 				tmpFile
-			], {
-				stdio: "pipe",
-				timeout: 1e4
-			});
-		} catch (execError) {
-			if (execError instanceof Error) {
-				const errObj = execError;
-				if (typeof errObj.status === "number") {
-					void errObj.status;
-				} else {
-					throw execError;
-				}
-			} else {
-				throw execError;
+			], { timeout: 1e4 });
+		} catch (e) {
+			if (typeof e.code !== "number") {
+				throw e;
 			}
 		}
-		const lintFixed = readFileSync(tmpFile, "utf-8");
-		const reformatted = await format(fileName, lintFixed, OXFMT_OPTIONS);
-		if (reformatted.errors.length > 0) {
-			const errorMessages = reformatted.errors.filter((e) => e.severity === "Error").map((e) => e.message);
-			if (errorMessages.length > 0) {
-				!isTest() && console.error("oxfmt reformat errors:", errorMessages);
-				throw new Error(`oxfmt reformat error: ${errorMessages.join(", ")}`);
-			}
-		}
-		return reformatted.code;
+		return await readFile(tmpFile, "utf-8");
 	} finally {
 		try {
-			unlinkSync(tmpFile);
+			await unlink(tmpFile);
 		} catch {}
 	}
 }
-var _require, OXFMT_OPTIONS;
+function resolveOxlintBin() {
+	try {
+		return _require.resolve("oxlint/bin/oxlint");
+	} catch {
+		return "oxlint";
+	}
+}
+var _require, formatCode, cachedOxfmtConfig;
 var init_formatter = __esmMin((() => {
+	init_async_utils();
 	init_controller();
+	init_process_utils();
 	_require = createRequire(import.meta.url);
-	OXFMT_OPTIONS = {
-		printWidth: 100,
-		tabWidth: 2,
-		useTabs: false,
-		singleQuote: false,
-		jsxSingleQuote: false,
-		trailingComma: "all",
-		semi: true,
-		endOfLine: "lf",
-		bracketSpacing: true,
-		sortImports: true
-	};
+	formatCode = cached(formatCodeInternal, (code, filePath) => {
+		const ext = filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith("json") ? "json" : "ts";
+		return `${ext}:${createHash("sha1").update(code).digest("hex")}`;
+	});
+	cachedOxfmtConfig = null;
 }));
 
 //#endregion
 init_formatter();
 export { formatCode, init_formatter };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"formatter.js","names":["cachedOxfmtConfig: FormatConfig | null"],"sources":["../../src/utils/formatter.ts"],"sourcesContent":["import { createHash } from \"crypto\";\n// 테스트 환경에서는 fs/promises가 mock되지만, 아래 runOxlint이 isTest 가드로 안 도니까\n// 그냥 fs/promises 그대로 사용. (production에서만 임시파일 흐름이 돕니다.)\nimport { readFile, unlink, writeFile } from \"fs/promises\";\nimport { createRequire } from \"module\";\nimport { tmpdir } from \"os\";\nimport path, { dirname, join } from \"path\";\n\nimport { format, type FormatConfig } from \"oxfmt\";\n\nimport { cached } from \"./async-utils\";\nimport { isTest } from \"./controller\";\nimport { execute } from \"./process-utils\";\n\nconst _require = createRequire(import.meta.url);\n\n/**\n * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.\n *\n * 캐싱도 있어요 ㅎㅎ 똑같은 입력에 대해서 캐시 커버됩니다.\n * 수명은 프로세스 죽을때까지 ㅋ\n */\nexport const formatCode = cached(formatCodeInternal, (code, filePath) => {\n  const ext = filePath.endsWith(\".tsx\") ? \"tsx\" : filePath.endsWith(\"json\") ? \"json\" : \"ts\";\n  return `${ext}:${createHash(\"sha1\").update(code).digest(\"hex\")}`;\n});\n\n/**\n * 캐시 없는 포맷함수 엔트리.\n */\nasync function formatCodeInternal(code: string, filePath: string): Promise<string> {\n  // json은 포맷만 하면 됩니다.\n  if (filePath.endsWith(\"json\")) {\n    return runOxfmt(code, filePath);\n  }\n\n  // 린트 먼저 한 다음에 포맷으로 마무리해요.\n  return runOxfmt(await runOxlint(code), filePath);\n}\n\n/**\n * 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.\n */\nasync function runOxfmt(code: string, filePath: string): Promise<string> {\n  const result = await format(path.basename(filePath), code, await loadOxfmtConfig());\n\n  const errors = result.errors.filter((e) => e.severity === \"Error\");\n  if (errors.length > 0) {\n    if (!isTest()) {\n      console.error(`oxfmt errors (${filePath}):`);\n      for (const err of errors) {\n        const label = err.labels[0];\n        if (label) {\n          const before = code.slice(Math.max(0, label.start - 80), label.start);\n          const at = code.slice(label.start, label.end);\n          const after = code.slice(label.end, Math.min(code.length, label.end + 80));\n          console.error(`  - ${err.message} (offset ${label.start}-${label.end})`);\n          console.error(`    around: ...${before}»${at}«${after}...`);\n        } else {\n          console.error(`  - ${err.message}`);\n        }\n      }\n    }\n    return code;\n  }\n  return result.code;\n}\n\nlet cachedOxfmtConfig: FormatConfig | null = null;\nasync function loadOxfmtConfig(): Promise<FormatConfig> {\n  if (cachedOxfmtConfig !== null) {\n    return cachedOxfmtConfig;\n  }\n\n  let dir = process.cwd();\n  while (true) {\n    const candidate = join(dir, \".oxfmtrc.json\");\n    try {\n      cachedOxfmtConfig = JSON.parse(await readFile(candidate, \"utf-8\")) as FormatConfig;\n      return cachedOxfmtConfig;\n    } catch (e) {\n      if ((e as NodeJS.ErrnoException).code !== \"ENOENT\") {\n        !isTest() && console.error(`Failed to load ${candidate}:`, e);\n        break;\n      }\n    }\n    const parent = dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  cachedOxfmtConfig = {};\n  return cachedOxfmtConfig;\n}\n\n/**\n * 프로젝트 설정에 맞춰 코드를 lint합니다.\n *\n * 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,\n * 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.\n * 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...\n */\nasync function runOxlint(code: string): Promise<string> {\n  if (isTest()) {\n    // 테스트 환경에서는 느려지기만 하고 검증할 가치도 없어서 안 합니다.\n    // GitHub Actions 환경에서 lint가 오래 걸려서 뻗기도 했어요. (https://github.com/cartanova-ai/sonamu/actions/runs/25267214027/job/74083630169)\n    return code;\n  }\n\n  // OS tmp dir에 두는 이유: process.cwd()가 watcher 스코프(api/src 아래)일 가능성을 차단합니다.\n  // cwd가 그 위치라면 write/unlink가 짧은 순간 watcher 이벤트로 잡혀 batch에 흘러들어갈 수 있어요.\n  const tmpFile = join(\n    tmpdir(),\n    `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,\n  );\n\n  try {\n    await writeFile(tmpFile, code, \"utf-8\");\n\n    try {\n      await execute(resolveOxlintBin(), [\"--fix\", \"--fix-suggestions\", \"--type-aware\", tmpFile], {\n        timeout: 10000,\n      });\n    } catch (e) {\n      // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 throw.\n      if (typeof (e as Error & { code?: number }).code !== \"number\") {\n        throw e;\n      }\n    }\n\n    return await readFile(tmpFile, \"utf-8\");\n  } finally {\n    try {\n      await unlink(tmpFile);\n    } catch {\n      // 삭제 실패해도 어차피 ignore됨.\n    }\n  }\n}\n\nfunction resolveOxlintBin(): string {\n  try {\n    return _require.resolve(\"oxlint/bin/oxlint\");\n  } catch {\n    return \"oxlint\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA8BA,eAAe,mBAAmB,MAAc,UAAmC;AAEjF,KAAI,SAAS,SAAS,OAAO,EAAE;AAC7B,SAAO,SAAS,MAAM,SAAS;;AAIjC,QAAO,SAAS,MAAM,UAAU,KAAK,EAAE,SAAS;;;;;AAMlD,eAAe,SAAS,MAAc,UAAmC;CACvE,MAAM,SAAS,MAAM,OAAO,KAAK,SAAS,SAAS,EAAE,MAAM,MAAM,iBAAiB,CAAC;CAEnF,MAAM,SAAS,OAAO,OAAO,QAAQ,MAAM,EAAE,aAAa,QAAQ;AAClE,KAAI,OAAO,SAAS,GAAG;AACrB,MAAI,CAAC,QAAQ,EAAE;AACb,WAAQ,MAAM,iBAAiB,SAAS,IAAI;AAC5C,QAAK,MAAM,OAAO,QAAQ;IACxB,MAAM,QAAQ,IAAI,OAAO;AACzB,QAAI,OAAO;KACT,MAAM,SAAS,KAAK,MAAM,KAAK,IAAI,GAAG,MAAM,QAAQ,GAAG,EAAE,MAAM,MAAM;KACrE,MAAM,KAAK,KAAK,MAAM,MAAM,OAAO,MAAM,IAAI;KAC7C,MAAM,QAAQ,KAAK,MAAM,MAAM,KAAK,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM,GAAG,CAAC;AAC1E,aAAQ,MAAM,OAAO,IAAI,QAAQ,WAAW,MAAM,MAAM,GAAG,MAAM,IAAI,GAAG;AACxE,aAAQ,MAAM,kBAAkB,OAAO,GAAG,GAAG,GAAG,MAAM,KAAK;WACtD;AACL,aAAQ,MAAM,OAAO,IAAI,UAAU;;;;AAIzC,SAAO;;AAET,QAAO,OAAO;;AAIhB,eAAe,kBAAyC;AACtD,KAAI,sBAAsB,MAAM;AAC9B,SAAO;;CAGT,IAAI,MAAM,QAAQ,KAAK;AACvB,QAAO,MAAM;EACX,MAAM,YAAY,KAAK,KAAK,gBAAgB;AAC5C,MAAI;AACF,uBAAoB,KAAK,MAAM,MAAM,SAAS,WAAW,QAAQ,CAAC;AAClE,UAAO;WACA,GAAG;AACV,OAAK,EAA4B,SAAS,UAAU;AAClD,KAAC,QAAQ,IAAI,QAAQ,MAAM,kBAAkB,UAAU,IAAI,EAAE;AAC7D;;;EAGJ,MAAM,SAAS,QAAQ,IAAI;AAC3B,MAAI,WAAW,IAAK;AACpB,QAAM;;AAGR,qBAAoB,EAAE;AACtB,QAAO;;;;;;;;;AAUT,eAAe,UAAU,MAA+B;AACtD,KAAI,QAAQ,EAAE;AAGZ,SAAO;;CAKT,MAAM,UAAU,KACd,QAAQ,EACR,eAAe,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,MAAM,EAAE,CAAC,KAClE;AAED,KAAI;AACF,QAAM,UAAU,SAAS,MAAM,QAAQ;AAEvC,MAAI;AACF,SAAM,QAAQ,kBAAkB,EAAE;IAAC;IAAS;IAAqB;IAAgB;IAAQ,EAAE,EACzF,SAAS,KACV,CAAC;WACK,GAAG;AAEV,OAAI,OAAQ,EAAgC,SAAS,UAAU;AAC7D,UAAM;;;AAIV,SAAO,MAAM,SAAS,SAAS,QAAQ;WAC/B;AACR,MAAI;AACF,SAAM,OAAO,QAAQ;UACf;;;AAMZ,SAAS,mBAA2B;AAClC,KAAI;AACF,SAAO,SAAS,QAAQ,oBAAoB;SACtC;AACN,SAAO;;;;;mBAtI4B;kBACD;qBACI;CAEpC,WAAW,cAAc,OAAO,KAAK,IAAI;CAQlC,aAAa,OAAO,qBAAqB,MAAM,aAAa;EACvE,MAAM,MAAM,SAAS,SAAS,OAAO,GAAG,QAAQ,SAAS,SAAS,OAAO,GAAG,SAAS;AACrF,SAAO,GAAG,IAAI,GAAG,WAAW,OAAO,CAAC,OAAO,KAAK,CAAC,OAAO,MAAM;GAC9D;CA2CEA,oBAAyC"}

package/dist/utils/fs-utils.d.ts

@@ -16,6 +16,8 @@ export declare function fileExists(path: PathLike): Promise<boolean>;
  * - services/user/user.types.ts → ../sonamu.shared
  * - i18n/ko.ts → ../services/sonamu.shared
  *
+ * ts/tsx 파일은 쓰기 전에 oxfmt/oxlint 한번 돌려줍니다!
+ *
  * @param fromPath 원본 파일 경로
  * @param toPath 대상 파일 경로
  * @param syncHeader 동기화 시 파일 최상단에 삽입할 주석 블록. 기존 @generated 블록이 있으면 교체하고, 없으면 최상단에 추가합니다.

package/dist/utils/fs-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../../src/utils/fs-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAInC;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7D;AAGD,wBAAsB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAOjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAuClB"}
+{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../../src/utils/fs-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,IAAI,CAAC;AAMnC;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7D;AAGD,wBAAsB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAOjE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CA4ClB"}

package/dist/utils/fs-utils.js

@@ -1,4 +1,5 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { formatCode, init_formatter } from "./formatter.js";
 import { access, readFile, stat, writeFile } from "fs/promises";
 import path, { dirname } from "path";
 import { constants } from "fs";
@@ -35,6 +36,8 @@ async function fileExists(path$1) {
 * - services/user/user.types.ts → ../sonamu.shared
 * - i18n/ko.ts → ../services/sonamu.shared
 *
+* ts/tsx 파일은 쓰기 전에 oxfmt/oxlint 한번 돌려줍니다!
+*
 * @param fromPath 원본 파일 경로
 * @param toPath 대상 파일 경로
 * @param syncHeader 동기화 시 파일 최상단에 삽입할 주석 블록. 기존 @generated 블록이 있으면 교체하고, 없으면 최상단에 추가합니다.
@@ -64,12 +67,17 @@ async function copyFileWithReplaceCoreToShared(fromPath, toPath, syncHeader) {
 			newFileContent = `${syncHeader}\n\n${newFileContent}`;
 		}
 	}
+	if (toPath.endsWith(".ts") || toPath.endsWith(".tsx")) {
+		newFileContent = await formatCode(newFileContent, toPath);
+	}
 	await writeFile(toPath, newFileContent);
 	return true;
 }
-var init_fs_utils = __esmMin((() => {}));
+var init_fs_utils = __esmMin((() => {
+	init_formatter();
+}));
 
 //#endregion
 init_fs_utils();
 export { copyFileWithReplaceCoreToShared, exists, fileExists, init_fs_utils };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/process-utils.d.ts

@@ -1,3 +1,9 @@
+import { type ExecFileOptions } from "child_process";
+/**
+ * exexFileSync의 비동기 버전입니다.
+ * exit code가 non-zero이면 reject해요.
+ */
+export declare function execute(bin: string, args: string[], options?: ExecFileOptions): Promise<string>;
 /**
  * 주어진 작업을 실행합니다.
  * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.

package/dist/utils/process-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"process-utils.d.ts","sourceRoot":"","sources":["../../src/utils/process-utils.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACxB,EACE,eAAe,EAAE,KAAK,EACtB,WAAW,EAAE,mBAAmB,GACjC,GAAE;IAAE,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAGxD,GACA,OAAO,CAAC,IAAI,CAAC,CAyBf"}
+{"version":3,"file":"process-utils.d.ts","sourceRoot":"","sources":["../../src/utils/process-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAQ/D;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACxB,EACE,eAAe,EAAE,KAAK,EACtB,WAAW,EAAE,mBAAmB,GACjC,GAAE;IAAE,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAGxD,GACA,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/utils/process-utils.js

@@ -1,9 +1,19 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
 import chalk from "chalk";
+import { execFile } from "child_process";
 import { setTimeout } from "timers/promises";
+import { promisify } from "util";
 
 //#region src/utils/process-utils.ts
 /**
+* exexFileSync의 비동기 버전입니다.
+* exit code가 non-zero이면 reject해요.
+*/
+async function execute(bin, args, options) {
+	const { stdout } = await execFileAsync(bin, args, options);
+	return typeof stdout === "string" ? stdout : stdout.toString();
+}
+/**
 * 주어진 작업을 실행합니다.
 * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.
 * @param {() => Promise<void>} job - 실행할 작업
@@ -34,9 +44,12 @@ async function runWithGracefulShutdown(job, { whenThisHappens: event, waitForUpT
 	abortController.abort();
 	process.off(event, onEvent);
 }
-var init_process_utils = __esmMin((() => {}));
+var execFileAsync;
+var init_process_utils = __esmMin((() => {
+	execFileAsync = promisify(execFile);
+}));
 
 //#endregion
 init_process_utils();
-export { init_process_utils, runWithGracefulShutdown };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { execute, init_process_utils, runWithGracefulShutdown };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/utils.d.ts

@@ -10,5 +10,6 @@ export declare function assertDefined<T>(value: T | undefined, message?: string)
 export declare function intersectionBy<T, K>(arr1: readonly T[], arr2: readonly T[], iteratee: (item: T) => K): T[];
 export declare function differenceWith<T>(arr1: readonly T[], arr2: readonly T[], comparator: (a: T, b: T) => boolean): T[];
 export declare function merge<T extends Record<string, any>>(defaultObj: T, userObj: T): T;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function convertFastifyHeadersToStandard(headers: FastifyRequest["headers"]): Headers;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,wBAAgB,eAAe,IAAI,YAAY,CAG9C;AAED,wBAAgB,eAAe,IAAI,YAAY,CA8B9C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAEhE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,QAEvC;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAKhF;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAKrE;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAK1E;AAGD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACvB,CAAC,EAAE,CAGL;AAED,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAClC,CAAC,EAAE,CAEL;AAGD,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAsBjF;AAcD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,OAAO,CAM3F"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,wBAAgB,eAAe,IAAI,YAAY,CAG9C;AAED,wBAAgB,eAAe,IAAI,YAAY,CA8B9C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAEhE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,QAEvC;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAKhF;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAKrE;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAK1E;AAGD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACvB,CAAC,EAAE,CAGL;AAED,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAClC,CAAC,EAAE,CAEL;AAGD,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAsBjF;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO9E;AAGD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,OAAO,CAM3F"}

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.4",
+  "version": "0.9.6",
   "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",
@@ -119,7 +121,7 @@
     "node-cron": "^4.2.1",
     "node-sql-parser": "^5.2.0",
     "oxfmt": "^0.43.0",
-    "oxlint": "^1.58.0",
+    "oxlint": "^1.61.0",
     "pg": "^8.16.3",
     "prompts": "^2.4.2",
     "qs": "^6.14.1",
@@ -128,8 +130,8 @@
     "vite": "8.0.5",
     "vitest": "^4.1.2",
     "@sonamu-kit/hmr-hook": "^0.5.1",
-    "@sonamu-kit/tasks": "^0.3.0",
     "@sonamu-kit/hmr-runner": "^0.2.0",
+    "@sonamu-kit/tasks": "^0.3.0",
     "@sonamu-kit/ts-loader": "^2.2.0"
   },
   "devDependencies": {
@@ -142,7 +144,7 @@
     "@types/qs": "^6.14.0",
     "nodemon": "^3.1.10",
     "tsdown": "^0.12.5",
-    "typescript": "^6.0.0"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
@@ -158,7 +160,7 @@
     "ioredis": "^5.8.2",
     "knex": "^3.2.9",
     "pgvector": "^0.2.1",
-    "typescript": "^6.0.0",
+    "typescript": "^6.0.3",
     "voyageai": "^0.0.8",
     "zod": "^4.3.6"
   },

package/src/ai/providers/rtzr/utils.ts

@@ -23,7 +23,7 @@ export function handleFetchError({
   ) {
     const cause = (error as { cause?: Error }).cause;
 
-    if (cause != null) {
+    if (cause) {
       return new APICallError({
         message: `Cannot connect to API: ${cause.message}`,
         cause,

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();
+  });
+});