sonamu 0.11.4 → 0.11.6

package/dist/ui-web/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/sonamu-ui/setting.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>{{projectName}}: Sonamu UI</title>
-    <script type="module" crossorigin src="/sonamu-ui/assets/index-DV1AAq6W.js"></script>
-    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-D3QNH-Dv.css">
+    <script type="module" crossorigin src="/sonamu-ui/assets/index-C_RUxOdN.js"></script>
+    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-5i4uZVES.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",

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

@@ -1,15 +1,30 @@
-import { access, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { access, mkdir, mkdtemp, readFile, rm, unlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { type SonamuConfig } from "../../api/config";
 import { Sonamu } from "../../api/sonamu";
+import { Template__entry_server } from "../../template/implementations/entry-server.template";
+import { Template__http_validators } from "../../template/implementations/http_validators.template";
+import { type Template } from "../../template/template";
+import { TemplateManager } from "../../template/template-manager";
 import { type AbsolutePath } from "../../utils/path-utils";
-import { Syncer, type SyncerDependencies } from "../syncer";
+import { findChangedFilesUsingChecksums } from "../checksum";
+import { Syncer } from "../syncer";
 import { actionGenerateHttpValidators } from "../syncer-actions";
 
+type ZodCompilerPolicy = NonNullable<SonamuConfig["validation"]>["zodCompiler"];
+
+type TestProject = {
+  apiRootPath: AbsolutePath;
+  lockPath: string;
+  registryPath: AbsolutePath;
+  syncer: Syncer;
+};
+
 function toAbsolutePath(filePath: string): AbsolutePath {
   if (!path.isAbsolute(filePath)) {
     throw new Error(`절대 경로가 필요합니다: ${filePath}`);
@@ -18,24 +33,14 @@ function toAbsolutePath(filePath: string): AbsolutePath {
   return filePath as AbsolutePath;
 }
 
-function createDependencies() {
-  return {
-    actionCopySharedToTargetsIfNotExists: vi
-      .fn<SyncerDependencies["actionCopySharedToTargetsIfNotExists"]>()
-      .mockResolvedValue(undefined),
-    actionGenerateHttpValidators: vi.fn<SyncerDependencies["actionGenerateHttpValidators"]>(),
-    actionGenerateSsrEntryServerIfNotExists: vi
-      .fn<SyncerDependencies["actionGenerateSsrEntryServerIfNotExists"]>()
-      .mockResolvedValue([]),
-    findChangedFilesUsingChecksums: vi.fn<SyncerDependencies["findChangedFilesUsingChecksums"]>(),
-    renewChecksums: vi.fn<SyncerDependencies["renewChecksums"]>().mockResolvedValue(undefined),
-  } satisfies SyncerDependencies;
+function sha1(content: string): string {
+  return createHash("sha1").update(content).digest("hex");
 }
 
 const testConfig = {
   api: { dir: "api", route: { prefix: "/api" } },
   i18n: { defaultLocale: "ko", supportedLocales: ["ko"] },
-  sync: { targets: [] },
+  sync: { targets: ["web"] },
   database: {},
   server: {
     apiConfig: {
@@ -47,91 +52,120 @@ const testConfig = {
 
 describe("HTTP validator registry sync 정리", () => {
   const tempRoots: string[] = [];
+  let sonamuSnapshot: ReturnType<typeof Sonamu.captureTestingSnapshot>;
+  let registeredTemplates: Template[];
+  let templateManagerWasAutoloaded: boolean;
+
+  beforeEach(() => {
+    sonamuSnapshot = Sonamu.captureTestingSnapshot();
+    registeredTemplates = TemplateManager.getAllKeys().map((key) => TemplateManager.get(key));
+    templateManagerWasAutoloaded = TemplateManager.isAutoloaded;
+
+    TemplateManager.reset();
+    TemplateManager.registerAll([new Template__http_validators(), new Template__entry_server()]);
+  });
 
   afterEach(async () => {
     vi.restoreAllMocks();
+    Sonamu.restoreTestingSnapshot(sonamuSnapshot);
+    TemplateManager.reset();
+    TemplateManager.registerAll(registeredTemplates);
+    TemplateManager.isAutoloaded = templateManagerWasAutoloaded;
     await Promise.all(
       tempRoots.splice(0).map((rootPath) => rm(rootPath, { recursive: true, force: true })),
     );
   });
 
+  async function createTestProject(zodCompiler: ZodCompilerPolicy): Promise<TestProject> {
+    const appRootPath = await mkdtemp(path.join(os.tmpdir(), "sonamu-registry-sync-test-"));
+    tempRoots.push(appRootPath);
+    const apiRootPath = toAbsolutePath(path.join(appRootPath, "api"));
+    const registryPath = toAbsolutePath(
+      path.join(apiRootPath, "src/application/sonamu.validators.generated.ts"),
+    );
+    await Promise.all([
+      mkdir(path.dirname(registryPath), { recursive: true }),
+      mkdir(path.join(appRootPath, "web/src/services"), { recursive: true }),
+    ]);
+
+    const syncer = new Syncer();
+    Sonamu.apiRootPath = apiRootPath;
+    Sonamu.config = {
+      ...testConfig,
+      validation: { zodCompiler },
+    };
+    Sonamu.syncer = syncer;
+
+    return {
+      apiRootPath,
+      lockPath: path.join(apiRootPath, "sonamu.lock"),
+      registryPath,
+      syncer,
+    };
+  }
+
+  async function readLock(lockPath: string): Promise<Array<{ path: string; checksum: string }>> {
+    // SAFETY: renewChecksums가 쓰는 sonamu.lock 직렬화 계약을 검증하는 테스트다.
+    return JSON.parse(await readFile(lockPath, "utf-8")) as Array<{
+      path: string;
+      checksum: string;
+    }>;
+  }
+
   it.each([
     { label: "opt-out", value: false as const },
     { label: "JIT", value: { api: "jit" as const } },
-  ])("$label 정책은 남아 있는 generated registry를 제거한다", async ({ value }) => {
-    const apiRootPath = await mkdtemp(path.join(os.tmpdir(), "sonamu-registry-sync-test-"));
-    tempRoots.push(apiRootPath);
-    const registryPath = path.join(apiRootPath, "src/application/sonamu.validators.generated.ts");
-    await mkdir(path.dirname(registryPath), { recursive: true });
+  ])("$label 정책은 실제 generated registry를 제거한다", async ({ value }) => {
+    const { registryPath } = await createTestProject(value);
     await writeFile(registryPath, "export const validators = new Map();\n");
-    Sonamu.apiRootPath = toAbsolutePath(apiRootPath);
-    Sonamu.config = {
-      ...testConfig,
-      api: { ...testConfig.api, dir: "." },
-      validation: { zodCompiler: value },
-    };
 
     await actionGenerateHttpValidators();
 
     await expect(access(registryPath)).rejects.toMatchObject({ code: "ENOENT" });
   });
 
-  it("registry-only drift를 경고로 넘기지 않고 즉시 재생성한다", async () => {
-    const appRootPath = await mkdtemp(path.join(os.tmpdir(), "sonamu-registry-drift-test-"));
-    tempRoots.push(appRootPath);
-    const apiRootPath = path.join(appRootPath, "api");
-    const registryPath = toAbsolutePath(
-      path.join(apiRootPath, "src/application/sonamu.validators.generated.ts"),
-    );
-    await mkdir(path.dirname(registryPath), { recursive: true });
+  it("registry-only drift를 정본으로 복구하고 갱신된 checksum lock을 남긴다", async () => {
+    const { lockPath, registryPath, syncer } = await createTestProject({ api: "aot" });
+    await actionGenerateHttpValidators();
+    const canonicalRegistry = await readFile(registryPath, "utf-8");
+    await syncer.renewChecksums();
     await writeFile(registryPath, "// drifted registry\n");
-    Sonamu.apiRootPath = toAbsolutePath(apiRootPath);
-    Sonamu.config = {
-      ...testConfig,
-      validation: { zodCompiler: { api: "aot" } },
-    };
-    const dependencies = createDependencies();
-    dependencies.actionGenerateHttpValidators.mockResolvedValue(registryPath);
-    dependencies.findChangedFilesUsingChecksums.mockResolvedValue([registryPath]);
-    vi.spyOn(console, "warn").mockImplementation(() => {});
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
 
-    await new Syncer(dependencies).sync();
+    await syncer.sync();
 
-    expect(dependencies.actionGenerateHttpValidators).toHaveBeenCalledTimes(1);
-    expect(dependencies.renewChecksums).toHaveBeenCalledTimes(1);
-  });
-
-  it("삭제된 registry가 checksum 변경 목록에서 빠져도 다른 tracked 변경 처리 중 복구한다", async () => {
-    const appRootPath = await mkdtemp(path.join(os.tmpdir(), "sonamu-missing-registry-test-"));
-    tempRoots.push(appRootPath);
-    const apiRootPath = path.join(appRootPath, "api");
-    const registryPath = toAbsolutePath(
-      path.join(apiRootPath, "src/application/sonamu.validators.generated.ts"),
-    );
-    const unrelatedPath = toAbsolutePath(
-      path.join(apiRootPath, "src/application/queries.generated.ts"),
+    expect(await readFile(registryPath, "utf-8")).toBe(canonicalRegistry);
+    const registryLock = (await readLock(lockPath)).find((entry) =>
+      entry.path.endsWith("sonamu.validators.generated.ts"),
     );
-    await mkdir(path.dirname(unrelatedPath), { recursive: true });
-    await writeFile(unrelatedPath, "// unrelated tracked change\n");
-    Sonamu.apiRootPath = toAbsolutePath(apiRootPath);
-    Sonamu.config = {
-      ...testConfig,
-      validation: { zodCompiler: { api: "aot" } },
-    };
-    const order: string[] = [];
-    const dependencies = createDependencies();
-    dependencies.actionGenerateHttpValidators.mockImplementation(async () => {
-      order.push("registry");
-      return registryPath;
+    expect(registryLock).toEqual({
+      path: "api/src/application/sonamu.validators.generated.ts",
+      checksum: sha1(canonicalRegistry),
     });
-    dependencies.findChangedFilesUsingChecksums.mockResolvedValue([unrelatedPath]);
-    dependencies.renewChecksums.mockImplementation(async () => {
-      order.push("checksum");
-    });
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-
-    await new Syncer(dependencies).sync();
+    await expect(findChangedFilesUsingChecksums()).resolves.toEqual([]);
+    expect(warn).not.toHaveBeenCalled();
+  });
 
-    expect(order).toEqual(["registry", "checksum"]);
+  it("삭제된 registry는 다른 tracked 변경을 처리할 때 lock 갱신 전에 복구한다", async () => {
+    const { apiRootPath, lockPath, registryPath, syncer } = await createTestProject({ api: "aot" });
+    const otherGeneratedPath = path.join(apiRootPath, "src/application/queries.generated.ts");
+    await actionGenerateHttpValidators();
+    const canonicalRegistry = await readFile(registryPath, "utf-8");
+    await writeFile(otherGeneratedPath, "// original generated output\n");
+    await syncer.renewChecksums();
+    await unlink(registryPath);
+    await writeFile(otherGeneratedPath, "// drifted generated output\n");
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+
+    await syncer.sync();
+
+    expect(await readFile(registryPath, "utf-8")).toBe(canonicalRegistry);
+    const lock = await readLock(lockPath);
+    expect(lock).toContainEqual({
+      path: "api/src/application/sonamu.validators.generated.ts",
+      checksum: sha1(canonicalRegistry),
+    });
+    await expect(findChangedFilesUsingChecksums()).resolves.toEqual([]);
+    expect(warn.mock.calls.flat().join(" ")).toContain("queries.generated.ts");
   });
 });

package/src/syncer/syncer.ts

@@ -37,22 +37,6 @@ import * as SyncerActions from "./syncer-actions";
 type DiffGroupKey = FileType | "unknown";
 type DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;
 
-export interface SyncerDependencies {
-  actionCopySharedToTargetsIfNotExists: typeof SyncerActions.actionCopySharedToTargetsIfNotExists;
-  actionGenerateHttpValidators: typeof SyncerActions.actionGenerateHttpValidators;
-  actionGenerateSsrEntryServerIfNotExists: typeof SyncerActions.actionGenerateSsrEntryServerIfNotExists;
-  findChangedFilesUsingChecksums: typeof findChangedFilesUsingChecksums;
-  renewChecksums: typeof renewChecksums;
-}
-
-const defaultSyncerDependencies: SyncerDependencies = {
-  actionCopySharedToTargetsIfNotExists: SyncerActions.actionCopySharedToTargetsIfNotExists,
-  actionGenerateHttpValidators: SyncerActions.actionGenerateHttpValidators,
-  actionGenerateSsrEntryServerIfNotExists: SyncerActions.actionGenerateSsrEntryServerIfNotExists,
-  findChangedFilesUsingChecksums,
-  renewChecksums,
-};
-
 export class Syncer {
   apis: LoadedApis = [];
   types: LoadedTypes = {};
@@ -60,8 +44,6 @@ export class Syncer {
   workflows: Map<string, WorkflowMetadata[]> = new Map();
   eventEmitter: EventEmitter = new EventEmitter();
 
-  constructor(private readonly dependencies: SyncerDependencies = defaultSyncerDependencies) {}
-
   /**
    * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
    * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
@@ -71,14 +53,14 @@ export class Syncer {
     // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.
     // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.
     // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.
-    await this.dependencies.actionCopySharedToTargetsIfNotExists();
-    await this.dependencies.actionGenerateSsrEntryServerIfNotExists();
+    await SyncerActions.actionCopySharedToTargetsIfNotExists();
+    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();
 
     // 바뀐 것이 없으면 그냥 넘어가요.
-    const changedFiles = await this.dependencies.findChangedFilesUsingChecksums();
+    const changedFiles = await findChangedFilesUsingChecksums();
     if (changedFiles.length === 0) {
       if (await this.reconcileHttpValidatorRegistry()) {
-        await this.dependencies.renewChecksums();
+        await renewChecksums();
       }
       console.log(chalk.black.bgGreen(centerText("All files are synced!")));
       return;
@@ -94,7 +76,7 @@ export class Syncer {
         await this.reconcileHttpValidatorRegistry();
 
         // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.
-        await this.dependencies.renewChecksums();
+        await renewChecksums();
       },
       { whenThisHappens: "SIGUSR2", waitForUpTo: 20000 },
     );
@@ -112,7 +94,7 @@ export class Syncer {
     }
 
     // 변경 목록이 registry 삭제를 놓쳐도 checksum 갱신 전에 정책과 산출물을 다시 맞춥니다.
-    await this.dependencies.actionGenerateHttpValidators();
+    await SyncerActions.actionGenerateHttpValidators();
     return true;
   }
 
@@ -351,7 +333,7 @@ export class Syncer {
 
     // 여기는 별로 중요한 파트는 아닙니다.
     // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.
-    const { changeMatches, nothingMatches, unhandledPaths } = this.changeMatcher(
+    const { changeMatches, unhandledPaths, unhandledChangesLeft } = this.changeMatcher(
       diffTypes,
       diffGroups,
     );
@@ -372,30 +354,24 @@ export class Syncer {
       await this.handleConfigChanges();
     }
 
-    if (changeMatches("i18n", "entity" /*레이블*/, "config" /*defaultLocale등*/)) {
-      await this.handleSonamuDictionaryRelatedChanges();
+    if (changeMatches("workflow")) {
+      // 뭐 딱히 안 해요. 그래도 이 if 조건은 eval되어야 하기 때문에 남겨둡니다 ㅎㅎ
     }
 
-    const metadataChanged = diffTypes.some((type) =>
-      ["entity", "types", "model", "frame", "config"].includes(type),
-    );
-    if (changeMatches("httpValidatorsGenerated") && !metadataChanged) {
-      // registry 자체 drift는 최신 in-memory metadata로 즉시 덮어써 lock 갱신 전에 정합성을 복구합니다.
-      await this.dependencies.actionGenerateHttpValidators();
+    if (changeMatches("i18n", "entity" /*레이블*/, "config" /*defaultLocale등*/)) {
+      await this.handleSonamuDictionaryRelatedChanges();
     }
 
-    if (metadataChanged) {
-      // 모든 생성/복사 액션 뒤 최신 metadata를 다시 읽어 registry를 한 번만 확정합니다.
-      await this.autoloadTypes();
-      await this.autoloadModels();
-      await this.autoloadApis();
-      await this.dependencies.actionGenerateHttpValidators();
+    if (changeMatches("entity", "types", "model", "frame", "config", "httpValidatorsGenerated")) {
+      // 생성물(httpValidatorsGenerated)에 드리프트가 생긴 경우도 처리합니다.
+      // 다른 것 안 바뀌고 딱 httpValidatorsGenerated만 바뀐 경우에도 동등한 처리(=무지성 오토로드)를 합니다. 그냥 이뻐서요 ㅋ
+      await this.handleHttpValidatorRelatedChanges();
     }
 
-    if (nothingMatches()) {
-      // 파일 변경은 감지되었으나 저 위 어느 changeMatches에도 걸리지 않은 파일들이 drifts입니다.
-      // syncer는 소스의 변경에는 반응하지만 산출물의 변경(drift)에는 직접적으로 반응하지 않습니다.
-      // 대신 이 drift에 대해 경고 정도만 출력해줍니다.
+    // 위에서 처리 안 된 변경들이 있다?
+    // 체크섬 관리 대상이긴 한데 위에서 핸들링이 안 된 것이라면 결국 생성물입니다.
+    // 이 친구들이 변경된 것은 drift로 간주해도 마땅합니다.
+    if (unhandledChangesLeft()) {
       await this.handleDrifts(unhandledPaths());
     }
 
@@ -442,18 +418,18 @@ export class Syncer {
       return matching.length > 0;
     };
 
-    /**
-     * changeMatches로 매칭된 것이 하나도 없는지 여부를 가져옵니다.
-     */
-    const nothingMatches = () => handled.size === 0;
-
     /**
      * 어떤 changeMatches 호출에도 걸리지 않은 FileType들의 실제 파일 경로를 모아서 반환합니다.
      */
     const unhandledPaths = (): AbsolutePath[] =>
       diffTypes.filter((t) => !handled.has(t)).flatMap((t) => diffGroups[t] ?? []);
 
-    return { changeMatches, nothingMatches, unhandledPaths };
+    /**
+     * changeMatches 호출에도 걸리지 않은 FileType들이 존재하는지 확인합니다.
+     */
+    const unhandledChangesLeft = () => unhandledPaths().length > 0;
+
+    return { changeMatches, unhandledPaths, unhandledChangesLeft };
   }
 
   async handleTruthSourceChanges(diffGroups: DiffGroups): Promise<void> {
@@ -542,18 +518,27 @@ export class Syncer {
     await SyncerActions.actionSyncSonamuDictionary();
   }
 
+  async handleHttpValidatorRelatedChanges(): Promise<void> {
+    await this.autoloadTypes();
+    await this.autoloadModels();
+    await this.autoloadApis();
+    await SyncerActions.actionGenerateHttpValidators();
+  }
+
   async handleDrifts(drifts: AbsolutePath[]): Promise<void> {
-    if (drifts.length > 0) {
-      console.warn(
-        chalk.yellow(
-          "⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.",
-        ),
-      );
-      for (const p of drifts) {
-        console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));
-      }
-      console.warn(chalk.dim("  → `pnpm sonamu sync --force`를 권장합니다."));
+    if (drifts.length === 0) {
+      return;
+    }
+
+    console.warn(
+      chalk.yellow(
+        "⚠️ Sonamu가 자동 생성한 파일에 대한 변경이 감지되었습니다. 파일이 Sonamu watcher 외부에서 변경된 것으로 추정됩니다.",
+      ),
+    );
+    for (const p of drifts) {
+      console.warn(chalk.yellow(`  - ${path.relative(Sonamu.appRootPath, p)}`));
     }
+    console.warn(chalk.dim("  → `pnpm sonamu sync --force`를 권장합니다."));
   }
 
   /**
@@ -672,6 +657,6 @@ export class Syncer {
    * 하위호환용 프록시 메소드입니다.
    */
   async renewChecksums(): Promise<void> {
-    return await this.dependencies.renewChecksums();
+    return await renewChecksums();
   }
 }