sonamu 0.8.26 → 0.9.0

package/dist/syncer/entity-operations.d.ts

@@ -1,4 +1,4 @@
-import type { TemplateOptions } from "../types/types";
+import { type TemplateOptions } from "../types/types";
 /**
  * 새로운 엔티티를 생성합니다.
  * entityId는 반드시 CamelCase 형식이어야 합니다.

package/dist/syncer/entity-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-operations.d.ts","sourceRoot":"","sources":["../../src/syncer/entity-operations.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,iBAUnE;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAgCjF"}
+{"version":3,"file":"entity-operations.d.ts","sourceRoot":"","sources":["../../src/syncer/entity-operations.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,iBAUnE;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAgCjF"}

package/dist/syncer/entity-operations.js

@@ -1,60 +1,69 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { SD, init_sd } from "../dict/sd.js";
+import { BadRequestException, 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 { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { generateTemplate, init_code_generator } from "./code-generator.js";
+import { rm } from "fs/promises";
 import chalk from "chalk";
-import { rm } from "node:fs/promises";
-import { Sonamu } from "../api/sonamu.js";
-import { SD } from "../dict/sd.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { BadRequestException } from "../exceptions/so-exceptions.js";
-import { isTest } from "../utils/controller.js";
-import { exists } from "../utils/fs-utils.js";
-import { generateTemplate } from "./code-generator.js";
+
+//#region src/syncer/entity-operations.ts
 /**
- * 새로운 엔티티를 생성합니다.
- * entityId는 반드시 CamelCase 형식이어야 합니다.
- */ export async function createEntity(form) {
-    if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
-        throw new BadRequestException(SD("sonamu.error.entityIdCamelCase"));
-    }
-    await generateTemplate("entity", form);
-    // reload entities
-    await EntityManager.reload();
+* 새로운 엔티티를 생성합니다.
+* entityId는 반드시 CamelCase 형식이어야 합니다.
+*/
+async function createEntity(form) {
+	if (!/^[A-Z][a-zA-Z0-9]*$/.test(form.entityId)) {
+		throw new BadRequestException(SD("sonamu.error.entityIdCamelCase"));
+	}
+	await generateTemplate("entity", form);
+	await EntityManager.reload();
 }
 /**
- * 엔티티를 삭제합니다.
- * parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
- * 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
- */ export async function delEntity(entityId) {
-    const entity = EntityManager.get(entityId);
-    const delPaths = (()=>{
-        if (entity.parentId) {
-            return [
-                `${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`
-            ];
-        } else {
-            return [
-                `${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
-                `${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
-                ...Sonamu.config.sync.targets.flatMap((target)=>[
-                        `${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`
-                    ])
-            ];
-        }
-    })(); // iife
-    for await (const delPath of delPaths){
-        if (await exists(delPath)) {
-            !isTest() && console.log(chalk.red(`DELETE ${delPath}`));
-            await rm(delPath, {
-                recursive: true,
-                force: true
-            });
-        } else {
-            !isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
-        }
-    }
-    // reload entities
-    await EntityManager.reload();
-    return {
-        delPaths
-    };
+* 엔티티를 삭제합니다.
+* parentId가 있는 서브 엔티티의 경우 entity.json만 삭제하고,
+* 루트 엔티티의 경우 디렉토리 전체와 타겟 디렉토리를 삭제합니다.
+*/
+async function delEntity(entityId) {
+	const entity = EntityManager.get(entityId);
+	const delPaths = (() => {
+		if (entity.parentId) {
+			return [`${Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`];
+		} else {
+			return [
+				`${Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
+				`${Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
+				...Sonamu.config.sync.targets.flatMap((target) => [`${Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`])
+			];
+		}
+	})();
+	for (const delPath of delPaths) {
+		if (await exists(delPath)) {
+			!isTest() && console.log(chalk.red(`DELETE ${delPath}`));
+			await rm(delPath, {
+				recursive: true,
+				force: true
+			});
+		} else {
+			!isTest() && console.log(chalk.yellow(`NOT_EXISTS ${delPath}`));
+		}
+	}
+	await EntityManager.reload();
+	return { delPaths };
 }
+var init_entity_operations = __esmMin((() => {
+	init_sonamu();
+	init_sd();
+	init_entity_manager();
+	init_so_exceptions();
+	init_controller();
+	init_fs_utils();
+	init_code_generator();
+}));
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+init_entity_operations();
+export { createEntity, delEntity, init_entity_operations };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/file-patterns.d.ts

@@ -1,4 +1,4 @@
-import type { AbsolutePath, ApiRelativePath } from "../utils/path-utils";
+import { type AbsolutePath, type ApiRelativePath } from "../utils/path-utils";
 /**
  * Syncer가 관심 가지고 지켜보는 파일들입니다.
  * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.

package/dist/syncer/file-patterns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-patterns.d.ts","sourceRoot":"","sources":["../../src/syncer/file-patterns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEzE;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;CAW0B,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAChC,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,oBAAoB,CAAC;AACzD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,YAAY,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAExF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qCAAqC,IAAI,WAAW,CAAC,YAAY,CAAC,CAOjF"}
+{"version":3,"file":"file-patterns.d.ts","sourceRoot":"","sources":["../../src/syncer/file-patterns.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE9E;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;CAW0B,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAChC,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,oBAAoB,CAAC;AACzD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,YAAY,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAExF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qCAAqC,IAAI,WAAW,CAAC,YAAY,CAAC,CAOjF"}

package/dist/syncer/file-patterns.js

@@ -1,42 +1,42 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import path from "path";
-import { Sonamu } from "../api/sonamu.js";
-/**
- * Syncer가 관심 가지고 지켜보는 파일들입니다.
- * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
- * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
- *
- * **경로 형식**: API 상대 경로 (src/로 시작)
- * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
- */ const checksumPatternGroup = {
-    config: "src/sonamu.config.ts",
-    entity: "src/application/**/*.entity.json",
-    frame: "src/application/**/*.frame.ts",
-    functions: "src/application/**/*.functions.ts",
-    generated: "src/application/sonamu.generated.ts",
-    model: "src/application/**/*.model.ts",
-    types: "src/application/**/*.types.ts",
-    workflow: "src/application/**/*.workflow.ts",
-    i18n: "src/i18n/**/!(sd.generated).ts",
-    i18nGenerated: "src/i18n/**/sd.generated.ts"
-};
-export { checksumPatternGroup };
+
+//#region src/syncer/file-patterns.ts
 /**
- * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
- *
- * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
- *
- * **사용처**: checksum.ts에서 실제 파일을 찾을 때
- *
- * @returns 절대 경로 기반 Glob 패턴 맵
- *
- * @example
- * // 입력: { entity: "src/application/**\/*.entity.json" }
- * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
- */ export function getChecksumPatternGroupInAbsolutePath() {
-    return Object.fromEntries(Object.entries(checksumPatternGroup).map(([key, value])=>[
-            key,
-            path.join(Sonamu.apiRootPath, value)
-        ]));
+* API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
+*
+* **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
+*
+* **사용처**: checksum.ts에서 실제 파일을 찾을 때
+*
+* @returns 절대 경로 기반 Glob 패턴 맵
+*
+* @example
+* // 입력: { entity: "src/application/**\/*.entity.json" }
+* // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
+*/
+function getChecksumPatternGroupInAbsolutePath() {
+	return Object.fromEntries(Object.entries(checksumPatternGroup).map(([key, value]) => [key, path.join(Sonamu.apiRootPath, value)]));
 }
+var checksumPatternGroup;
+var init_file_patterns = __esmMin((() => {
+	init_sonamu();
+	checksumPatternGroup = {
+		config: "src/sonamu.config.ts",
+		entity: "src/application/**/*.entity.json",
+		frame: "src/application/**/*.frame.ts",
+		functions: "src/application/**/*.functions.ts",
+		generated: "src/application/sonamu.generated.ts",
+		model: "src/application/**/*.model.ts",
+		types: "src/application/**/*.types.ts",
+		workflow: "src/application/**/*.workflow.ts",
+		i18n: "src/i18n/**/!(sd.generated).ts",
+		i18nGenerated: "src/i18n/**/sd.generated.ts"
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jZXIvZmlsZS1wYXR0ZXJucy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgcGF0aCBmcm9tIFwicGF0aFwiO1xuaW1wb3J0IHsgU29uYW11IH0gZnJvbSBcIi4uL2FwaS9zb25hbXVcIjtcbmltcG9ydCB0eXBlIHsgQWJzb2x1dGVQYXRoLCBBcGlSZWxhdGl2ZVBhdGggfSBmcm9tIFwiLi4vdXRpbHMvcGF0aC11dGlsc1wiO1xuXG4vKipcbiAqIFN5bmNlcuqwgCDqtIDsi6wg6rCA7KeA6rOgIOyngOy8nOuztOuKlCDtjIzsnbzrk6TsnoXri4jri6QuXG4gKiDsnbQg7YyM7J2865Ok7JeQIOuzgOqyveydtCDsg53quLDrqbQg7LaU6rCA7KCB7J24IOyekeyXhSjsnbTtlZggXCLsi7HtgaxcIiDrmJDripQgXCLsi7Htgawg7JWh7IWYXCIp7J2EIOyImO2Wie2VqeuLiOuLpC5cbiAqIOydtCDsnpHsl4XsnbTrnbwg7ZWo7J2AIO2MjOydvCDrs7Xsgqwg65iQ64qUIO2FnO2UjOumvyDroIzrjZTrp4HsnYQg7Ya17ZWcIGNvZGUgZ2VuZXJhdGlvbuydhCDsnZjrr7jtlanri4jri6QuXG4gKlxuICogKirqsr3roZwg7ZiV7IudKio6IEFQSSDsg4HrjIAg6rK966GcIChzcmMv66GcIOyLnOyekSlcbiAqICoq7IKs7JqpKio6IGdldENoZWNrc3VtUGF0dGVybkdyb3VwSW5BYnNvbHV0ZVBhdGgoKeuhnCDsoIjrjIAg6rK966GcIOuzgO2ZmCDtm4QgZ2xvYiDsgqzsmqlcbiAqL1xuY29uc3QgY2hlY2tzdW1QYXR0ZXJuR3JvdXAgPSB7XG4gIGNvbmZpZzogXCJzcmMvc29uYW11LmNvbmZpZy50c1wiLFxuICBlbnRpdHk6IFwic3JjL2FwcGxpY2F0aW9uLyoqLyouZW50aXR5Lmpzb25cIixcbiAgZnJhbWU6IFwic3JjL2FwcGxpY2F0aW9uLyoqLyouZnJhbWUudHNcIixcbiAgZnVuY3Rpb25zOiBcInNyYy9hcHBsaWNhdGlvbi8qKi8qLmZ1bmN0aW9ucy50c1wiLFxuICBnZW5lcmF0ZWQ6IFwic3JjL2FwcGxpY2F0aW9uL3NvbmFtdS5nZW5lcmF0ZWQudHNcIixcbiAgbW9kZWw6IFwic3JjL2FwcGxpY2F0aW9uLyoqLyoubW9kZWwudHNcIixcbiAgdHlwZXM6IFwic3JjL2FwcGxpY2F0aW9uLyoqLyoudHlwZXMudHNcIixcbiAgd29ya2Zsb3c6IFwic3JjL2FwcGxpY2F0aW9uLyoqLyoud29ya2Zsb3cudHNcIixcbiAgaTE4bjogXCJzcmMvaTE4bi8qKi8hKHNkLmdlbmVyYXRlZCkudHNcIixcbiAgaTE4bkdlbmVyYXRlZDogXCJzcmMvaTE4bi8qKi9zZC5nZW5lcmF0ZWQudHNcIixcbn0gYXMgY29uc3Qgc2F0aXNmaWVzIFJlY29yZDxzdHJpbmcsIEFwaVJlbGF0aXZlUGF0aD47XG5cbmV4cG9ydCB7IGNoZWNrc3VtUGF0dGVybkdyb3VwIH07XG5leHBvcnQgdHlwZSBGaWxlVHlwZSA9IGtleW9mIHR5cGVvZiBjaGVja3N1bVBhdHRlcm5Hcm91cDtcbmV4cG9ydCB0eXBlIEdsb2JQYXR0ZXJuPFQgZXh0ZW5kcyBBcGlSZWxhdGl2ZVBhdGggfCBBYnNvbHV0ZVBhdGg+ID0gUmVjb3JkPEZpbGVUeXBlLCBUPjtcblxuLyoqXG4gKiBBUEkg7IOB64yAIOqyveuhnCDtjKjthLTsnYQg7KCI64yAIOqyveuhnCDtjKjthLTsnLzroZwg67OA7ZmY7ZWp64uI64ukLlxuICpcbiAqICoq66qp7KCBKio6IEdsb2Ig7Yyo7YS07J2EIO2MjOydvOyLnOyKpO2FnOyXkOyEnCDsgqzsmqntlaAg7IiYIOyeiOuKlCDsoIjrjIAg6rK966Gc66GcIOuzgO2ZmFxuICpcbiAqICoq7IKs7Jqp7LKYKio6IGNoZWNrc3VtLnRz7JeQ7IScIOyLpOygnCDtjIzsnbzsnYQg7LC+7J2EIOuVjFxuICpcbiAqIEByZXR1cm5zIOygiOuMgCDqsr3roZwg6riw67CYIEdsb2Ig7Yyo7YS0IOuntVxuICpcbiAqIEBleGFtcGxlXG4gKiAvLyDsnoXroKU6IHsgZW50aXR5OiBcInNyYy9hcHBsaWNhdGlvbi8qKlxcLyouZW50aXR5Lmpzb25cIiB9XG4gKiAvLyDstpzroKU6IHsgZW50aXR5OiBcIi9Vc2Vycy8uLi4vYXBpL3NyYy9hcHBsaWNhdGlvbi8qKlxcLyouZW50aXR5Lmpzb25cIiB9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRDaGVja3N1bVBhdHRlcm5Hcm91cEluQWJzb2x1dGVQYXRoKCk6IEdsb2JQYXR0ZXJuPEFic29sdXRlUGF0aD4ge1xuICByZXR1cm4gT2JqZWN0LmZyb21FbnRyaWVzKFxuICAgIE9iamVjdC5lbnRyaWVzKGNoZWNrc3VtUGF0dGVybkdyb3VwKS5tYXAoKFtrZXksIHZhbHVlXSkgPT4gW1xuICAgICAga2V5LFxuICAgICAgcGF0aC5qb2luKFNvbmFtdS5hcGlSb290UGF0aCwgdmFsdWUpLCAvLyBBUEkg7IOB64yAIOqyveuhnCDihpIg7KCI64yAIOqyveuhnFxuICAgIF0pLFxuICApIGFzIEdsb2JQYXR0ZXJuPEFic29sdXRlUGF0aD47XG59XG4iXSwibmFtZXMiOlsicGF0aCIsIlNvbmFtdSIsImNoZWNrc3VtUGF0dGVybkdyb3VwIiwiY29uZmlnIiwiZW50aXR5IiwiZnJhbWUiLCJmdW5jdGlvbnMiLCJnZW5lcmF0ZWQiLCJtb2RlbCIsInR5cGVzIiwid29ya2Zsb3ciLCJpMThuIiwiaTE4bkdlbmVyYXRlZCIsImdldENoZWNrc3VtUGF0dGVybkdyb3VwSW5BYnNvbHV0ZVBhdGgiLCJPYmplY3QiLCJmcm9tRW50cmllcyIsImVudHJpZXMiLCJtYXAiLCJrZXkiLCJ2YWx1ZSIsImpvaW4iLCJhcGlSb290UGF0aCJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsVUFBVSxPQUFPO0FBQ3hCLFNBQVNDLE1BQU0sUUFBUSxtQkFBZ0I7QUFHdkM7Ozs7Ozs7Q0FPQyxHQUNELE1BQU1DLHVCQUF1QjtJQUMzQkMsUUFBUTtJQUNSQyxRQUFRO0lBQ1JDLE9BQU87SUFDUEMsV0FBVztJQUNYQyxXQUFXO0lBQ1hDLE9BQU87SUFDUEMsT0FBTztJQUNQQyxVQUFVO0lBQ1ZDLE1BQU07SUFDTkMsZUFBZTtBQUNqQjtBQUVBLFNBQVNWLG9CQUFvQixHQUFHO0FBSWhDOzs7Ozs7Ozs7Ozs7Q0FZQyxHQUNELE9BQU8sU0FBU1c7SUFDZCxPQUFPQyxPQUFPQyxXQUFXLENBQ3ZCRCxPQUFPRSxPQUFPLENBQUNkLHNCQUFzQmUsR0FBRyxDQUFDLENBQUMsQ0FBQ0MsS0FBS0MsTUFBTSxHQUFLO1lBQ3pERDtZQUNBbEIsS0FBS29CLElBQUksQ0FBQ25CLE9BQU9vQixXQUFXLEVBQUVGO1NBQy9CO0FBRUwifQ==
+//#endregion
+init_file_patterns();
+export { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/index.js

@@ -1,9 +1,20 @@
-export * from "./api-parser.js";
-export * from "./checksum.js";
-export * from "./code-generator.js";
-export * from "./entity-operations.js";
-export * from "./file-patterns.js";
-export * from "./module-loader.js";
-export * from "./syncer.js";
+import { init_api_parser, readApisFromFile } from "./api-parser.js";
+import { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { findChangedFilesUsingChecksums, init_checksum, renewChecksums } from "./checksum.js";
+import { generateTemplate, init_code_generator, renderTemplate } from "./code-generator.js";
+import { createEntity, delEntity, init_entity_operations } from "./entity-operations.js";
+import { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader.js";
+import { Syncer, init_syncer } from "./syncer.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXBpLXBhcnNlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2hlY2tzdW1cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvZGUtZ2VuZXJhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lbnRpdHktb3BlcmF0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsZS1wYXR0ZXJuc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kdWxlLWxvYWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3luY2VyXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBZTtBQUM3QixjQUFjLGdCQUFhO0FBQzNCLGNBQWMsc0JBQW1CO0FBQ2pDLGNBQWMseUJBQXNCO0FBQ3BDLGNBQWMscUJBQWtCO0FBQ2hDLGNBQWMscUJBQWtCO0FBQ2hDLGNBQWMsY0FBVyJ9
+//#region src/syncer/index.ts
+init_api_parser();
+init_checksum();
+init_code_generator();
+init_entity_operations();
+init_file_patterns();
+init_module_loader();
+init_syncer();
+
+//#endregion
+export { Syncer, checksumPatternGroup, createEntity, delEntity, findChangedFilesUsingChecksums, generateTemplate, getChecksumPatternGroupInAbsolutePath, loadApis, loadModels, loadTypes, loadWorkflows, readApisFromFile, renderTemplate, renewChecksums };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNlci9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hcGktcGFyc2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jaGVja3N1bVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29kZS1nZW5lcmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2VudGl0eS1vcGVyYXRpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maWxlLXBhdHRlcm5zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2R1bGUtbG9hZGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zeW5jZXJcIjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/dist/syncer/module-loader.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import type { BaseFrameClass } from "../api/base-frame";
-import type { ApiDecoratorOptions } from "../api/decorators";
-import type { BaseModelClass } from "../database/base-model";
-import type { WorkflowMetadata } from "../tasks/decorator";
-import type { ApiParam, ApiParamType } from "../types/types";
+import { type BaseFrameClass } from "../api/base-frame";
+import { type ApiDecoratorOptions } from "../api/decorators";
+import { type BaseModelClass } from "../database/base-model";
+import { type WorkflowMetadata } from "../tasks/decorator";
+import { type ApiParam, type ApiParamType } from "../types/types";
 export type LoadedApis = {
     typeParameters: ApiParamType.TypeParam[];
     parameters: ApiParam[];

package/dist/syncer/module-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-loader.d.ts","sourceRoot":"","sources":["../../src/syncer/module-loader.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAM7D,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,CAAC;IACzC,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,UAAU,EAAE,YAAY,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,mBAAmB,CAAC;CAC9B,EAAE,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CA+BpD;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,CAmBxD;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CAkBtD;AAED;;GAEG;AACH,wBAAsB,aAAa,6CA6BlC"}
+{"version":3,"file":"module-loader.d.ts","sourceRoot":"","sources":["../../src/syncer/module-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOlE,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,CAAC;IACzC,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,UAAU,EAAE,YAAY,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,mBAAmB,CAAC;CAC9B,EAAE,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CA+BpD;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC,CAmBxD;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CAkBtD;AAED;;GAEG;AACH,wBAAsB,aAAa,6CA6BlC"}

package/dist/syncer/module-loader.js

@@ -1,88 +1,93 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { globAsync, init_async_utils } from "../utils/async-utils.js";
+import { importMembers, init_esm_utils } from "../utils/esm-utils.js";
+import { init_path_utils, runtimePath } from "../utils/path-utils.js";
+import { init_api_parser, readApisFromFile } from "./api-parser.js";
+import { z as z$1 } from "zod";
 import path from "path";
-import { z } from "zod";
-import { Sonamu } from "../api/sonamu.js";
-import { globAsync } from "../utils/async-utils.js";
-import { importMembers } from "../utils/esm-utils.js";
-import { runtimePath } from "../utils/path-utils.js";
-import { readApisFromFile } from "./api-parser.js";
+
+//#region src/syncer/module-loader.ts
 /**
- * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
- * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
- * 따라서 loadModels()를 먼저 호출해야 합니다.
- */ export async function loadApis() {
-    // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,
-    // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.
-    // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.
-    // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!
-    const modelPathsPattern = path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts");
-    const modelPaths = await globAsync(modelPathsPattern);
-    const apis = [];
-    for (const filePath of modelPaths){
-        const parsedApis = await readApisFromFile(filePath);
-        apis.push(...parsedApis);
-    }
-    // console.log(
-    //   chalk.gray(`[Loading] Loaded APIs from "*.model.ts" files: ${count} files.`)
-    // );
-    for (const api of apis){
-        if (api.path === "") {
-            // api의 경로(path)가 "텅 비어있음"인 상태입니다.
-            // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.
-            throw new Error(`API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`);
-        }
-    }
-    return apis;
+* *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.
+* registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.
+* 따라서 loadModels()를 먼저 호출해야 합니다.
+*/
+async function loadApis() {
+	const modelPathsPattern = path.join(Sonamu.apiRootPath, "src/application/**/*.{model,frame}.ts");
+	const modelPaths = await globAsync(modelPathsPattern);
+	const apis = [];
+	for (const filePath of modelPaths) {
+		const parsedApis = await readApisFromFile(filePath);
+		apis.push(...parsedApis);
+	}
+	for (const api of apis) {
+		if (api.path === "") {
+			throw new Error(`API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`);
+		}
+	}
+	return apis;
 }
 /**
- * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
- */ export async function loadModels() {
-    const modelPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts"));
-    const modelPaths = await globAsync(modelPathsPattern);
-    const models = {};
-    for (const filePath of modelPaths){
-        const importedMembers = await importMembers(filePath);
-        for (const { name, value } of importedMembers){
-            if (name.endsWith("Model") || name.endsWith("Frame")) {
-                models[name] = value;
-            }
-        }
-    }
-    return models;
+* *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.
+*/
+async function loadModels() {
+	const modelPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.{model,frame}.ts"));
+	const modelPaths = await globAsync(modelPathsPattern);
+	const models = {};
+	for (const filePath of modelPaths) {
+		const importedMembers = await importMembers(filePath);
+		for (const { name, value } of importedMembers) {
+			if (name.endsWith("Model") || name.endsWith("Frame")) {
+				models[name] = value;
+			}
+		}
+	}
+	return models;
 }
 /**
- * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.
- */ export async function loadTypes() {
-    const typePathsPatterns = [
-        path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")),
-        path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts"))
-    ];
-    const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();
-    const types = {};
-    for (const filePath of typePaths){
-        const importedMembers = await importMembers(filePath);
-        for (const { name, value } of importedMembers){
-            if (value instanceof z.ZodType) {
-                types[name] = value;
-            }
-        }
-    }
-    return types;
+* *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.
+*/
+async function loadTypes() {
+	const typePathsPatterns = [path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")), path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts"))];
+	const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();
+	const types = {};
+	for (const filePath of typePaths) {
+		const importedMembers = await importMembers(filePath);
+		for (const { name, value } of importedMembers) {
+			if (value instanceof z$1.ZodType) {
+				types[name] = value;
+			}
+		}
+	}
+	return types;
 }
 /**
- * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
- */ export async function loadWorkflows() {
-    const workflowPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts"));
-    const workflowPaths = await globAsync(workflowPathsPattern);
-    const workflows = new Map();
-    for (const filePath of workflowPaths){
-        const importedMembers = await importMembers(filePath);
-        workflows.set(filePath, importedMembers.filter(({ value })=>{
-            return typeof value === "object" && value !== null && "type" in value && value.type === "workflow" && "fn" in value && typeof value.fn === "function";
-        }).map(({ value })=>{
-            return value;
-        }));
-    }
-    return workflows;
+* *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.
+*/
+async function loadWorkflows() {
+	const workflowPathsPattern = path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.workflow.ts"));
+	const workflowPaths = await globAsync(workflowPathsPattern);
+	const workflows = new Map();
+	for (const filePath of workflowPaths) {
+		const importedMembers = await importMembers(filePath);
+		workflows.set(filePath, importedMembers.filter(({ value }) => {
+			return typeof value === "object" && value !== null && "type" in value && value.type === "workflow" && "fn" in value && typeof value.fn === "function";
+		}).map(({ value }) => {
+			return value;
+		}));
+	}
+	return workflows;
 }
+var init_module_loader = __esmMin((() => {
+	init_sonamu();
+	init_async_utils();
+	init_esm_utils();
+	init_path_utils();
+	init_api_parser();
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\nimport { z } from \"zod\";\nimport type { BaseFrameClass } from \"../api/base-frame\";\nimport type { ApiDecoratorOptions } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport type { BaseModelClass } from \"../database/base-model\";\nimport type { WorkflowMetadata } from \"../tasks/decorator\";\nimport type { ApiParam, ApiParamType } from \"../types/types\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { type AbsolutePath, runtimePath } from \"../utils/path-utils\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = {\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n}[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths = (await globAsync(modelPathsPattern)) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            typeof value === \"object\" &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            typeof value.fn === \"function\"\n          );\n        })\n        .map(({ value }) => {\n          return value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"names":["path","z","Sonamu","globAsync","importMembers","runtimePath","readApisFromFile","loadApis","modelPathsPattern","join","apiRootPath","modelPaths","apis","filePath","parsedApis","push","api","Error","modelName","methodName","loadModels","models","importedMembers","name","value","endsWith","loadTypes","typePathsPatterns","typePaths","Promise","all","map","flat","types","ZodType","loadWorkflows","workflowPathsPattern","workflowPaths","workflows","Map","set","filter","type","fn"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AACxB,SAASC,CAAC,QAAQ,MAAM;AAGxB,SAASC,MAAM,QAAQ,mBAAgB;AAIvC,SAASC,SAAS,QAAQ,0BAAuB;AACjD,SAASC,aAAa,QAAQ,wBAAqB;AACnD,SAA4BC,WAAW,QAAQ,yBAAsB;AACrE,SAASC,gBAAgB,QAAQ,kBAAe;AAkBhD;;;;CAIC,GACD,OAAO,eAAeC;IACpB,8CAA8C;IAC9C,gCAAgC;IAChC,oDAAoD;IACpD,0CAA0C;IAC1C,MAAMC,oBAAoBR,KAAKS,IAAI,CACjCP,OAAOQ,WAAW,EAClB;IAEF,MAAMC,aAAc,MAAMR,UAAUK;IAEpC,MAAMI,OAAmB,EAAE;IAC3B,KAAK,MAAMC,YAAYF,WAAY;QACjC,MAAMG,aAAa,MAAMR,iBAAiBO;QAC1CD,KAAKG,IAAI,IAAID;IACf;IACA,eAAe;IACf,iFAAiF;IACjF,KAAK;IAEL,KAAK,MAAME,OAAOJ,KAAM;QACtB,IAAII,IAAIhB,IAAI,KAAK,IAAI;YACnB,kCAAkC;YAClC,+CAA+C;YAC/C,MAAM,IAAIiB,MACR,CAAC,IAAI,EAAED,IAAIE,SAAS,CAAC,CAAC,EAAEF,IAAIG,UAAU,CAAC,yDAAyD,CAAC;QAErG;IACF;IAEA,OAAOP;AACT;AAEA;;CAEC,GACD,OAAO,eAAeQ;IACpB,MAAMZ,oBAAoBR,KAAKS,IAAI,CACjCP,OAAOQ,WAAW,EAClBL,YAAY;IAEd,MAAMM,aAAa,MAAMR,UAAUK;IAEnC,MAAMa,SAAuB,CAAC;IAC9B,KAAK,MAAMR,YAAYF,WAAY;QACjC,MAAMW,kBAAkB,MAAMlB,cAA+CS;QAE7E,KAAK,MAAM,EAAEU,IAAI,EAAEC,KAAK,EAAE,IAAIF,gBAAiB;YAC7C,IAAIC,KAAKE,QAAQ,CAAC,YAAYF,KAAKE,QAAQ,CAAC,UAAU;gBACpDJ,MAAM,CAACE,KAAK,GAAGC;YACjB;QACF;IACF;IAEA,OAAOH;AACT;AAEA;;CAEC,GACD,OAAO,eAAeK;IACpB,MAAMC,oBAAoB;QACxB3B,KAAKS,IAAI,CAACP,OAAOQ,WAAW,EAAEL,YAAY;QAC1CL,KAAKS,IAAI,CAACP,OAAOQ,WAAW,EAAEL,YAAY;KAC3C;IACD,MAAMuB,YAAY,AAAC,CAAA,MAAMC,QAAQC,GAAG,CAACH,kBAAkBI,GAAG,CAAC5B,WAAU,EAAG6B,IAAI;IAE5E,MAAMC,QAAqB,CAAC;IAC5B,KAAK,MAAMpB,YAAYe,UAAW;QAChC,MAAMN,kBAAkB,MAAMlB,cAAyBS;QACvD,KAAK,MAAM,EAAEU,IAAI,EAAEC,KAAK,EAAE,IAAIF,gBAAiB;YAC7C,IAAIE,iBAAiBvB,EAAEiC,OAAO,EAAE;gBAC9BD,KAAK,CAACV,KAAK,GAAGC;YAChB;QACF;IACF;IAEA,OAAOS;AACT;AAEA;;CAEC,GACD,OAAO,eAAeE;IACpB,MAAMC,uBAAuBpC,KAAKS,IAAI,CACpCP,OAAOQ,WAAW,EAClBL,YAAY;IAEd,MAAMgC,gBAAgB,MAAMlC,UAAUiC;IACtC,MAAME,YAA6C,IAAIC;IACvD,KAAK,MAAM1B,YAAYwB,cAAe;QACpC,MAAMf,kBAAkB,MAAMlB,cAAcS;QAC5CyB,UAAUE,GAAG,CACX3B,UACAS,gBACGmB,MAAM,CAAC,CAAC,EAAEjB,KAAK,EAAE;YAChB,OACE,OAAOA,UAAU,YACjBA,UAAU,QACV,UAAUA,SACVA,MAAMkB,IAAI,KAAK,cACf,QAAQlB,SACR,OAAOA,MAAMmB,EAAE,KAAK;QAExB,GACCZ,GAAG,CAAC,CAAC,EAAEP,KAAK,EAAE;YACb,OAAOA;QACT;IAEN;IAEA,OAAOc;AACT"}
+//#endregion
+init_module_loader();
+export { init_module_loader, loadApis, loadModels, loadTypes, loadWorkflows };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"module-loader.js","names":["apis: LoadedApis","models: LoadedModels","types: LoadedTypes","z","workflows: Map<string, WorkflowMetadata[]>"],"sources":["../../src/syncer/module-loader.ts"],"sourcesContent":["import path from \"path\";\n\nimport { z } from \"zod\";\n\nimport { type BaseFrameClass } from \"../api/base-frame\";\nimport { type ApiDecoratorOptions } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\nimport { type ApiParam, type ApiParamType } from \"../types/types\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { importMembers } from \"../utils/esm-utils\";\nimport { runtimePath } from \"../utils/path-utils\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { readApisFromFile } from \"./api-parser\";\n\nexport type LoadedApis = {\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n  modelName: string;\n  methodName: string;\n  path: string;\n  options: ApiDecoratorOptions;\n}[];\n\nexport type LoadedTypes = { [typeName: string]: z.ZodType };\n\nexport type LoadedModels = {\n  [modelName: string]: BaseModelClass | BaseFrameClass;\n};\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 API 메소드를 파싱하여 로드합니다.\n * registeredApis에 API가 등록되어 있어야 하기 때문에, *.model.ts 파일들을 먼저 import해야 합니다.\n * 따라서 loadModels()를 먼저 호출해야 합니다.\n */\nexport async function loadApis(): Promise<LoadedApis> {\n  // 얘는 특이하게도 환경에 따라 .ts나 .js를 import하는 경우가 아니고,\n  // 타입이 살아있는 .ts 소스 코드만을 읽어야 합니다.\n  // 이것은 dev서버(hot reload)가 아닌 production 환경에서도 동일합니다.\n  // 모델들의 .ts 파일이 있어야 이를 읽어서 라우트를 등록할 수 있어요!\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    \"src/application/**/*.{model,frame}.ts\", // !! runtimePath 안 씀 주의 !!\n  );\n  const modelPaths = (await globAsync(modelPathsPattern)) as AbsolutePath[];\n\n  const apis: LoadedApis = [];\n  for (const filePath of modelPaths) {\n    const parsedApis = await readApisFromFile(filePath);\n    apis.push(...parsedApis);\n  }\n  // console.log(\n  //   chalk.gray(`[Loading] Loaded APIs from \"*.model.ts\" files: ${count} files.`)\n  // );\n\n  for (const api of apis) {\n    if (api.path === \"\") {\n      // api의 경로(path)가 \"텅 비어있음\"인 상태입니다.\n      // 이는 @api와 함께 사용해야 하는 데코레이터가 @api 없이 붙은 상황입니다.\n      throw new Error(\n        `API ${api.modelName}.${api.methodName} has no path. Please attach @api decorator to the method.`,\n      );\n    }\n  }\n\n  return apis;\n}\n\n/**\n * *.model.ts와 *.frame.ts 파일들에서 Model/Frame 클래스 인스턴스를 로드합니다.\n */\nexport async function loadModels(): Promise<LoadedModels> {\n  const modelPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.{model,frame}.ts\"),\n  );\n  const modelPaths = await globAsync(modelPathsPattern);\n\n  const models: LoadedModels = {};\n  for (const filePath of modelPaths) {\n    const importedMembers = await importMembers<BaseModelClass | BaseFrameClass>(filePath);\n\n    for (const { name, value } of importedMembers) {\n      if (name.endsWith(\"Model\") || name.endsWith(\"Frame\")) {\n        models[name] = value;\n      }\n    }\n  }\n\n  return models;\n}\n\n/**\n * *.types.ts와 *.generated.ts 파일들에서 Zod 스키마를 로드합니다.\n */\nexport async function loadTypes(): Promise<LoadedTypes> {\n  const typePathsPatterns = [\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.types.ts\")),\n    path.join(Sonamu.apiRootPath, runtimePath(\"src/application/**/*.generated.ts\")),\n  ];\n  const typePaths = (await Promise.all(typePathsPatterns.map(globAsync))).flat();\n\n  const types: LoadedTypes = {};\n  for (const filePath of typePaths) {\n    const importedMembers = await importMembers<z.ZodType>(filePath);\n    for (const { name, value } of importedMembers) {\n      if (value instanceof z.ZodType) {\n        types[name] = value;\n      }\n    }\n  }\n\n  return types;\n}\n\n/**\n * *.workflow.ts 파일들에서 Workflow 메타데이터를 로드합니다.\n */\nexport async function loadWorkflows() {\n  const workflowPathsPattern = path.join(\n    Sonamu.apiRootPath,\n    runtimePath(\"src/application/**/*.workflow.ts\"),\n  );\n  const workflowPaths = await globAsync(workflowPathsPattern);\n  const workflows: Map<string, WorkflowMetadata[]> = new Map();\n  for (const filePath of workflowPaths) {\n    const importedMembers = await importMembers(filePath);\n    workflows.set(\n      filePath,\n      importedMembers\n        .filter(({ value }) => {\n          return (\n            typeof value === \"object\" &&\n            value !== null &&\n            \"type\" in value &&\n            value.type === \"workflow\" &&\n            \"fn\" in value &&\n            typeof value.fn === \"function\"\n          );\n        })\n        .map(({ value }) => {\n          return value as WorkflowMetadata;\n        }),\n    );\n  }\n\n  return workflows;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAqCA,eAAsB,WAAgC;CAKpD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,wCACD;CACD,MAAM,aAAc,MAAM,UAAU,kBAAkB;CAEtD,MAAMA,OAAmB,EAAE;AAC3B,MAAK,MAAM,YAAY,YAAY;EACjC,MAAM,aAAa,MAAM,iBAAiB,SAAS;AACnD,OAAK,KAAK,GAAG,WAAW;;AAM1B,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,IAAI,SAAS,IAAI;AAGnB,SAAM,IAAI,MACR,OAAO,IAAI,UAAU,GAAG,IAAI,WAAW,2DACxC;;;AAIL,QAAO;;;;;AAMT,eAAsB,aAAoC;CACxD,MAAM,oBAAoB,KAAK,KAC7B,OAAO,aACP,YAAY,wCAAwC,CACrD;CACD,MAAM,aAAa,MAAM,UAAU,kBAAkB;CAErD,MAAMC,SAAuB,EAAE;AAC/B,MAAK,MAAM,YAAY,YAAY;EACjC,MAAM,kBAAkB,MAAM,cAA+C,SAAS;AAEtF,OAAK,MAAM,EAAE,MAAM,WAAW,iBAAiB;AAC7C,OAAI,KAAK,SAAS,QAAQ,IAAI,KAAK,SAAS,QAAQ,EAAE;AACpD,WAAO,QAAQ;;;;AAKrB,QAAO;;;;;AAMT,eAAsB,YAAkC;CACtD,MAAM,oBAAoB,CACxB,KAAK,KAAK,OAAO,aAAa,YAAY,gCAAgC,CAAC,EAC3E,KAAK,KAAK,OAAO,aAAa,YAAY,oCAAoC,CAAC,CAChF;CACD,MAAM,aAAa,MAAM,QAAQ,IAAI,kBAAkB,IAAI,UAAU,CAAC,EAAE,MAAM;CAE9E,MAAMC,QAAqB,EAAE;AAC7B,MAAK,MAAM,YAAY,WAAW;EAChC,MAAM,kBAAkB,MAAM,cAAyB,SAAS;AAChE,OAAK,MAAM,EAAE,MAAM,WAAW,iBAAiB;AAC7C,OAAI,iBAAiBC,IAAE,SAAS;AAC9B,UAAM,QAAQ;;;;AAKpB,QAAO;;;;;AAMT,eAAsB,gBAAgB;CACpC,MAAM,uBAAuB,KAAK,KAChC,OAAO,aACP,YAAY,mCAAmC,CAChD;CACD,MAAM,gBAAgB,MAAM,UAAU,qBAAqB;CAC3D,MAAMC,YAA6C,IAAI,KAAK;AAC5D,MAAK,MAAM,YAAY,eAAe;EACpC,MAAM,kBAAkB,MAAM,cAAc,SAAS;AACrD,YAAU,IACR,UACA,gBACG,QAAQ,EAAE,YAAY;AACrB,UACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,MAAM,SAAS,cACf,QAAQ,SACR,OAAO,MAAM,OAAO;IAEtB,CACD,KAAK,EAAE,YAAY;AAClB,UAAO;IACP,CACL;;AAGH,QAAO;;;cA9I8B;mBAIU;iBACE;kBACD;kBAEF"}

package/dist/syncer/syncer-actions.d.ts

@@ -1,5 +1,5 @@
-import type { EntityNamesRecord } from "../entity/entity-manager";
-import type { AbsolutePath } from "../utils/path-utils";
+import { type EntityNamesRecord } from "../entity/entity-manager";
+import { type AbsolutePath } from "../utils/path-utils";
 export declare function actionSyncConfig(): Promise<void>;
 /**
  * services.generated.ts를 생성합니다.

package/dist/syncer/syncer-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncer-actions.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer-actions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,wBAAsB,gBAAgB,kBAWrC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE;IACX,WAAW,EAAE,iBAAiB,CAAC;CAChC,EAAE,GACF,OAAO,CAAC,MAAM,EAAE,CAAC,CAanB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOrE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CAQjE;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOjE;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiCzF"}
+{"version":3,"file":"syncer-actions.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer-actions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,wBAAsB,gBAAgB,kBAWrC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE;IACX,WAAW,EAAE,iBAAiB,CAAC;CAChC,EAAE,GACF,OAAO,CAAC,MAAM,EAAE,CAAC,CAanB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOrE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CAQjE;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAOjE;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiCzF"}