sonamu 0.8.26 → 0.9.0

package/dist/syncer/checksum.js

@@ -1,89 +1,103 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { exists, init_fs_utils } from "../utils/fs-utils.js";
+import { differenceWith, init_utils } from "../utils/utils.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { globAsync, init_async_utils } from "../utils/async-utils.js";
+import { getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { isEqual } from "radashi";
 import crypto from "crypto";
-import equal from "fast-deep-equal";
-import { createReadStream } from "fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, writeFile } from "fs/promises";
 import path from "path";
-import { isEqual } from "radashi";
-import { Sonamu } from "../api/sonamu.js";
-import { globAsync } from "../utils/async-utils.js";
-import { exists } from "../utils/fs-utils.js";
-import { differenceWith } from "../utils/utils.js";
-import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns.js";
+import { createReadStream } from "fs";
+import equal from "fast-deep-equal";
+
+//#region src/syncer/checksum.ts
 /**
- * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
- * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
- */ export async function findChangedFilesUsingChecksums() {
-    const calculatedChecksums = await getCurrentChecksums();
-    const savedChecksums = await getPreviousChecksums();
-    const isSame = equal(calculatedChecksums, savedChecksums);
-    if (isSame) {
-        return [];
-    }
-    return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r)=>r.path);
+* 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
+* @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
+*/
+async function findChangedFilesUsingChecksums() {
+	const calculatedChecksums = await getCurrentChecksums();
+	const savedChecksums = await getPreviousChecksums();
+	const isSame = equal(calculatedChecksums, savedChecksums);
+	if (isSame) {
+		return [];
+	}
+	return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);
 }
 /**
- * 체크섬을 갱신합니다.
- * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
- */ export async function renewChecksums() {
-    const calculatedChecksums = await getCurrentChecksums();
-    const savedChecksums = await getPreviousChecksums();
-    const isSame = equal(calculatedChecksums, savedChecksums);
-    if (isSame) {
-        return;
-    }
-    await saveChecksums(calculatedChecksums);
+* 체크섬을 갱신합니다.
+* 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
+*/
+async function renewChecksums() {
+	const calculatedChecksums = await getCurrentChecksums();
+	const savedChecksums = await getPreviousChecksums();
+	const isSame = equal(calculatedChecksums, savedChecksums);
+	if (isSame) {
+		return;
+	}
+	await saveChecksums(calculatedChecksums);
 }
 async function getCurrentChecksums() {
-    const filePaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern])=>{
-        return globAsync(pattern);
-    }))).flat().sort();
-    const fileChecksums = await Promise.all(filePaths.map(async (filePath)=>{
-        return {
-            path: filePath,
-            checksum: await getChecksumOfFile(filePath)
-        };
-    }));
-    return fileChecksums;
+	const filePaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {
+		return globAsync(pattern);
+	}))).flat().toSorted();
+	const fileChecksums = await Promise.all(filePaths.map(async (filePath) => {
+		return {
+			path: filePath,
+			checksum: await getChecksumOfFile(filePath)
+		};
+	}));
+	return fileChecksums;
 }
 async function getPreviousChecksums() {
-    const checksumFilePath = getChecksumFilePath();
-    if (!await exists(checksumFilePath)) {
-        return [];
-    }
-    try {
-        const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map((r)=>({
-                path: path.join(Sonamu.apiRootPath, r.path),
-                checksum: r.checksum
-            }));
-        return previousChecksums;
-    } catch (e) {
-        // 체크섬 파일이 손상된 경우 빈 배열 반환 (전체 재동기화 유도)
-        console.warn(`체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`, e);
-        return [];
-    }
+	const checksumFilePath = getChecksumFilePath();
+	if (!await exists(checksumFilePath)) {
+		return [];
+	}
+	try {
+		const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map((r) => ({
+			path: path.join(Sonamu.apiRootPath, r.path),
+			checksum: r.checksum
+		}));
+		return previousChecksums;
+	} catch (e) {
+		console.warn(`체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`, e);
+		return [];
+	}
 }
 function getChecksumFilePath() {
-    return path.join(Sonamu.apiRootPath, "sonamu.lock");
+	return path.join(Sonamu.apiRootPath, "sonamu.lock");
 }
 async function saveChecksums(checksums) {
-    const checksumFilePath = getChecksumFilePath();
-    await writeFile(checksumFilePath, JSON.stringify(checksums.map((r)=>({
-            path: path.relative(Sonamu.apiRootPath, r.path),
-            checksum: r.checksum
-        })), null, 2), "utf-8");
+	const checksumFilePath = getChecksumFilePath();
+	await writeFile(checksumFilePath, JSON.stringify(checksums.map((r) => ({
+		path: path.relative(Sonamu.apiRootPath, r.path),
+		checksum: r.checksum
+	})), null, 2), "utf-8");
 }
 async function getChecksumOfFile(filePath) {
-    return new Promise((resolve, reject)=>{
-        const hash = crypto.createHash("sha1");
-        const input = createReadStream(filePath);
-        input.on("error", reject);
-        input.on("data", (chunk)=>{
-            hash.update(chunk);
-        });
-        input.on("close", ()=>{
-            resolve(hash.digest("hex"));
-        });
-    });
+	return new Promise((resolve, reject) => {
+		const hash = crypto.createHash("sha1");
+		const input = createReadStream(filePath);
+		input.on("error", reject);
+		input.on("data", (chunk) => {
+			hash.update(chunk);
+		});
+		input.on("close", () => {
+			resolve(hash.digest("hex"));
+		});
+	});
 }
+var init_checksum = __esmMin((() => {
+	init_sonamu();
+	init_async_utils();
+	init_fs_utils();
+	init_utils();
+	init_file_patterns();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto, { type BinaryLike } from \"crypto\";\nimport equal from \"fast-deep-equal\";\nimport { createReadStream, type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { isEqual } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport type { AbsolutePath, ApiRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {\n        return globAsync(pattern) as Promise<AbsolutePath[]>;\n      }),\n    )\n  )\n    .flat()\n    .sort();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  try {\n    const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n      (r: { path: ApiRelativePath; checksum: string }) => ({\n        path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n        checksum: r.checksum,\n      }),\n    ) as PathAndChecksum[];\n    return previousChecksums;\n  } catch (e) {\n    // 체크섬 파일이 손상된 경우 빈 배열 반환 (전체 재동기화 유도)\n    console.warn(\n      `체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`,\n      e,\n    );\n    return [];\n  }\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2,\n    ),\n    \"utf-8\",\n  );\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"names":["crypto","equal","createReadStream","readFile","writeFile","path","isEqual","Sonamu","globAsync","exists","differenceWith","getChecksumPatternGroupInAbsolutePath","findChangedFilesUsingChecksums","calculatedChecksums","getCurrentChecksums","savedChecksums","getPreviousChecksums","isSame","map","r","renewChecksums","saveChecksums","filePaths","Promise","all","Object","entries","_fileType","pattern","flat","sort","fileChecksums","filePath","checksum","getChecksumOfFile","checksumFilePath","getChecksumFilePath","previousChecksums","JSON","parse","join","apiRootPath","e","console","warn","checksums","stringify","relative","resolve","reject","hash","createHash","input","on","chunk","update","digest"],"mappings":"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"}
+//#endregion
+init_checksum();
+export { findChangedFilesUsingChecksums, init_checksum, renewChecksums };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"checksum.js","names":[],"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { type BinaryLike } from \"crypto\";\nimport { createReadStream } from \"fs\";\nimport { type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport equal from \"fast-deep-equal\";\nimport { isEqual } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath, type ApiRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {\n        return globAsync(pattern) as Promise<AbsolutePath[]>;\n      }),\n    )\n  )\n    .flat()\n    .toSorted();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  try {\n    const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n      (r: { path: ApiRelativePath; checksum: string }) => ({\n        path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n        checksum: r.checksum,\n      }),\n    ) as PathAndChecksum[];\n    return previousChecksums;\n  } catch (e) {\n    // 체크섬 파일이 손상된 경우 빈 배열 반환 (전체 재동기화 유도)\n    console.warn(\n      `체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`,\n      e,\n    );\n    return [];\n  }\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2,\n    ),\n    \"utf-8\",\n  );\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0BA,eAAsB,iCAA0D;CAC9E,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV,SAAO,EAAE;;AAGX,QAAO,eAAe,qBAAqB,gBAAgB,QAAQ,CAAC,KAAK,MAAM,EAAE,KAAK;;;;;;AAOxF,eAAsB,iBAAgC;CACpD,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV;;AAGF,OAAM,cAAc,oBAAoB;;AAG1C,eAAe,sBAAkD;CAC/D,MAAM,aACJ,MAAM,QAAQ,IACZ,OAAO,QAAQ,uCAAuC,CAAC,CAAC,IAAI,OAAO,CAAC,WAAW,aAAa;AAC1F,SAAO,UAAU,QAAQ;GACzB,CACH,EAEA,MAAM,CACN,UAAU;CAEb,MAAM,gBAAgB,MAAM,QAAQ,IAClC,UAAU,IAAI,OAAO,aAAa;AAChC,SAAO;GACL,MAAM;GACN,UAAU,MAAM,kBAAkB,SAAS;GAC5C;GACD,CACH;AAED,QAAO;;AAGT,eAAe,uBAAmD;CAChE,MAAM,mBAAmB,qBAAqB;AAC9C,KAAI,CAAE,MAAM,OAAO,iBAAiB,EAAG;AACrC,SAAO,EAAE;;AAGX,KAAI;EACF,MAAM,oBAAoB,KAAK,MAAM,MAAM,SAAS,kBAAkB,QAAQ,CAAC,CAAC,KAC7E,OAAoD;GACnD,MAAM,KAAK,KAAK,OAAO,aAAa,EAAE,KAAK;GAC3C,UAAU,EAAE;GACb,EACF;AACD,SAAO;UACA,GAAG;AAEV,UAAQ,KACN,UAAU,iBAAiB,oCAC3B,EACD;AACD,SAAO,EAAE;;;AAIb,SAAS,sBAAoC;AAC3C,QAAO,KAAK,KAAK,OAAO,aAAa,cAAc;;AAGrD,eAAe,cAAc,WAA6C;CACxE,MAAM,mBAAmB,qBAAqB;AAC9C,OAAM,UACJ,kBACA,KAAK,UACH,UAAU,KAAK,OAAO;EACpB,MAAM,KAAK,SAAS,OAAO,aAAa,EAAE,KAAK;EAC/C,UAAU,EAAE;EACb,EAAE,EACH,MACA,EACD,EACD,QACD;;AAGH,eAAe,kBAAkB,UAAqC;AACpE,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAO,OAAO,WAAW,OAAO;EACtC,MAAM,QAAQ,iBAAiB,SAAS;AACxC,QAAM,GAAG,SAAS,OAAO;AACzB,QAAM,GAAG,SAAS,UAAsB;AACtC,QAAK,OAAO,MAAM;IAClB;AACF,QAAM,GAAG,eAAe;AACtB,WAAQ,KAAK,OAAO,MAAM,CAAC;IAC3B;GACF;;;cA1HmC;mBACU;gBACN;aAEK;qBACwB"}

package/dist/syncer/code-generator.d.ts

@@ -1,5 +1,5 @@
-import type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from "../types/types";
-import type { AbsolutePath } from "../utils/path-utils";
+import { type GenerateOptions, type PathAndCode, type TemplateKey, type TemplateOptions } from "../types/types";
+import { type AbsolutePath } from "../utils/path-utils";
 /**
  * 템플릿을 렌더링하고 파일로 생성합니다.
  * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.

package/dist/syncer/code-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAMjG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1D,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CAyCzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAoBxB"}
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1D,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CAyCzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAoBxB"}

package/dist/syncer/code-generator.js

@@ -1,170 +1,164 @@
-import chalk from "chalk";
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "path";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { SD, init_sd } from "../dict/sd.js";
+import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
+import { init_controller, isTest } from "../utils/controller.js";
+import { exists, init_fs_utils } from "../utils/fs-utils.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { everyAsync, filterAsync, init_async_utils } from "../utils/async-utils.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { Naite, init_naite } from "../naite/naite.js";
+import { formatCode, init_formatter } from "../utils/formatter.js";
+import { TemplateManager, init_template_manager } from "../template/template-manager.js";
+import { BUILT_IN_TYPES, init_zod_converter } from "../template/zod-converter.js";
+import { init_lodash_able, wrapIf } from "../utils/lodash-able.js";
 import { unique } from "radashi";
-import { Sonamu } from "../api/sonamu.js";
-import { SD } from "../dict/sd.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { AlreadyProcessedException } from "../exceptions/so-exceptions.js";
-import { Naite } from "../naite/naite.js";
-import { TemplateManager } from "../template/template-manager.js";
-import { BUILT_IN_TYPES } from "../template/zod-converter.js";
-import { everyAsync, filterAsync } from "../utils/async-utils.js";
-import { isTest } from "../utils/controller.js";
-import { formatCode } from "../utils/formatter.js";
-import { exists } from "../utils/fs-utils.js";
-import { wrapIf } from "../utils/lodash-able.js";
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+
+//#region src/syncer/code-generator.ts
 /**
- * 템플릿을 렌더링하고 파일로 생성합니다.
- * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
- * @param key - 템플릿 키 (예: "entity", "model", "service" 등)
- * @param templateOptions - 템플릿 렌더링에 필요한 옵션
- * @param _generateOptions - 생성 옵션 (overwrite 여부)
- * @returns 생성된 파일 경로 배열
- */ export async function generateTemplate(key, templateOptions, _generateOptions) {
-    const generateOptions = {
-        overwrite: false,
-        ..._generateOptions
-    };
-    Naite.t("generateTemplate", {
-        key,
-        templateOptions,
-        generateOptions
-    });
-    // 키 children
-    const keys = [
-        key
-    ];
-    // 템플릿 렌더
-    const pathAndCodes = (await Promise.all(keys.map(async (key)=>{
-        return await renderTemplate(key, templateOptions);
-    }))).flat();
-    const filteredPathAndCodes = await (async ()=>{
-        if (generateOptions.overwrite === true) {
-            return pathAndCodes;
-        } else {
-            return await filterAsync(pathAndCodes, async (pathAndCode)=>{
-                const { targets } = Sonamu.config.sync;
-                const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-                const dstFilePaths = targets.map((target)=>filePath.replace("/:target/", `/${target}/`));
-                return await everyAsync(dstFilePaths, async (dstPath)=>!await exists(dstPath));
-            });
-        }
-    })();
-    if (filteredPathAndCodes.length === 0) {
-        throw new AlreadyProcessedException(SD("sonamu.error.allFilesExist"));
-    }
-    return (await Promise.all(filteredPathAndCodes.map((pathAndCode)=>writeCodeToPathEachTarget(pathAndCode)))).flat();
+* 템플릿을 렌더링하고 파일로 생성합니다.
+* overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
+* @param key - 템플릿 키 (예: "entity", "model", "service" 등)
+* @param templateOptions - 템플릿 렌더링에 필요한 옵션
+* @param _generateOptions - 생성 옵션 (overwrite 여부)
+* @returns 생성된 파일 경로 배열
+*/
+async function generateTemplate(key, templateOptions, _generateOptions) {
+	const generateOptions = {
+		overwrite: false,
+		..._generateOptions
+	};
+	Naite.t("generateTemplate", {
+		key,
+		templateOptions,
+		generateOptions
+	});
+	const keys = [key];
+	const pathAndCodes = (await Promise.all(keys.map(async (key$1) => {
+		return await renderTemplate(key$1, templateOptions);
+	}))).flat();
+	const filteredPathAndCodes = await (async () => {
+		if (generateOptions.overwrite) {
+			return pathAndCodes;
+		} else {
+			return await filterAsync(pathAndCodes, async (pathAndCode) => {
+				const { targets } = Sonamu.config.sync;
+				const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+				const dstFilePaths = targets.map((target) => filePath.replace("/:target/", `/${target}/`));
+				return await everyAsync(dstFilePaths, async (dstPath) => !await exists(dstPath));
+			});
+		}
+	})();
+	if (filteredPathAndCodes.length === 0) {
+		throw new AlreadyProcessedException(SD("sonamu.error.allFilesExist"));
+	}
+	return (await Promise.all(filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)))).flat();
 }
 /**
- * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
- * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.
- * @param key - 템플릿 키
- * @param options - 템플릿 렌더링 옵션
- * @returns 경로와 코드 쌍의 배열
- */ export async function renderTemplate(key, options) {
-    Naite.t("renderTemplate", {
-        key,
-        options
-    });
-    const template = TemplateManager.get(key);
-    const rendered = await template.render(options);
-    const resolved = await resolveRenderedTemplate(key, rendered);
-    let preTemplateResolved = [];
-    if (rendered.preTemplates) {
-        preTemplateResolved = (await Promise.all(rendered.preTemplates.map(({ key, options })=>{
-            return renderTemplate(key, options);
-        }))).flat();
-    }
-    return [
-        resolved,
-        ...preTemplateResolved
-    ];
+* 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
+* 파일로 쓰지 않고 메모리상에서만 렌더링합니다.
+* @param key - 템플릿 키
+* @param options - 템플릿 렌더링 옵션
+* @returns 경로와 코드 쌍의 배열
+*/
+async function renderTemplate(key, options) {
+	Naite.t("renderTemplate", {
+		key,
+		options
+	});
+	const template = TemplateManager.get(key);
+	const rendered = await template.render(options);
+	const resolved = await resolveRenderedTemplate(key, rendered);
+	let preTemplateResolved = [];
+	if (rendered.preTemplates) {
+		preTemplateResolved = (await Promise.all(rendered.preTemplates.map(({ key: key$1, options: options$1 }) => {
+			return renderTemplate(key$1, options$1);
+		}))).flat();
+	}
+	return [resolved, ...preTemplateResolved];
 }
 async function resolveRenderedTemplate(key, result) {
-    Naite.t(`resolveRenderedTemplate${key}`, {
-        key,
-        result
-    });
-    const { target, path: filePath, body, importKeys, customHeaders } = result;
-    // import 할 대상의 대상 path 추출
-    const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info)=>info.schemaName);
-    const importDefs = importKeys// 내장 타입 스키마는 이미 sonamu에서 import되므로 제외
-    .filter((importKey)=>!builtInSchemaNames.includes(importKey)).reduce((r, importKey)=>{
-        let modulePath = importKey;
-        try {
-            modulePath = EntityManager.getModulePath(importKey);
-        } catch (error) {
-            throw new Error(`[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`);
-        }
-        let importPath = modulePath;
-        if (modulePath.includes("/") || modulePath.includes(".")) {
-            importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p)=>[
-                    p.startsWith(".") === false,
-                    `./${p}`
-                ]);
-        }
-        // 같은 파일에서 import 하는 경우 keys 로 나열 처리
-        const existsOne = r.find((importDef)=>importDef.from === importPath);
-        if (existsOne) {
-            existsOne.keys = unique(existsOne.keys.concat(importKey));
-        } else {
-            r.push({
-                keys: [
-                    importKey
-                ],
-                from: importPath
-            });
-        }
-        return r;
-    }, [])// 셀프 참조 방지
-    .filter((importDef)=>filePath.endsWith(`${importDef.from.replace("./", "")}.ts`) === false);
-    // 커스텀 헤더 포함하여 헤더 생성
-    const header = [
-        ...customHeaders ?? [],
-        ...importDefs.map((importDef)=>`import { ${importDef.keys.join(", ")} } from '${importDef.from}'`)
-    ].join("\n");
-    const formatted = await (async ()=>{
-        if (key === "generated_http") {
-            return [
-                header,
-                body
-            ].join("\n\n");
-        } else {
-            Naite.t("resolveRenderedTemplate:beforeFormat", {
-                key,
-                header,
-                body
-            });
-            const formatted = formatCode([
-                header,
-                body
-            ].join("\n\n"), key === "entity" ? "json" : "typescript", `${Sonamu.appRootPath}/${filePath}`);
-            Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);
-            return formatted;
-        }
-    })();
-    return {
-        path: `${target}/${filePath}`,
-        code: formatted
-    };
+	Naite.t(`resolveRenderedTemplate${key}`, {
+		key,
+		result
+	});
+	const { target, path: filePath, body, importKeys, customHeaders } = result;
+	const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName);
+	const importDefs = importKeys.filter((importKey) => !builtInSchemaNames.includes(importKey)).reduce((r, importKey) => {
+		let modulePath = importKey;
+		try {
+			modulePath = EntityManager.getModulePath(importKey);
+		} catch (error) {
+			throw new Error(`[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`, { cause: error });
+		}
+		let importPath = modulePath;
+		if (modulePath.includes("/") || modulePath.includes(".")) {
+			importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [!p.startsWith("."), `./${p}`]);
+		}
+		const existsOne = r.find((importDef) => importDef.from === importPath);
+		if (existsOne) {
+			existsOne.keys = unique(existsOne.keys.concat(importKey));
+		} else {
+			r.push({
+				keys: [importKey],
+				from: importPath
+			});
+		}
+		return r;
+	}, []).filter((importDef) => !filePath.endsWith(`${importDef.from.replace("./", "")}.ts`));
+	const header = [...customHeaders ?? [], ...importDefs.map((importDef) => `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`)].join("\n");
+	const formatted = await (async () => {
+		if (key === "generated_http") {
+			return [header, body].join("\n\n");
+		} else {
+			Naite.t("resolveRenderedTemplate:beforeFormat", {
+				key,
+				header,
+				body
+			});
+			const formatted$1 = await formatCode([header, body].join("\n\n"), key === "entity" ? "json" : "typescript", `${Sonamu.appRootPath}/${filePath}`);
+			Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted$1);
+			return formatted$1;
+		}
+	})();
+	return {
+		path: `${target}/${filePath}`,
+		code: formatted
+	};
 }
 async function writeCodeToPathEachTarget(pathAndCode) {
-    const { targets } = Sonamu.config.sync;
-    const { appRootPath } = Sonamu;
-    const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
-    const dstFilePaths = unique(targets.map((target)=>filePath.replace("/:target/", `/${target}/`)));
-    return await Promise.all(dstFilePaths.map(async (dstFilePath)=>{
-        const dir = path.dirname(dstFilePath);
-        if (!await exists(dir)) {
-            await mkdir(dir, {
-                recursive: true
-            });
-        }
-        await writeFile(dstFilePath, pathAndCode.code);
-        !isTest() && console.log(chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`));
-        return dstFilePath;
-    }));
+	const { targets } = Sonamu.config.sync;
+	const { appRootPath } = Sonamu;
+	const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;
+	const dstFilePaths = unique(targets.map((target) => filePath.replace("/:target/", `/${target}/`)));
+	return await Promise.all(dstFilePaths.map(async (dstFilePath) => {
+		const dir = path.dirname(dstFilePath);
+		if (!await exists(dir)) {
+			await mkdir(dir, { recursive: true });
+		}
+		await writeFile(dstFilePath, pathAndCode.code);
+		!isTest() && console.log(chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`));
+		return dstFilePath;
+	}));
 }
+var init_code_generator = __esmMin((() => {
+	init_sonamu();
+	init_sd();
+	init_entity_manager();
+	init_so_exceptions();
+	init_naite();
+	init_template_manager();
+	init_zod_converter();
+	init_async_utils();
+	init_controller();
+	init_formatter();
+	init_fs_utils();
+	init_lodash_able();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport type { RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport type { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport type { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite === true) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            p.startsWith(\".\") === false,\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`) === false);\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"names":["chalk","mkdir","writeFile","path","unique","Sonamu","SD","EntityManager","AlreadyProcessedException","Naite","TemplateManager","BUILT_IN_TYPES","everyAsync","filterAsync","isTest","formatCode","exists","wrapIf","generateTemplate","key","templateOptions","_generateOptions","generateOptions","overwrite","t","keys","pathAndCodes","Promise","all","map","renderTemplate","flat","filteredPathAndCodes","pathAndCode","targets","config","sync","filePath","appRootPath","dstFilePaths","target","replace","dstPath","length","writeCodeToPathEachTarget","options","template","get","rendered","render","resolved","resolveRenderedTemplate","preTemplateResolved","preTemplates","result","body","importKeys","customHeaders","builtInSchemaNames","Object","values","info","schemaName","importDefs","filter","importKey","includes","reduce","r","modulePath","getModulePath","error","Error","importPath","relative","dirname","p","startsWith","existsOne","find","importDef","from","concat","push","endsWith","header","join","formatted","code","dstFilePath","dir","recursive","console","log","bold","blue"],"mappings":"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"}
+//#endregion
+init_code_generator();
+export { generateTemplate, init_code_generator, renderTemplate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-generator.js","names":["keys: TemplateKey[]","key","filteredPathAndCodes: PathAndCode[]","preTemplateResolved: PathAndCode[]","options","formatted"],"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport {\n  type GenerateOptions,\n  type PathAndCode,\n  type TemplateKey,\n  type TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n            { cause: error },\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            !p.startsWith(\".\"),\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => !filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`));\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = await formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"mappings":"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"}