sonamu 0.13.4 → 0.13.6

package/src/syncer/__tests__/http-validator-registry.test.ts

@@ -168,4 +168,19 @@ describe("HTTP validator registry sync 정리", () => {
     await expect(findChangedFilesUsingChecksums()).resolves.toEqual([]);
     expect(warn.mock.calls.flat().join(" ")).toContain("queries.generated.ts");
   });
+
+  it("forceSync는 lock을 지운 뒤에도 생성물을 drift로 경고하지 않는다", async () => {
+    const { apiRootPath, syncer } = await createTestProject(false);
+    await writeFile(
+      path.join(apiRootPath, "src/application/queries.generated.ts"),
+      "// generated output\n",
+    );
+    await syncer.renewChecksums();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+
+    await syncer.forceSync();
+
+    expect(warn).not.toHaveBeenCalled();
+    await expect(findChangedFilesUsingChecksums()).resolves.toEqual([]);
+  });
 });

package/src/syncer/syncer.ts

@@ -56,6 +56,11 @@ export class Syncer {
     await SyncerActions.actionCopySharedToTargetsIfNotExists();
     await SyncerActions.actionGenerateSsrEntryServerIfNotExists();
 
+    // lock이 없으면 비교 기준이 없어 모든 파일이 변경으로 잡히므로, 생성물 drift를 판정할 수 없습니다.
+    const hasChecksumBaseline = await syncerFileExists(
+      path.join(Sonamu.apiRootPath, "sonamu.lock"),
+    );
+
     // 바뀐 것이 없으면 그냥 넘어가요.
     const changedFiles = await findChangedFilesUsingChecksums();
     if (changedFiles.length === 0) {
@@ -72,7 +77,7 @@ export class Syncer {
     await runWithGracefulShutdown(
       async () => {
         // 얘가 싱크 작업 수행하는 본체입니다.
-        await this.doSyncActions(changedFiles);
+        await this.doSyncActions(changedFiles, { skipDriftCheck: !hasChecksumBaseline });
         await this.reconcileHttpValidatorRegistry();
 
         // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.
@@ -322,9 +327,13 @@ export class Syncer {
    * 변경된 파일들을 타입별로 분류하고 각 타입에 맞는 액션을 실행합니다.
    *
    * @param diffFilePaths - 변경된 파일들의 절대 경로 목록
+   * @param options.skipDriftCheck - true이면 처리되지 않은 생성물 변경을 drift로 경고하지 않습니다.
    * @returns diffTypes - 변경된 파일의 타입 목록 (entity, types, model 등)
    */
-  async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {
+  async doSyncActions(
+    diffFilePaths: AbsolutePath[],
+    { skipDriftCheck = false }: { skipDriftCheck?: boolean } = {},
+  ): Promise<{ diffTypes: FileType[] }> {
     const diffGroups = this.calculateDiffGroups(diffFilePaths);
     const diffTypes =
       /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(
@@ -371,7 +380,7 @@ export class Syncer {
     // 위에서 처리 안 된 변경들이 있다?
     // 체크섬 관리 대상이긴 한데 위에서 핸들링이 안 된 것이라면 결국 생성물입니다.
     // 이 친구들이 변경된 것은 drift로 간주해도 마땅합니다.
-    if (unhandledChangesLeft()) {
+    if (!skipDriftCheck && unhandledChangesLeft()) {
       await this.handleDrifts(unhandledPaths());
     }
 

package/src/types/entity-custom.test-d.ts

@@ -0,0 +1,43 @@
+import { describe, expectTypeOf, it } from "vitest";
+import { type infer as ZodInfer } from "zod";
+
+import { type EntityJson, type EntityJsonSchema } from "./types";
+
+declare module "./types" {
+  interface EntityCustom {
+    history?: boolean;
+  }
+}
+
+describe("EntityJsonSchema custom", () => {
+  it("declaration merging으로 정의한 확장 키만 타입에서 허용한다", () => {
+    type Parsed = ZodInfer<typeof EntityJsonSchema>;
+
+    expectTypeOf<Parsed>().toEqualTypeOf<EntityJson>();
+
+    const withExtension: EntityJson = {
+      id: "History",
+      title: "이력",
+      table: "histories",
+      custom: { history: true },
+      props: [],
+      indexes: [],
+      subsets: {},
+      enums: {},
+    };
+    expectTypeOf(withExtension.custom?.history).toEqualTypeOf<boolean | undefined>();
+
+    const withTypo: EntityJson = {
+      id: "HistoryTypo",
+      title: "이력 오타",
+      table: "history_typos",
+      // @ts-expect-error history 오타는 EntityCustom에 없으면 거부되어야 한다.
+      custom: { histroy: true },
+      props: [],
+      indexes: [],
+      subsets: {},
+      enums: {},
+    };
+    expectTypeOf(withTypo).toEqualTypeOf<EntityJson>();
+  });
+});

package/src/types/types.ts

@@ -515,11 +515,14 @@ export function getEnumDefValues(def: EnumDef): Record<string, string> {
   return isEnumDefWithCone(def) ? def.values : def;
 }
 
+export interface EntityCustom {}
+
 export type EntityJson = {
   id: string;
   parentId?: string;
   table: string;
   title?: string;
+  custom?: EntityCustom;
   cone?: Cone; // cone 메타데이터
   props: EntityProp[];
   indexes: EntityIndex[];
@@ -1629,12 +1632,15 @@ function validateSearchTextSources(
   });
 }
 
+const EntityCustomSchema: z.ZodType<EntityCustom> = z.looseObject({});
+
 const EntityJsonBaseSchema = z
   .object({
     id: z.string().describe("PascalCase로 된 Entity ID"),
     title: z.string().describe("Entity 이름"),
     table: z.string().describe("snake_case로 된 테이블명"),
     parentId: z.string().optional().describe("부모 Entity ID"),
+    custom: EntityCustomSchema.optional(),
     cone: ConeSchema.optional(),
     props: z.array(EntityPropSchema),
     indexes: z.array(EntityIndexSchema),