sonamu 0.10.13 → 0.11.0

package/src/tooling/__tests__/cli-tooling-entity-patch.contract.test.ts

@@ -0,0 +1,131 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { EntityManager } from "../../entity/entity-manager";
+import { type EntityJson, type EntityProp } from "../../types/types";
+import { tooling } from "../cli-tooling";
+import { attachSonamuTestRoot, detachSonamuTestRoot } from "./helpers/sonamu-test-root";
+
+const BASE_PROPS: EntityProp[] = [{ name: "id", type: "integer" }];
+
+const POST_JSON: EntityJson = {
+  id: "Post",
+  table: "posts",
+  title: "게시글",
+  props: BASE_PROPS,
+  indexes: [],
+  subsets: {},
+  enums: {},
+};
+
+let apiRootPath = "";
+let entityJsonPath = "";
+let patchFilePath = "";
+
+/**
+ * prop 추가 patch 파일을 만듭니다.
+ *
+ * 스키마를 위반하는 입력도 그대로 기록해야 하므로 raw JSON 문자열을 받습니다.
+ */
+async function writePatchFile(valueJson: string): Promise<string> {
+  await writeFile(
+    patchFilePath,
+    `{"entityId":"Post","operations":[{"op":"add","path":"/props/-","value":${valueJson}}]}`,
+    "utf8",
+  );
+  return patchFilePath;
+}
+
+async function readEntityFile(): Promise<string> {
+  return readFile(entityJsonPath, "utf8");
+}
+
+beforeEach(async () => {
+  apiRootPath = await attachSonamuTestRoot();
+  const entityDirectory = path.join(apiRootPath, "src", "application", "post");
+  await mkdir(entityDirectory, { recursive: true });
+  entityJsonPath = path.join(entityDirectory, "post.entity.json");
+  patchFilePath = path.join(apiRootPath, "patch.json");
+  await writeFile(entityJsonPath, JSON.stringify(POST_JSON, null, 2), "utf8");
+  await EntityManager.register(POST_JSON);
+});
+
+afterEach(async () => {
+  await detachSonamuTestRoot();
+});
+
+describe("entity apply의 prop 검증", () => {
+  it("존재하지 않는 prop type은 파일을 바꾸기 전에 거절한다", async () => {
+    const before = await readEntityFile();
+    const file = await writePatchFile(`{"name":"status","type":"bogus"}`);
+
+    await expect(tooling.entity.applyPatch({ file, execute: true })).rejects.toMatchObject({
+      code: "INVALID_ENTITY_PATCH",
+      exitCode: 2,
+    });
+
+    await expect(readEntityFile()).resolves.toBe(before);
+    expect(EntityManager.get("Post").props).toEqual(BASE_PROPS);
+  });
+
+  it("타입에 맞지 않는 부가 필드도 파일을 바꾸기 전에 거절한다", async () => {
+    // integer prop은 length 부가 필드를 허용하지 않습니다.
+    const before = await readEntityFile();
+    const file = await writePatchFile(`{"name":"count","type":"integer","length":10}`);
+
+    await expect(tooling.entity.applyPatch({ file, execute: true })).rejects.toMatchObject({
+      code: "INVALID_ENTITY_PATCH",
+    });
+
+    await expect(readEntityFile()).resolves.toBe(before);
+    expect(EntityManager.get("Post").props).toEqual(BASE_PROPS);
+  });
+
+  it("유효한 prop은 entity 파일에 반영한다", async () => {
+    const file = await writePatchFile(`{"name":"title","type":"string","length":128}`);
+
+    await expect(tooling.entity.applyPatch({ file, execute: true })).resolves.toMatchObject({
+      changed: true,
+      after: {
+        props: [
+          { name: "id", type: "integer" },
+          { name: "title", type: "string", length: 128 },
+        ],
+      },
+    });
+
+    await expect(readEntityFile()).resolves.toContain(`"title"`);
+    expect(EntityManager.get("Post").props).toEqual([
+      { name: "id", type: "integer" },
+      { name: "title", type: "string", length: 128 },
+    ]);
+  });
+
+  it("dry run은 유효한 patch도 파일에 쓰지 않는다", async () => {
+    const before = await readEntityFile();
+    const file = await writePatchFile(`{"name":"title","type":"string","length":128}`);
+
+    await expect(tooling.entity.applyPatch({ file, dryRun: true })).resolves.toMatchObject({
+      changed: true,
+    });
+
+    await expect(readEntityFile()).resolves.toBe(before);
+  });
+});
+
+describe("entity show의 미존재 처리", () => {
+  it("존재하지 않는 entityId는 ENTITY_NOT_FOUND로 실패한다", async () => {
+    await expect(tooling.entity.show({ entityId: "UNKNOWN_ID" })).rejects.toMatchObject({
+      code: "ENTITY_NOT_FOUND",
+    });
+  });
+
+  it("존재하는 entityId는 entity JSON을 반환한다", async () => {
+    await expect(tooling.entity.show({ entityId: "Post" })).resolves.toMatchObject({
+      id: "Post",
+      table: "posts",
+    });
+  });
+});

package/src/tooling/__tests__/cli-tooling-fixture-transfer.contract.test.ts

@@ -0,0 +1,255 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { type Knex } from "knex";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { Sonamu } from "../../api/sonamu";
+import { type SonamuDBConfig } from "../../database/db";
+import { EntityManager } from "../../entity/entity-manager";
+import { FixtureManager, type FixtureSourceRecord } from "../../testing/fixture-manager";
+import { type FixtureRecord } from "../../types/types";
+import { tooling } from "../cli-tooling";
+import { attachSonamuTestRoot, detachSonamuTestRoot } from "./helpers/sonamu-test-root";
+
+// 실제 커넥션 없이 preset 존재 여부만 검증되도록 빈 Knex 설정을 사용합니다.
+const DB_CONFIG: SonamuDBConfig = {
+  development: {},
+  staging: {},
+  production: {},
+  test: {},
+  fixture: {},
+  development_readonly: {},
+  staging_readonly: {},
+  production_readonly: {},
+  test_readonly: {},
+};
+
+const FIXTURE_RECORD: FixtureRecord = {
+  fixtureId: "Post#1",
+  entityId: "Post",
+  id: 1,
+  columns: { id: { prop: { name: "id", type: "integer" }, value: 1 } },
+  fetchedRecords: [],
+  belongsRecords: [],
+};
+
+type TransferOverrides = {
+  depth?: number;
+  target?: string;
+  relations?: string;
+  dryRun?: boolean;
+  execute?: boolean;
+};
+
+// fixture transfer 선택자는 depth를 제외하면 모든 케이스에서 동일합니다.
+function transferInput(overrides: TransferOverrides) {
+  return {
+    entityId: "Post",
+    source: "development",
+    target: "fixture",
+    field: "id",
+    values: ["1"],
+    relations: "none",
+    ...overrides,
+  };
+}
+
+function stubFixtureManager() {
+  return {
+    getFixtures: vi.spyOn(FixtureManager, "getFixtures").mockResolvedValue([FIXTURE_RECORD]),
+    insertFixtures: vi.spyOn(FixtureManager, "insertFixtures").mockResolvedValue([]),
+  };
+}
+
+let apiRoot = "";
+
+const POST_ENTITY_JSON = {
+  id: "Post",
+  table: "posts",
+  title: "게시글",
+  props: [
+    { name: "id", type: "integer" },
+    { name: "title", type: "string", length: 128 },
+    { name: "author", type: "relation", relationType: "BelongsToOne", with: "User" },
+  ],
+  indexes: [],
+  subsets: {},
+  enums: {},
+};
+
+const USER_ENTITY_JSON = {
+  id: "User",
+  table: "users",
+  title: "사용자",
+  props: [
+    { name: "id", type: "integer" },
+    { name: "name", type: "string", length: 64 },
+  ],
+  indexes: [],
+  subsets: {},
+  enums: {},
+};
+
+/** 임시 api root에 Post -> User BelongsToOne 관계를 가진 엔티티를 등록합니다. */
+async function registerRelatedEntities(): Promise<void> {
+  await Promise.all(
+    [POST_ENTITY_JSON, USER_ENTITY_JSON].map(async (entityJson) => {
+      const moduleName = entityJson.id.toLowerCase();
+      const directory = path.join(apiRoot, "src", "application", moduleName);
+      await mkdir(directory, { recursive: true });
+      await writeFile(
+        path.join(directory, `${moduleName}.entity.json`),
+        JSON.stringify(entityJson, null, 2),
+        "utf8",
+      );
+    }),
+  );
+  EntityManager.isAutoloaded = false;
+  await EntityManager.autoload(true, apiRoot);
+}
+
+/** 관계 순회가 실제로 일어나야만 호출되는 최소 Knex 대역입니다. */
+function createStubDb(rowsByTable: Record<string, FixtureSourceRecord>) {
+  const queriedTables: string[] = [];
+  const query = (table: string) => {
+    queriedTables.push(table);
+    return {
+      where: () => ({
+        first: () => Promise.resolve(rowsByTable[table]),
+        pluck: () => Promise.resolve([]),
+      }),
+    };
+  };
+  // SAFETY: createFixtureRecord가 쓰는 db(table).where(...).first() 경로만 구현한 테스트 대역입니다.
+  return { db: Object.assign(query, {} as Knex), queriedTables };
+}
+
+beforeEach(async () => {
+  apiRoot = await attachSonamuTestRoot();
+  Sonamu.dbConfig = DB_CONFIG;
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  // 임시 루트에서 등록한 엔티티가 다음 케이스로 새지 않도록 되돌립니다.
+  EntityManager.isAutoloaded = false;
+  await detachSonamuTestRoot();
+});
+
+describe("fixture transfer의 depth 검증", () => {
+  it("--depth 0을 허용하고 maxDepth 0으로 관계 순회를 막는다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: 0, dryRun: true })),
+    ).resolves.toMatchObject({ dryRun: true, records: [FIXTURE_RECORD] });
+
+    expect(fixtures.getFixtures).toHaveBeenCalledWith(
+      "development",
+      "fixture",
+      { entityId: "Post", field: "id", value: "1", searchType: "equals" },
+      { includeRelations: false, maxDepth: 0 },
+    );
+    expect(fixtures.insertFixtures).not.toHaveBeenCalled();
+  });
+
+  it("--depth 0으로 실제 이관까지 수행한다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: 0, execute: true })),
+    ).resolves.toMatchObject({ records: [FIXTURE_RECORD] });
+
+    expect(fixtures.insertFixtures).toHaveBeenCalledWith("fixture", [FIXTURE_RECORD]);
+  });
+
+  it("양의 정수 depth는 계속 허용한다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: 2, dryRun: true })),
+    ).resolves.toMatchObject({ dryRun: true });
+
+    expect(fixtures.getFixtures).toHaveBeenCalledWith("development", "fixture", expect.anything(), {
+      includeRelations: false,
+      maxDepth: 2,
+    });
+  });
+
+  it("음수 depth는 거절하고 fixture 조회를 시도하지 않는다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: -1, dryRun: true })),
+    ).rejects.toMatchObject({ code: "INVALID_FIXTURE_TRANSFER", exitCode: 2 });
+
+    expect(fixtures.getFixtures).not.toHaveBeenCalled();
+    expect(fixtures.insertFixtures).not.toHaveBeenCalled();
+  });
+
+  it("정수가 아닌 depth는 거절한다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: 1.5, dryRun: true })),
+    ).rejects.toMatchObject({ code: "INVALID_FIXTURE_TRANSFER", exitCode: 2 });
+
+    expect(fixtures.getFixtures).not.toHaveBeenCalled();
+  });
+
+  it("설정되지 않은 DB preset은 depth 0이어도 거절한다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ depth: 0, target: "unknown", dryRun: true })),
+    ).rejects.toMatchObject({ code: "INVALID_FIXTURE_TRANSFER", exitCode: 2 });
+
+    expect(fixtures.getFixtures).not.toHaveBeenCalled();
+  });
+});
+
+describe("relations include와 depth 0의 관계 순회 억제", () => {
+  it("relations include에서도 --depth 0은 maxDepth 0으로 전달한다", async () => {
+    const fixtures = stubFixtureManager();
+
+    await expect(
+      tooling.fixture.fetch(transferInput({ relations: "include", depth: 0, dryRun: true })),
+    ).resolves.toMatchObject({ dryRun: true, records: [FIXTURE_RECORD] });
+
+    // includeRelations가 true인 상태에서는 maxDepth 0만이 순회를 막는 조건입니다.
+    expect(fixtures.getFixtures).toHaveBeenCalledWith("development", "fixture", expect.anything(), {
+      includeRelations: true,
+      maxDepth: 0,
+    });
+  });
+
+  it("includeRelations true여도 maxDepth 0이면 관계 레코드를 조회하지 않는다", async () => {
+    await registerRelatedEntities();
+    const { db, queriedTables } = createStubDb({ users: { id: 7, name: "글쓴이" } });
+
+    const records = await FixtureManager.createFixtureRecord(
+      EntityManager.get("Post"),
+      { id: 1, title: "첫 글", author_id: 7 },
+      { db, includeRelations: true, maxDepth: 0 },
+    );
+
+    expect(records.map((record) => record.fixtureId)).toEqual(["Post#1"]);
+    expect(records[0].belongsRecords).toEqual(["User#7"]);
+    expect(queriedTables).toEqual([]);
+  });
+
+  it("maxDepth 1이면 같은 입력에서 관계 레코드까지 수집한다", async () => {
+    await registerRelatedEntities();
+    const { db, queriedTables } = createStubDb({ users: { id: 7, name: "글쓴이" } });
+
+    const records = await FixtureManager.createFixtureRecord(
+      EntityManager.get("Post"),
+      { id: 1, title: "첫 글", author_id: 7 },
+      { db, includeRelations: true, maxDepth: 1 },
+    );
+
+    expect(records.map((record) => record.fixtureId).toSorted()).toEqual(["Post#1", "User#7"]);
+    expect(queriedTables).toEqual(["users"]);
+  });
+});

package/src/tooling/__tests__/cli-tooling-i18n-update.contract.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { sonamuDictionary } from "../../dict/sonamu-dictionary";
+import { type DictionaryResult } from "../../dict/types";
+import { tooling } from "../cli-tooling";
+import { attachSonamuTestRoot, detachSonamuTestRoot } from "./helpers/sonamu-test-root";
+
+const DICTIONARY: DictionaryResult = {
+  locales: ["ko", "en"],
+  defaultLocale: "ko",
+  stats: {},
+  rows: [
+    { key: "Post.title", source: "entity", isFunction: false, ko: "제목", en: "Title" },
+    { key: "common.save", source: "project", isFunction: false, ko: "저장", en: "Save" },
+  ],
+};
+
+function stubDictionary() {
+  vi.spyOn(sonamuDictionary, "getDictionary").mockResolvedValue(DICTIONARY);
+  return vi.spyOn(sonamuDictionary, "updateEntry").mockResolvedValue(undefined);
+}
+
+beforeEach(async () => {
+  await attachSonamuTestRoot();
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await detachSonamuTestRoot();
+});
+
+describe("i18n update의 source 결정", () => {
+  it("entity 항목은 source를 생략해도 entity로 갱신한다", async () => {
+    const updateEntry = stubDictionary();
+
+    await tooling.i18n.update({ key: "Post.title", values: { ko: "게시글 제목" } });
+
+    expect(updateEntry).toHaveBeenCalledWith({
+      oldKey: "Post.title",
+      newKey: "Post.title",
+      source: "entity",
+      values: { ko: "게시글 제목" },
+    });
+  });
+
+  it("project 항목은 project로 갱신한다", async () => {
+    const updateEntry = stubDictionary();
+
+    await tooling.i18n.update({ key: "common.save", values: { ko: "보관" } });
+
+    expect(updateEntry).toHaveBeenCalledWith(
+      expect.objectContaining({ oldKey: "common.save", source: "project" }),
+    );
+  });
+
+  it("사전에 없는 key는 project로 폴백한다", async () => {
+    const updateEntry = stubDictionary();
+
+    await tooling.i18n.update({ key: "unknown.key", values: { ko: "값" } });
+
+    expect(updateEntry).toHaveBeenCalledWith(
+      expect.objectContaining({ oldKey: "unknown.key", source: "project" }),
+    );
+  });
+
+  it("명시한 source가 사전에서 조회한 source보다 우선한다", async () => {
+    const updateEntry = stubDictionary();
+
+    await tooling.i18n.update({
+      key: "Post.title",
+      source: "project",
+      values: { ko: "게시글 제목" },
+    });
+
+    expect(updateEntry).toHaveBeenCalledWith(expect.objectContaining({ source: "project" }));
+  });
+
+  it("key 변경 시에도 기존 항목의 source를 유지한다", async () => {
+    const updateEntry = stubDictionary();
+
+    await tooling.i18n.update({
+      key: "Post.title",
+      newKey: "Post.headline",
+      values: { ko: "게시글 제목" },
+    });
+
+    expect(updateEntry).toHaveBeenCalledWith({
+      oldKey: "Post.title",
+      newKey: "Post.headline",
+      source: "entity",
+      values: { ko: "게시글 제목" },
+    });
+  });
+
+  it("dry run은 사전을 변경하지 않는다", async () => {
+    const updateEntry = stubDictionary();
+
+    await expect(
+      tooling.i18n.update({ key: "Post.title", values: { ko: "게시글 제목" }, dryRun: true }),
+    ).resolves.toMatchObject({ operation: "update", dryRun: true });
+
+    expect(updateEntry).not.toHaveBeenCalled();
+  });
+});

package/src/tooling/__tests__/cli-tooling-scaffold.contract.test.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { Sonamu } from "../../api/sonamu";
+import * as codeGenerator from "../../syncer/code-generator";
+import { tooling } from "../cli-tooling";
+import { attachSonamuTestRoot, detachSonamuTestRoot } from "./helpers/sonamu-test-root";
+
+const RENDERED_PATH = "/:target/src/components/PostSearchInput.tsx";
+
+function stubRenderTemplate() {
+  return vi
+    .spyOn(codeGenerator, "renderTemplate")
+    .mockResolvedValue([{ path: RENDERED_PATH, code: "// rendered" }]);
+}
+
+beforeEach(async () => {
+  await attachSonamuTestRoot();
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await detachSonamuTestRoot();
+});
+
+describe("scaffold의 view_search_input 템플릿", () => {
+  it("status에서 view_search_input을 렌더링 대상으로 인식한다", async () => {
+    const renderTemplate = stubRenderTemplate();
+
+    await expect(
+      tooling.scaffold.status({ entities: ["Post"], templates: ["view_search_input"] }),
+    ).resolves.toEqual([
+      {
+        entityId: "Post",
+        template: "view_search_input",
+        target: path.join(Sonamu.appRootPath, "web/src/components/PostSearchInput.tsx"),
+        exists: false,
+      },
+    ]);
+
+    expect(renderTemplate).toHaveBeenCalledWith("view_search_input", { entityId: "Post" });
+  });
+
+  it("preview에서 view_search_input의 렌더링 내용을 반환한다", async () => {
+    stubRenderTemplate();
+
+    await expect(
+      tooling.scaffold.preview({ entities: ["Post"], templates: ["view_search_input"] }),
+    ).resolves.toEqual([
+      expect.objectContaining({ template: "view_search_input", content: "// rendered" }),
+    ]);
+  });
+
+  it("batch dry run에서도 view_search_input을 렌더링한다", async () => {
+    const renderTemplate = stubRenderTemplate();
+
+    await expect(
+      tooling.scaffold.batch({
+        entities: ["Post"],
+        templates: ["view_search_input"],
+        dryRun: true,
+      }),
+    ).resolves.toEqual([expect.objectContaining({ template: "view_search_input" })]);
+
+    expect(renderTemplate).toHaveBeenCalledWith("view_search_input", { entityId: "Post" });
+  });
+
+  it("기존 템플릿 키도 그대로 렌더링한다", async () => {
+    const renderTemplate = stubRenderTemplate();
+
+    await tooling.scaffold.status({ entities: ["Post"], templates: ["view_list"] });
+
+    expect(renderTemplate).toHaveBeenCalledWith("view_list", { entityId: "Post" });
+  });
+
+  it("지원하지 않는 템플릿 키는 거절한다", async () => {
+    const renderTemplate = stubRenderTemplate();
+
+    await expect(
+      tooling.scaffold.status({ entities: ["Post"], templates: ["bogus_template"] }),
+    ).rejects.toThrow();
+
+    expect(renderTemplate).not.toHaveBeenCalled();
+  });
+});