sonamu 0.9.4 → 0.9.6

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

@@ -1,39 +1,61 @@
-import { type AbsolutePath, type ApiRelativePath } from "../utils/path-utils";
+import { type AbsolutePath, type AppRelativePath } from "../utils/path-utils";
 /**
  * Syncer가 관심 가지고 지켜보는 파일들입니다.
  * 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
  * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
  *
- * **경로 형식**: API 상대 경로 (src/로 시작)
- * **사용**: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ * 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: "api/src/...", "web/src/...")
+ * 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
+ *
+ * 두 가지 의미적 영역:
+ * - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.
+ * - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.
+ *
+ * 추적 밖 자산 (부트스트랩 phase에서 매번 보장):
+ * - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.
+ * - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.
+ *
+ * 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.
+ * 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.
+ *
+ * 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.
+ *
+ * FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을
+ * 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.
  */
-declare const checksumPatternGroup: {
-    readonly config: "src/sonamu.config.ts";
-    readonly entity: "src/application/**/*.entity.json";
-    readonly frame: "src/application/**/*.frame.ts";
-    readonly functions: "src/application/**/*.functions.ts";
-    readonly generated: "src/application/sonamu.generated.ts";
-    readonly model: "src/application/**/*.model.ts";
-    readonly types: "src/application/**/*.types.ts";
-    readonly workflow: "src/application/**/*.workflow.ts";
-    readonly i18n: "src/i18n/**/!(sd.generated).ts";
-    readonly i18nGenerated: "src/i18n/**/sd.generated.ts";
+export declare function getChecksumPatternGroup(): {
+    config: `${string}/src/${string}` | `${string}/dist/${string}`;
+    entity: `${string}/src/${string}` | `${string}/dist/${string}`;
+    frame: `${string}/src/${string}` | `${string}/dist/${string}`;
+    functions: `${string}/src/${string}` | `${string}/dist/${string}`;
+    model: `${string}/src/${string}` | `${string}/dist/${string}`;
+    types: `${string}/src/${string}` | `${string}/dist/${string}`;
+    workflow: `${string}/src/${string}` | `${string}/dist/${string}`;
+    i18n: `${string}/src/${string}` | `${string}/dist/${string}`;
+    generated: `${string}/src/${string}` | `${string}/dist/${string}`;
+    generatedCopied: `${string}/src/${string}` | `${string}/dist/${string}`;
+    httpGenerated: `${string}/src/${string}` | `${string}/dist/${string}`;
+    servicesGenerated: `${string}/src/${string}` | `${string}/dist/${string}`;
+    sdGenerated: `${string}/src/${string}` | `${string}/dist/${string}`;
+    typesCopied: `${string}/src/${string}` | `${string}/dist/${string}`;
+    functionsCopied: `${string}/src/${string}` | `${string}/dist/${string}`;
+    i18nCopied: `${string}/src/${string}` | `${string}/dist/${string}`;
 };
-export { checksumPatternGroup };
-export type FileType = keyof typeof checksumPatternGroup;
-export type GlobPattern<T extends ApiRelativePath | AbsolutePath> = Record<FileType, T>;
 /**
- * API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
- *
- * **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
- *
- * **사용처**: checksum.ts에서 실제 파일을 찾을 때
+ * FileType은 getChecksumPatternGroup의 반환 객체 키에서 자동 추론됩니다.
+ * 별도 배열/enum 동기화 불필요 — 패턴 그룹 함수가 진실의 단일 원천.
+ */
+export type FileType = keyof ReturnType<typeof getChecksumPatternGroup>;
+export type GlobPattern<T extends AppRelativePath | AbsolutePath> = Record<FileType, T>;
+/**
+ * 빌드 산출물 디렉토리는 alternation 글롭이 의도치 않게 휘말릴 수 있으므로 안전망으로 제외.
+ * Node 내장 fs.glob의 exclude 옵션과 함께 사용합니다.
+ */
+export declare const GLOB_EXCLUDE: string[];
+/**
+ * appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
  *
  * @returns 절대 경로 기반 Glob 패턴 맵
- *
- * @example
- * // 입력: { entity: "src/application/**\/*.entity.json" }
- * // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
  */
 export declare function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath>;
 //# sourceMappingURL=file-patterns.d.ts.map

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":"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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;EAsCtC;AAyBD;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,eAAe,GAAG,YAAY,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,YAAY,UAAsE,CAAC;AAEhG;;;;GAIG;AACH,wBAAgB,qCAAqC,IAAI,WAAW,CAAC,YAAY,CAAC,CAQjF"}

package/dist/syncer/file-patterns.js

@@ -4,39 +4,87 @@ import path from "path";
 
 //#region src/syncer/file-patterns.ts
 /**
-* API 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
+* Syncer가 관심 가지고 지켜보는 파일들입니다.
+* 이 파일들에 변경이 생기면 추가적인 작업(이하 "싱크" 또는 "싱크 액션")을 수행합니다.
+* 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.
 *
-* **목적**: Glob 패턴을 파일시스템에서 사용할 수 있는 절대 경로로 변환
+* 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: "api/src/...", "web/src/...")
+* 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용
 *
-* **사용처**: checksum.ts에서 실제 파일을 찾을 때
+* 두 가지 의미적 영역:
+* - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.
+* - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.
 *
-* @returns 절대 경로 기반 Glob 패턴 맵
+* 추적 밖 자산 (부트스트랩 phase에서 매번 보장):
+* - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.
+* - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.
+*
+* 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.
+* 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.
+*
+* 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.
+*
+* FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을
+* 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.
+*/
+function getChecksumPatternGroup() {
+	const { api, targets, anywhere } = globBuilders();
+	return {
+		config: api("src/sonamu.config.ts"),
+		entity: api("src/application/**/*.entity.json"),
+		frame: api("src/application/**/*.frame.ts"),
+		functions: api("src/application/**/*.functions.ts"),
+		model: api("src/application/**/*.model.ts"),
+		types: api("src/application/**/*.types.ts"),
+		workflow: api("src/application/**/*.workflow.ts"),
+		i18n: api("src/i18n/**/!(sd.generated).ts"),
+		generated: api("src/application/**/*.generated.{ts,tsx,sso.ts}"),
+		generatedCopied: targets("src/services/**/{sonamu,queries}.generated.{ts,tsx,sso.ts}"),
+		httpGenerated: api("src/application/**/*.generated.http"),
+		servicesGenerated: targets("src/services/services.generated.ts"),
+		sdGenerated: anywhere("src/i18n/**/sd.generated.ts"),
+		typesCopied: targets("src/services/**/*.types.ts"),
+		functionsCopied: targets("src/services/**/*.functions.ts"),
+		i18nCopied: targets("src/i18n/**/!(sd.generated).ts")
+	};
+}
+/**
+* 위치 카테고리별 글롭 빌더를 만들어 반환합니다.
+* - api(rest): api 디렉토리에 한정
+* - targets(rest): target 디렉토리들에 한정 (web, app 등)
+* - anywhere(rest): api와 target 모두
+*/
+function globBuilders() {
+	const apiDir = Sonamu.config.api.dir;
+	const targetDirs = Sonamu.config.sync.targets;
+	const braceJoin = (dirs) => dirs.length === 1 ? dirs[0] : `{${dirs.join(",")}}`;
+	return {
+		api: (pathFromApi) => `${apiDir}/${pathFromApi}`,
+		targets: (pathFromTarget) => `${braceJoin(targetDirs)}/${pathFromTarget}`,
+		anywhere: (pathFromAnywhere) => `${braceJoin([apiDir, ...targetDirs])}/${pathFromAnywhere}`
+	};
+}
+/**
+* appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.
 *
-* @example
-* // 입력: { entity: "src/application/**\/*.entity.json" }
-* // 출력: { entity: "/Users/.../api/src/application/**\/*.entity.json" }
+* @returns 절대 경로 기반 Glob 패턴 맵
 */
 function getChecksumPatternGroupInAbsolutePath() {
-	return Object.fromEntries(Object.entries(checksumPatternGroup).map(([key, value]) => [key, path.join(Sonamu.apiRootPath, value)]));
+	const group = getChecksumPatternGroup();
+	return Object.fromEntries(Object.entries(group).map(([key, value]) => [key, path.join(Sonamu.appRootPath, value)]));
 }
-var checksumPatternGroup;
+var GLOB_EXCLUDE;
 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"
-	};
+	GLOB_EXCLUDE = [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/.turbo/**"
+	];
 }));
 
 //#endregion
 init_file_patterns();
-export { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { GLOB_EXCLUDE, getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"file-patterns.js","names":[],"sources":["../../src/syncer/file-patterns.ts"],"sourcesContent":["import path from \"path\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { type AbsolutePath, type AppRelativePath } from \"../utils/path-utils\";\n\n/**\n * Syncer가 관심 가지고 지켜보는 파일들입니다.\n * 이 파일들에 변경이 생기면 추가적인 작업(이하 \"싱크\" 또는 \"싱크 액션\")을 수행합니다.\n * 이 작업이라 함은 파일 복사 또는 템플릿 렌더링을 통한 code generation을 의미합니다.\n *\n * 경로 형식: appRoot 기준 상대 경로 (target 디렉토리로 시작, 예: \"api/src/...\", \"web/src/...\")\n * 사용: getChecksumPatternGroupInAbsolutePath()로 절대 경로 변환 후 glob 사용\n *\n * 두 가지 의미적 영역:\n * - 입력 (사용자 작성): api 디렉토리에만 위치. 사용자가 직접 편집.\n * - 출력 (sonamu 생성/복사): api 또는 target 디렉토리에 sonamu가 만들어내는 파일.\n *\n * 추적 밖 자산 (부트스트랩 phase에서 매번 보장):\n * - sonamu.shared.ts: 사용자가 커스터마이즈하는 자산. IfNotExists로 1회 생성 후 손대지 않음.\n * - entry-server.generated.tsx: 입력 의존 없는 정적 코드. 매번 overwrite generate.\n *\n * 위 둘은 sync()의 부트스트랩 phase에서 변경 검출 사이클과 무관하게 보장됩니다.\n * 추적 사이클 안에서 할 액션이 없는 자산이라 패턴 그룹에 포함되지 않습니다.\n *\n * 위치 카테고리는 api/targets/anywhere 헬퍼로 명시적으로 표현합니다.\n *\n * FileType은 이 함수의 반환 타입에서 자동 추론됩니다. 키 추가 시 별도 enum/배열을\n * 동기화할 필요 없이 여기 한 군데만 수정하면 됩니다.\n */\nexport function getChecksumPatternGroup() {\n  // 헬퍼 함수들 만들어서 가져옵니다.\n  const { api, targets, anywhere } = globBuilders();\n\n  return {\n    // Sonamu 입장에서 soruce가 되는 파일들입니다.\n    // 이 친구들이 변경되면 이들로부터 액션을 수행하고 파일을 생성합니다.\n    // 모노리포에서 이 source들은 api 프로젝트에 한정되므로, api에 있는 친구들만 리스팅합니다.\n    config: api(\"src/sonamu.config.ts\"),\n    entity: api(\"src/application/**/*.entity.json\"),\n    frame: api(\"src/application/**/*.frame.ts\"),\n    functions: api(\"src/application/**/*.functions.ts\"),\n    model: api(\"src/application/**/*.model.ts\"),\n    types: api(\"src/application/**/*.types.ts\"),\n    workflow: api(\"src/application/**/*.workflow.ts\"),\n    i18n: api(\"src/i18n/**/!(sd.generated).ts\"),\n\n    // Sonamu가 출력하는 생성 파일들입니다.\n    // 이 친구들도 정합성 검증 차원에서 sonamu.lock에 기록해야 하고,\n    // 또한 변경시 그 사실을 syncer가 알기는 해야 합니다(비록 별다른 처리가 없는 경우도 있지만).\n    //\n    // 자산 본성에 따라 위치 카테고리가 다르기 때문에, 본성별로 분리해서 표기합니다.\n    // - 양쪽-필요 자산: api에 정본이 만들어진 뒤 target에 복사됨 (sonamu.generated.*, queries.generated.ts).\n    // - api 전용 자산: api에만 만들어짐 (sonamu.generated.http).\n    // - target 전용 자산: target에만 만들어짐 (services.generated.ts는 services.template의 :target 분배).\n    //\n    // 여기에는 Sonamu의 모든 sync 산출물이 있는 것은 아닙니다.\n    // sonamu.shared.ts와 entry-server.generated.tsx와 같은\n    // sync 초반 1회성 부트스트랩 파일들은 관리 안 하기 때문에 여기에 리스팅도 안 합니다.\n    generated: api(\"src/application/**/*.generated.{ts,tsx,sso.ts}\"),\n    generatedCopied: targets(\"src/services/**/{sonamu,queries}.generated.{ts,tsx,sso.ts}\"),\n    httpGenerated: api(\"src/application/**/*.generated.http\"),\n    servicesGenerated: targets(\"src/services/services.generated.ts\"),\n    sdGenerated: anywhere(\"src/i18n/**/sd.generated.ts\"),\n    typesCopied: targets(\"src/services/**/*.types.ts\"),\n    functionsCopied: targets(\"src/services/**/*.functions.ts\"),\n    i18nCopied: targets(\"src/i18n/**/!(sd.generated).ts\"),\n  } satisfies Record<string, AppRelativePath>;\n}\n\n/**\n * 위치 카테고리별 글롭 빌더를 만들어 반환합니다.\n * - api(rest): api 디렉토리에 한정\n * - targets(rest): target 디렉토리들에 한정 (web, app 등)\n * - anywhere(rest): api와 target 모두\n */\nfunction globBuilders() {\n  const apiDir = Sonamu.config.api.dir;\n  const targetDirs = Sonamu.config.sync.targets;\n\n  // Node 내장 fs.glob의 brace expansion은 단일 멤버 {x}를 풀지 않으므로, 멤버가 1개일 때는 alternation 없이 직접 결합합니다.\n  const braceJoin = (dirs: readonly string[]) =>\n    dirs.length === 1 ? dirs[0] : `{${dirs.join(\",\")}}`;\n\n  return {\n    api: (pathFromApi: string) => `${apiDir}/${pathFromApi}` as AppRelativePath,\n    targets: (pathFromTarget: string) =>\n      `${braceJoin(targetDirs)}/${pathFromTarget}` as AppRelativePath,\n    anywhere: (pathFromAnywhere: string) =>\n      `${braceJoin([apiDir, ...targetDirs])}/${pathFromAnywhere}` as AppRelativePath,\n  };\n}\n\n/**\n * FileType은 getChecksumPatternGroup의 반환 객체 키에서 자동 추론됩니다.\n * 별도 배열/enum 동기화 불필요 — 패턴 그룹 함수가 진실의 단일 원천.\n */\nexport type FileType = keyof ReturnType<typeof getChecksumPatternGroup>;\nexport type GlobPattern<T extends AppRelativePath | AbsolutePath> = Record<FileType, T>;\n\n/**\n * 빌드 산출물 디렉토리는 alternation 글롭이 의도치 않게 휘말릴 수 있으므로 안전망으로 제외.\n * Node 내장 fs.glob의 exclude 옵션과 함께 사용합니다.\n */\nexport const GLOB_EXCLUDE = [\"**/node_modules/**\", \"**/dist/**\", \"**/build/**\", \"**/.turbo/**\"];\n\n/**\n * appRoot 기준 상대 경로 패턴을 절대 경로 패턴으로 변환합니다.\n *\n * @returns 절대 경로 기반 Glob 패턴 맵\n */\nexport function getChecksumPatternGroupInAbsolutePath(): GlobPattern<AbsolutePath> {\n  const group = getChecksumPatternGroup();\n  return Object.fromEntries(\n    Object.entries(group).map(([key, value]) => [\n      key,\n      path.join(Sonamu.appRootPath, value), // appRoot 상대 경로 → 절대 경로\n    ]),\n  ) as GlobPattern<AbsolutePath>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,0BAA0B;CAExC,MAAM,EAAE,KAAK,SAAS,aAAa,cAAc;AAEjD,QAAO;EAIL,QAAQ,IAAI,uBAAuB;EACnC,QAAQ,IAAI,mCAAmC;EAC/C,OAAO,IAAI,gCAAgC;EAC3C,WAAW,IAAI,oCAAoC;EACnD,OAAO,IAAI,gCAAgC;EAC3C,OAAO,IAAI,gCAAgC;EAC3C,UAAU,IAAI,mCAAmC;EACjD,MAAM,IAAI,iCAAiC;EAc3C,WAAW,IAAI,iDAAiD;EAChE,iBAAiB,QAAQ,6DAA6D;EACtF,eAAe,IAAI,sCAAsC;EACzD,mBAAmB,QAAQ,qCAAqC;EAChE,aAAa,SAAS,8BAA8B;EACpD,aAAa,QAAQ,6BAA6B;EAClD,iBAAiB,QAAQ,iCAAiC;EAC1D,YAAY,QAAQ,iCAAiC;EACtD;;;;;;;;AASH,SAAS,eAAe;CACtB,MAAM,SAAS,OAAO,OAAO,IAAI;CACjC,MAAM,aAAa,OAAO,OAAO,KAAK;CAGtC,MAAM,aAAa,SACjB,KAAK,WAAW,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,CAAC;AAEnD,QAAO;EACL,MAAM,gBAAwB,GAAG,OAAO,GAAG;EAC3C,UAAU,mBACR,GAAG,UAAU,WAAW,CAAC,GAAG;EAC9B,WAAW,qBACT,GAAG,UAAU,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAC,GAAG;EAC5C;;;;;;;AAqBH,SAAgB,wCAAmE;CACjF,MAAM,QAAQ,yBAAyB;AACvC,QAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,KAAK,CAAC,KAAK,WAAW,CAC1C,KACA,KAAK,KAAK,OAAO,aAAa,MAAM,CACrC,CAAC,CACH;;;;cAnHoC;CAqG1B,eAAe;EAAC;EAAsB;EAAc;EAAe;EAAe"}

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

@@ -0,0 +1,13 @@
+import { type AbsolutePath } from "../utils/path-utils";
+export declare const fileWrittenAt: Map<`/${string}`, number>;
+/**
+ * 우리가 디스크에 write한 path를 등록합니다. write 직후 호출하세요.
+ * 디스크에서 mtime을 직접 읽어 정확한 값으로 등록합니다.
+ */
+export declare function trackWritten(filePath: AbsolutePath): Promise<void>;
+/**
+ * 주어진 path가 가장 최근 우리 write 이후로 외부에서 수정된 적 없는지 확인합니다.
+ * true면 "내가 쓴 그대로 남아있음", false면 "외부에서 수정됐거나 우리가 쓴 적 없음".
+ */
+export declare function isLastChangedByMe(filePath: AbsolutePath): Promise<boolean>;
+//# sourceMappingURL=file-tracking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-tracking.d.ts","sourceRoot":"","sources":["../../src/syncer/file-tracking.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,eAAO,MAAM,aAAa,2BAAkC,CAAC;AAE7D;;;GAGG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAGxE;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAOhF"}

package/dist/syncer/file-tracking.js

@@ -0,0 +1,33 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { stat } from "fs/promises";
+
+//#region src/syncer/file-tracking.ts
+/**
+* 우리가 디스크에 write한 path를 등록합니다. write 직후 호출하세요.
+* 디스크에서 mtime을 직접 읽어 정확한 값으로 등록합니다.
+*/
+async function trackWritten(filePath) {
+	const fileStat = await stat(filePath);
+	fileWrittenAt.set(filePath, fileStat.mtimeMs);
+}
+/**
+* 주어진 path가 가장 최근 우리 write 이후로 외부에서 수정된 적 없는지 확인합니다.
+* true면 "내가 쓴 그대로 남아있음", false면 "외부에서 수정됐거나 우리가 쓴 적 없음".
+*/
+async function isLastChangedByMe(filePath) {
+	const registered = fileWrittenAt.get(filePath);
+	if (registered === undefined) {
+		return false;
+	}
+	const fileStat = await stat(filePath);
+	return fileStat.mtimeMs <= registered;
+}
+var fileWrittenAt;
+var init_file_tracking = __esmMin((() => {
+	fileWrittenAt = new Map();
+}));
+
+//#endregion
+init_file_tracking();
+export { fileWrittenAt, init_file_tracking, isLastChangedByMe, trackWritten };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS10cmFja2luZy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2VyL2ZpbGUtdHJhY2tpbmcudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3RhdCB9IGZyb20gXCJmcy9wcm9taXNlc1wiO1xuXG5pbXBvcnQgeyB0eXBlIEFic29sdXRlUGF0aCB9IGZyb20gXCIuLi91dGlscy9wYXRoLXV0aWxzXCI7XG5cbmV4cG9ydCBjb25zdCBmaWxlV3JpdHRlbkF0ID0gbmV3IE1hcDxBYnNvbHV0ZVBhdGgsIG51bWJlcj4oKTtcblxuLyoqXG4gKiDsmrDrpqzqsIAg65SU7Iqk7YGs7JeQIHdyaXRl7ZWcIHBhdGjrpbwg65Ox66Gd7ZWp64uI64ukLiB3cml0ZSDsp4Htm4Qg7Zi47Lac7ZWY7IS47JqULlxuICog65SU7Iqk7YGs7JeQ7IScIG10aW1l7J2EIOyngeygkSDsnb3slrQg7KCV7ZmV7ZWcIOqwkuycvOuhnCDrk7HroZ3tlanri4jri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB0cmFja1dyaXR0ZW4oZmlsZVBhdGg6IEFic29sdXRlUGF0aCk6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICBmaWxlV3JpdHRlbkF0LnNldChmaWxlUGF0aCwgZmlsZVN0YXQubXRpbWVNcyk7XG59XG5cbi8qKlxuICog7KO87Ja07KeEIHBhdGjqsIAg6rCA7J6lIOy1nOq3vCDsmrDrpqwgd3JpdGUg7J207ZuE66GcIOyZuOu2gOyXkOyEnCDsiJjsoJXrkJwg7KCBIOyXhuuKlOyngCDtmZXsnbjtlanri4jri6QuXG4gKiB0cnVl66m0IFwi64K06rCAIOyTtCDqt7jrjIDroZwg64Ko7JWE7J6I7J2MXCIsIGZhbHNl66m0IFwi7Jm467aA7JeQ7IScIOyImOygleuQkOqxsOuCmCDsmrDrpqzqsIAg7JO0IOyggSDsl4bsnYxcIi5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGlzTGFzdENoYW5nZWRCeU1lKGZpbGVQYXRoOiBBYnNvbHV0ZVBhdGgpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgY29uc3QgcmVnaXN0ZXJlZCA9IGZpbGVXcml0dGVuQXQuZ2V0KGZpbGVQYXRoKTtcbiAgaWYgKHJlZ2lzdGVyZWQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuICBjb25zdCBmaWxlU3RhdCA9IGF3YWl0IHN0YXQoZmlsZVBhdGgpO1xuICByZXR1cm4gZmlsZVN0YXQubXRpbWVNcyA8PSByZWdpc3RlcmVkO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQVVBLGVBQXNCLGFBQWEsVUFBdUM7Q0FDeEUsTUFBTSxXQUFXLE1BQU0sS0FBSyxTQUFTO0FBQ3JDLGVBQWMsSUFBSSxVQUFVLFNBQVMsUUFBUTs7Ozs7O0FBTy9DLGVBQXNCLGtCQUFrQixVQUEwQztDQUNoRixNQUFNLGFBQWEsY0FBYyxJQUFJLFNBQVM7QUFDOUMsS0FBSSxlQUFlLFdBQVc7QUFDNUIsU0FBTzs7Q0FFVCxNQUFNLFdBQVcsTUFBTSxLQUFLLFNBQVM7QUFDckMsUUFBTyxTQUFTLFdBQVc7Ozs7Q0FyQmhCLGdCQUFnQixJQUFJLEtBQTJCIn0=

package/dist/syncer/index.js

@@ -1,5 +1,5 @@
 import { init_api_parser, readApisFromFile } from "./api-parser.js";
-import { checksumPatternGroup, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { GLOB_EXCLUDE, getChecksumPatternGroup, 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";
@@ -16,5 +16,5 @@ init_module_loader();
 init_syncer();
 
 //#endregion
-export { Syncer, checksumPatternGroup, createEntity, delEntity, findChangedFilesUsingChecksums, generateTemplate, getChecksumPatternGroupInAbsolutePath, loadApis, loadModels, loadTypes, loadWorkflows, readApisFromFile, renderTemplate, renewChecksums };
+export { GLOB_EXCLUDE, Syncer, createEntity, delEntity, findChangedFilesUsingChecksums, generateTemplate, getChecksumPatternGroup, 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,18 +1,9 @@
 import { z } from "zod";
 import { type BaseFrameClass } from "../api/base-frame";
-import { type ApiDecoratorOptions } from "../api/decorators";
+import { type ExtendedApi } 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[];
-    returnType: ApiParamType;
-    modelName: string;
-    methodName: string;
-    path: string;
-    options: ApiDecoratorOptions;
-}[];
+export type LoadedApis = ExtendedApi[];
 export type LoadedTypes = {
     [typeName: string]: z.ZodType;
 };

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":"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"}
+{"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,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAO3D,MAAM,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC;AAEvC,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,CAoBtD;AAED;;GAEG;AACH,wBAAsB,aAAa,6CA6BlC"}

package/dist/syncer/module-loader.js

@@ -1,6 +1,6 @@
 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 { Sonamu, init_sonamu } from "../api/sonamu.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";
@@ -50,7 +50,7 @@ async function loadModels() {
 */
 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 typePaths = (await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))).flat();
 	const types = {};
 	for (const filePath of typePaths) {
 		const importedMembers = await importMembers(filePath);
@@ -90,4 +90,4 @@ var init_module_loader = __esmMin((() => {
 //#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"}
+//# 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 ExtendedApi } from \"../api/decorators\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type BaseModelClass } from \"../database/base-model\";\nimport { type WorkflowMetadata } from \"../tasks/decorator\";\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 = ExtendedApi[];\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 = (\n    await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))\n  ).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":";;;;;;;;;;;;;;;AA4BA,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,aACJ,MAAM,QAAQ,IAAI,kBAAkB,KAAK,YAAY,UAAU,QAAQ,CAAC,CAAC,EACzE,MAAM;CAER,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;;;cAvI8B;mBAGU;iBACE;kBACD;kBAEF"}

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

@@ -8,7 +8,12 @@ export declare function actionSyncConfig(): Promise<void>;
  */
 export declare function actionGenerateServices(paramsArray: {
     namesRecord: EntityNamesRecord;
-}[]): Promise<string[]>;
+}[]): Promise<AbsolutePath[]>;
+/**
+ * Entity에 딸린 초기 types.ts를 만들어줍니다.
+ * @param entityId
+ */
+export declare function actionGenerateInitialTypes(entityId: string): Promise<AbsolutePath[]>;
 /**
  * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
  * @returns 생성된 파일 경로 배열.
@@ -20,14 +25,42 @@ export declare function actionGenerateSchemas(): Promise<AbsolutePath[]>;
  */
 export declare function actionGenerateHttps(): Promise<AbsolutePath>;
 /**
- * queries.generated.ts 및 entry-server.generated.tsx 재생성합니다.
+ * queries.generated.ts 재생성합니다.
  * @returns 생성된 파일 경로 배열.
  */
-export declare function actionGenerateSsr(): Promise<AbsolutePath[]>;
+export declare function actionGenerateSsrQueries(): Promise<AbsolutePath[]>;
+/**
+ * entry-server.generated.tsx를 생성합니다.
+ * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ
+ * 입력 의존 없는 정적 코드라 매번 overwrite는 mtime만 갱신하는 의미 없는 동작.
+ * 템플릿 자체가 변경된 경우(Sonamu 업그레이드)에는 사용자가 파일을 삭제한 뒤 sync로 재생성.
+ * @returns 생성된 파일 경로 배열 (이미 있으면 빈 배열).
+ */
+export declare function actionGenerateSsrEntryServerIfNotExists(): Promise<AbsolutePath[]>;
 /**
- * *.types.ts, *.functions.ts, *.generated.ts를 타겟 디렉토리에 복사합니다.
- * @param tsPaths
- * @returns 복사된 파일 경로 배열.
+ * 주어진 .ts 파일들(api에 있다고 가정)을 모든 타겟 디렉토리의 services에 갖다 둡니다.
+ * 이때 내부의 sonamu import는 sonamu.shared.ts import로 치환되고,
+ * 경로의 /application/은 /services/로 치환됩니다.
+ *
+ * @param tsPaths 복사할 파일들의 절대 경로
+ * @returns 각 타겟에 복사된 파일들의 절대 경로 배열 (flat).
  */
 export declare function actionSyncFilesToTargets(tsPaths: AbsolutePath[]): Promise<string[]>;
+/**
+ * shared 템플릿으로부터 sonamu.shared.ts 파일을 만들어서 모든 타겟 디렉토리에 갖다 둡니다.
+ * 파일을 만드는 과정에서 여러 치환 가공이 일어납니다.
+ *
+ * 다른 액션들과 달리, 이미 파일이 있으면 그냥 놔둡니다. 그래서 함수 이름 끝에 써놨어요 ㅎ
+ */
+export declare function actionCopySharedToTargetsIfNotExists(): Promise<void>;
+/**
+ * Sonamu Dictionary(SD)를 모든 타겟(api + web/app 등)에 동기화합니다.
+ *
+ * 각 타겟에 대해:
+ * - target이 api가 아니면 사용자 작성 locale 파일(ko.ts/en.ts/...)을 api → target으로 복사
+ * - sd 템플릿을 렌더링해서 sd.generated.ts 생성 (overwrite)
+ *
+ * 한 타겟에서 실패해도 다른 타겟은 계속 진행합니다.
+ */
+export declare function actionSyncSonamuDictionary(): Promise<void>;
 //# sourceMappingURL=syncer-actions.d.ts.map

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":"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"}
+{"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;AAMlE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKxD,wBAAsB,gBAAgB,kBAWrC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE;IACX,WAAW,EAAE,iBAAiB,CAAC;CAChC,EAAE,GACF,OAAO,CAAC,YAAY,EAAE,CAAC,CAazB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAE1F;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,wBAAwB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAExE;AAED;;;;;;GAMG;AACH,wBAAsB,uCAAuC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAWvF;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkCzF;AAED;;;;;GAKG;AACH,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,IAAI,CAAC,CA+D1E;AAED;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBhE"}