sonamu 0.10.11 → 0.10.13

package/src/bin/__tests__/zod-compiler-build.test.ts

@@ -0,0 +1,307 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { isFunctionValue, isObjectValue } from "../../utils/runtime-value";
+import {
+  assertApiZodCompilerBuildOutput,
+  assertApiZodCompilerSourceRegistry,
+  composeApiZodCompilerBuildConfig,
+  createApiZodCompilerBuildWrapper,
+} from "../build-config";
+
+const compilerPluginFake = vi.fn();
+const compilerDependencies = {
+  async loadCompilerPlugin() {
+    return compilerPluginFake;
+  },
+};
+
+describe("API zod-compiler 빌드 정책", () => {
+  const tempRoots: string[] = [];
+
+  beforeEach(() => {
+    compilerPluginFake.mockReset();
+  });
+
+  afterEach(async () => {
+    await Promise.all(
+      tempRoots.splice(0).map((rootPath) => rm(rootPath, { recursive: true, force: true })),
+    );
+  });
+
+  it.each([false, "jit"] as const)(
+    "%s 정책은 registry 없이 기존 tsdown 설정을 유지한다",
+    async (api) => {
+      const baseConfig = {
+        entry: ["src/index.ts"],
+        plugins: [{ name: "custom" }],
+      };
+
+      expect(
+        await composeApiZodCompilerBuildConfig(baseConfig, {
+          policy: { api, targets: {} },
+        }),
+      ).toEqual(baseConfig);
+      expect(compilerPluginFake).not.toHaveBeenCalled();
+    },
+  );
+
+  it("기본 설정과 사용자 설정에 registry 전용 explicit compact inline plugin을 합성한다", async () => {
+    const registryPath = "/project/api/src/application/sonamu.validators.generated.ts";
+    const compilerPlugin = { name: "zod-compiler" };
+    const customPlugin = { name: "custom" };
+    compilerPluginFake.mockReturnValue(compilerPlugin);
+
+    const defaultConfig = await composeApiZodCompilerBuildConfig(
+      { entry: ["src/index.ts"] },
+      {
+        policy: { api: "aot", targets: {} },
+        registryPath,
+      },
+      compilerDependencies,
+    );
+    const customConfig = await composeApiZodCompilerBuildConfig(
+      { entry: ["src/index.ts"], plugins: [customPlugin] },
+      {
+        policy: { api: "aot", targets: {} },
+        registryPath,
+      },
+      compilerDependencies,
+    );
+
+    expect(compilerPluginFake).toHaveBeenNthCalledWith(1, {
+      codegenMode: "inline",
+      include: [registryPath],
+      output: "compact",
+      schemas: "explicit",
+    });
+    expect(compilerPluginFake).toHaveBeenNthCalledWith(2, {
+      codegenMode: "inline",
+      include: [registryPath],
+      output: "compact",
+      schemas: "explicit",
+    });
+    expect(defaultConfig.plugins).toEqual([compilerPlugin]);
+    expect(customConfig.plugins).toEqual([customPlugin, compilerPlugin]);
+  });
+
+  it("실제 build wrapper가 사용자 object entry와 plugin을 보존하면서 registry entry를 추가한다", async () => {
+    const apiRootPath = await mkdtemp(path.join(process.cwd(), ".sonamu-build-wrapper-test-"));
+    tempRoots.push(apiRootPath);
+    const registryPath = path.join(apiRootPath, "src/application/sonamu.validators.generated.ts");
+    const baseConfigPath = path.join(apiRootPath, "tsdown.config.mjs");
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(
+      registryPath,
+      `export const fingerprint = "${"a".repeat(64)}";\nexport const validator = compile(schema);\n`,
+    );
+    await writeFile(
+      baseConfigPath,
+      `export default { entry: { index: "src/index.ts" }, plugins: [{ name: "custom" }] };\n`,
+    );
+    const wrapperPath = await createApiZodCompilerBuildWrapper({
+      apiRootPath,
+      baseConfigPath,
+      policy: { api: "aot", targets: {} },
+      registryPath,
+    });
+    const wrapperModule: unknown = await import(`${pathToFileURL(wrapperPath).href}?test=entry`);
+    if (
+      !isObjectValue(wrapperModule) ||
+      wrapperModule === null ||
+      !("default" in wrapperModule) ||
+      !isFunctionValue(wrapperModule.default)
+    ) {
+      throw new Error("build wrapper가 default config factory를 내보내지 않았습니다");
+    }
+    const resolvedConfig: unknown = await wrapperModule.default();
+    if (!isObjectValue(resolvedConfig) || resolvedConfig === null) {
+      throw new Error("build wrapper가 tsdown config object를 반환하지 않았습니다");
+    }
+    const entry = "entry" in resolvedConfig ? resolvedConfig.entry : undefined;
+    const plugins = "plugins" in resolvedConfig ? resolvedConfig.plugins : undefined;
+
+    expect(entry).toMatchObject({ index: "src/index.ts" });
+    expect(isObjectValue(entry) && entry !== null ? Object.values(entry) : []).toContain(
+      registryPath,
+    );
+    expect(plugins).toEqual([
+      { name: "custom" },
+      expect.objectContaining({ name: "zod-compiler" }),
+    ]);
+  });
+
+  it("entry가 undefined인 사용자 설정은 tsdown 기본 entry와 registry entry를 함께 보존한다", async () => {
+    const apiRootPath = await mkdtemp(path.join(process.cwd(), ".sonamu-default-entry-test-"));
+    tempRoots.push(apiRootPath);
+    const registryPath = path.join(apiRootPath, "src/application/sonamu.validators.generated.ts");
+    const baseConfigPath = path.join(apiRootPath, "tsdown.config.mjs");
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(
+      registryPath,
+      `export const fingerprint = "${"c".repeat(64)}";\nexport const validator = compile(schema);\n`,
+    );
+    await writeFile(
+      baseConfigPath,
+      `export default { entry: undefined, plugins: [{ name: "custom" }] };\n`,
+    );
+    const wrapperPath = await createApiZodCompilerBuildWrapper({
+      apiRootPath,
+      baseConfigPath,
+      policy: { api: "aot", targets: {} },
+      registryPath,
+    });
+    const wrapperModule: unknown = await import(`${pathToFileURL(wrapperPath).href}?test=default`);
+    if (
+      !isObjectValue(wrapperModule) ||
+      wrapperModule === null ||
+      !("default" in wrapperModule) ||
+      !isFunctionValue(wrapperModule.default)
+    ) {
+      throw new Error("build wrapper가 default config factory를 내보내지 않았습니다");
+    }
+    const resolvedConfig: unknown = await wrapperModule.default();
+    if (
+      !isObjectValue(resolvedConfig) ||
+      resolvedConfig === null ||
+      !("entry" in resolvedConfig) ||
+      !isObjectValue(resolvedConfig.entry) ||
+      resolvedConfig.entry === null
+    ) {
+      throw new Error("build wrapper가 기본 entry를 포함한 object entry를 반환하지 않았습니다");
+    }
+
+    expect(resolvedConfig.entry).toMatchObject({
+      index: "src/index.ts",
+      "application/sonamu.validators.generated": registryPath,
+    });
+    expect("plugins" in resolvedConfig ? resolvedConfig.plugins : undefined).toEqual([
+      { name: "custom" },
+      expect.objectContaining({ name: "zod-compiler" }),
+    ]);
+  });
+
+  it("canonical registry key의 상대 entry는 같은 registry로 해석해 충돌 없이 보존한다", async () => {
+    const apiRootPath = await mkdtemp(path.join(process.cwd(), ".sonamu-relative-entry-test-"));
+    tempRoots.push(apiRootPath);
+    const relativeRegistryPath = "./src/application/sonamu.validators.generated.ts";
+    const registryPath = path.join(apiRootPath, "src/application/sonamu.validators.generated.ts");
+    const baseConfigPath = path.join(apiRootPath, "tsdown.config.mjs");
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(
+      registryPath,
+      `export const fingerprint = "${"b".repeat(64)}";\nexport const validator = compile(schema);\n`,
+    );
+    await writeFile(
+      baseConfigPath,
+      [
+        "export default {",
+        '  entry: { index: "src/index.ts",',
+        `    "application/sonamu.validators.generated": ${JSON.stringify(relativeRegistryPath)} },`,
+        "};",
+        "",
+      ].join("\n"),
+    );
+    const wrapperPath = await createApiZodCompilerBuildWrapper({
+      apiRootPath,
+      baseConfigPath,
+      policy: { api: "aot", targets: {} },
+      registryPath,
+    });
+    const wrapperModule: unknown = await import(`${pathToFileURL(wrapperPath).href}?test=relative`);
+    if (
+      !isObjectValue(wrapperModule) ||
+      wrapperModule === null ||
+      !("default" in wrapperModule) ||
+      !isFunctionValue(wrapperModule.default)
+    ) {
+      throw new Error("build wrapper가 default config factory를 내보내지 않았습니다");
+    }
+    const resolvedConfig: unknown = await wrapperModule.default();
+    if (
+      !isObjectValue(resolvedConfig) ||
+      resolvedConfig === null ||
+      !("entry" in resolvedConfig) ||
+      !isObjectValue(resolvedConfig.entry) ||
+      resolvedConfig.entry === null
+    ) {
+      throw new Error("build wrapper가 object entry를 반환하지 않았습니다");
+    }
+
+    expect(resolvedConfig.entry).toMatchObject({
+      index: "src/index.ts",
+      "application/sonamu.validators.generated": relativeRegistryPath,
+    });
+  });
+
+  it("REST API가 0개인 AOT registry를 compile 경계 없이 검증하고 wrapper로 내보낸다", async () => {
+    const apiRootPath = await mkdtemp(path.join(process.cwd(), ".sonamu-zero-registry-test-"));
+    tempRoots.push(apiRootPath);
+    const registryPath = path.join(apiRootPath, "src/application/sonamu.validators.generated.ts");
+    const baseConfigPath = path.join(apiRootPath, "tsdown.config.mjs");
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(
+      registryPath,
+      [
+        `export const fingerprint = "${"0".repeat(64)}";`,
+        "export const routeIds = {};",
+        "export const validators = new Map();",
+        "",
+      ].join("\n"),
+    );
+    await writeFile(baseConfigPath, `export default { entry: { index: "src/index.ts" } };\n`);
+
+    await expect(assertApiZodCompilerSourceRegistry(registryPath)).resolves.toBeUndefined();
+    const wrapperPath = await createApiZodCompilerBuildWrapper({
+      apiRootPath,
+      baseConfigPath,
+      policy: { api: "aot", targets: {} },
+      registryPath,
+    });
+
+    await expect(readFile(wrapperPath, "utf8")).resolves.toContain(registryPath);
+    const registrySource = await readFile(registryPath, "utf8");
+    expect(() =>
+      assertApiZodCompilerBuildOutput([
+        {
+          code: registrySource,
+          path: registryPath,
+        },
+      ]),
+    ).not.toThrow();
+  });
+
+  it.each([
+    {
+      code: "export const validator = compile(schema);",
+      label: "적용되지 않은 compile 경계",
+    },
+    {
+      code: 'import { parse } from "virtual:zod-compiler/runtime";',
+      label: "해석되지 않은 virtual runtime import",
+    },
+  ])("$label가 남은 AOT 산출물을 거부한다", ({ code }) => {
+    expect(() =>
+      assertApiZodCompilerBuildOutput([
+        {
+          code,
+          path: "dist/application/sonamu.validators.generated.js",
+        },
+      ]),
+    ).toThrow();
+  });
+
+  it("compile 경계와 virtual import가 제거된 AOT 산출물을 허용한다", () => {
+    expect(() =>
+      assertApiZodCompilerBuildOutput([
+        {
+          code: "export const validator = { parse(input) { return input; } };",
+          path: "dist/application/sonamu.validators.generated.js",
+        },
+      ]),
+    ).not.toThrow();
+  });
+});

package/src/bin/build-config.ts

@@ -1,3 +1,12 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { type UserConfig } from "tsdown";
+
+import { type NormalizedZodCompilerPolicy } from "../api/config";
+import { exists } from "../utils/fs-utils";
+
 export type BuildArtifact<BuildCommandArgs = {}> = {
   name: string;
   description: string;
@@ -7,6 +16,164 @@ export type BuildArtifact<BuildCommandArgs = {}> = {
   postBuildCommand?: () => string;
 };
 
+export type ApiTsdownBuildConfig = Pick<UserConfig, "entry" | "plugins">;
+
+type ZodCompilerPluginFactory = (typeof import("zod-compiler/rolldown"))["default"];
+
+export interface ApiZodCompilerBuildDependencies {
+  loadCompilerPlugin: () => Promise<ZodCompilerPluginFactory>;
+}
+
+const apiZodCompilerBuildDependencies: ApiZodCompilerBuildDependencies = {
+  async loadCompilerPlugin() {
+    return (await import("zod-compiler/rolldown")).default;
+  },
+};
+
+export async function composeApiZodCompilerBuildConfig<T extends ApiTsdownBuildConfig>(
+  baseConfig: T,
+  options: {
+    policy: NormalizedZodCompilerPolicy;
+    registryPath?: string;
+  },
+  dependencies: ApiZodCompilerBuildDependencies = apiZodCompilerBuildDependencies,
+): Promise<T & ApiTsdownBuildConfig> {
+  if (options.policy.api !== "aot") {
+    return baseConfig;
+  }
+  if (options.registryPath === undefined) {
+    throw new Error("validation.zodCompiler.api requires the generated HTTP validator registry");
+  }
+
+  const zodCompiler = await dependencies.loadCompilerPlugin();
+  const compilerPlugin = zodCompiler({
+    codegenMode: "inline",
+    include: [options.registryPath],
+    output: "compact",
+    schemas: "explicit",
+  });
+
+  let configuredPlugins: Exclude<UserConfig["plugins"], undefined>[];
+  if (Array.isArray(baseConfig.plugins)) {
+    configuredPlugins = baseConfig.plugins;
+  } else if (baseConfig.plugins === undefined) {
+    configuredPlugins = [];
+  } else {
+    configuredPlugins = [baseConfig.plugins];
+  }
+
+  return {
+    ...baseConfig,
+    plugins: [...configuredPlugins, compilerPlugin],
+  };
+}
+
+export function assertApiZodCompilerBuildOutput(
+  outputs: readonly { code: string; path: string }[],
+): void {
+  for (const output of outputs) {
+    if (/\bcompile\s*\(/.test(output.code)) {
+      throw new Error(`zod-compiler compile boundary remains in ${output.path}`);
+    }
+    if (output.code.includes("virtual:zod-compiler/runtime")) {
+      throw new Error(`zod-compiler virtual runtime import remains in ${output.path}`);
+    }
+  }
+}
+
+export const HTTP_VALIDATOR_REGISTRY_SOURCE_PATH = "src/application/sonamu.validators.generated.ts";
+export const HTTP_VALIDATOR_REGISTRY_BUILD_PATH = "dist/application/sonamu.validators.generated.js";
+
+export async function assertApiZodCompilerSourceRegistry(registryPath: string): Promise<void> {
+  if (!(await exists(registryPath))) {
+    throw new Error(`Generated HTTP validator registry not found: ${registryPath}`);
+  }
+  const source = await readFile(registryPath, "utf8");
+  if (!/fingerprint\s*=\s*["'][a-f0-9]{64}["']/.test(source)) {
+    throw new Error(`Generated HTTP validator registry fingerprint is invalid: ${registryPath}`);
+  }
+  const declaresZeroRoutes = /\brouteIds\s*=\s*\{\s*\}\s*;/.test(source);
+  if (!declaresZeroRoutes && !/\bcompile\s*\(/.test(source)) {
+    throw new Error(`Generated HTTP validator registry has no compile boundary: ${registryPath}`);
+  }
+}
+
+export async function createApiZodCompilerBuildWrapper(options: {
+  apiRootPath: string;
+  baseConfigPath: string;
+  policy: NormalizedZodCompilerPolicy;
+  registryPath: string;
+}): Promise<string> {
+  if (options.policy.api !== "aot") {
+    return options.baseConfigPath;
+  }
+
+  await assertApiZodCompilerSourceRegistry(options.registryPath);
+  const wrapperPath = path.join(
+    options.apiRootPath,
+    `.sonamu-zod-compiler-${process.pid}-${Date.now()}.mjs`,
+  );
+  const baseConfigUrl = pathToFileURL(options.baseConfigPath).href;
+  const source = [
+    `import path from "node:path";`,
+    `import baseConfig from ${JSON.stringify(baseConfigUrl)};`,
+    `import zodCompiler from "zod-compiler/rolldown";`,
+    "",
+    `const compilerPlugin = zodCompiler(${JSON.stringify({
+      codegenMode: "inline",
+      include: [options.registryPath],
+      output: "compact",
+      schemas: "explicit",
+    })});`,
+    `const registryPath = ${JSON.stringify(options.registryPath)};`,
+    `const apiRootPath = ${JSON.stringify(options.apiRootPath)};`,
+    `const canonicalOutDir = path.join(apiRootPath, "dist");`,
+    `const registryEntryName = "application/sonamu.validators.generated";`,
+    `const defaultEntry = { index: "src/index.ts" };`,
+    "const resolvesToRegistry = (entry) =>",
+    '  typeof entry === "string" && path.resolve(apiRootPath, entry) === registryPath;',
+    "const appendRegistryEntry = (entry) => {",
+    "  if (Array.isArray(entry)) {",
+    "    return entry.some(resolvesToRegistry) ? entry : [...entry, registryPath];",
+    "  }",
+    '  if (typeof entry === "string") {',
+    "    return resolvesToRegistry(entry) ? entry : [entry, registryPath];",
+    "  }",
+    '  if (typeof entry === "object" && entry !== null) {',
+    "    if (Object.values(entry).some(resolvesToRegistry)) return entry;",
+    "    if (registryEntryName in entry) {",
+    "      throw new Error(`tsdown entry collision: ${registryEntryName}`);",
+    "    }",
+    "    return { ...entry, [registryEntryName]: registryPath };",
+    "  }",
+    "  if (entry === undefined) {",
+    "    return { ...defaultEntry, [registryEntryName]: registryPath };",
+    "  }",
+    "  return { [registryEntryName]: registryPath };",
+    "};",
+    "const appendPlugin = (config) => ({",
+    "  ...config,",
+    "  // 런타임 loader가 참조하는 registry 경로를 빌드 설정과 일치시킵니다.",
+    "  outDir: canonicalOutDir,",
+    "  fixedExtension: false,",
+    "  entry: appendRegistryEntry(config.entry),",
+    "  plugins: [...(config.plugins ?? []), compilerPlugin],",
+    "});",
+    "const appendToResolvedConfig = (config) =>",
+    "  Array.isArray(config) ? config.map(appendPlugin) : appendPlugin(config);",
+    "",
+    "export default async (...args) => {",
+    '  const resolved = typeof baseConfig === "function"',
+    "    ? await baseConfig(...args)",
+    "    : await baseConfig;",
+    "  return appendToResolvedConfig(resolved);",
+    "};",
+    "",
+  ].join("\n");
+  await writeFile(wrapperPath, source, "utf8");
+  return wrapperPath;
+}
+
 /**
  * API 프로젝트 빌드 산출물에 대한 규칙들.
  * cli.ts의 build_api 함수가 이것을 보고 그대로 실행합니다.