sonamu 0.10.13 → 0.11.0

package/dist/tooling/fixture-service.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+declare const legacyFixtureOptionsSchema: z.ZodObject<{
+    _: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    all: z.ZodOptional<z.ZodBoolean>;
+    include: z.ZodOptional<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    strategy: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    saveTo: z.ZodOptional<z.ZodString>;
+    useLlm: z.ZodOptional<z.ZodBoolean>;
+    noCache: z.ZodOptional<z.ZodBoolean>;
+    "save-to": z.ZodOptional<z.ZodString>;
+    "use-llm": z.ZodOptional<z.ZodBoolean>;
+    "no-cache": z.ZodOptional<z.ZodBoolean>;
+    nonInteractive: z.ZodOptional<z.ZodBoolean>;
+    userMode: z.ZodOptional<z.ZodEnum<{
+        dummy: "dummy";
+        login: "login";
+    }>>;
+}, z.core.$strip>;
+type LegacyFixtureOptions = z.infer<typeof legacyFixtureOptionsSchema>;
+export type LegacyFixtureSource = z.input<typeof legacyFixtureOptionsSchema>;
+export type LegacyFixtureCommand = "gen" | "fetch" | "explore";
+export type NormalizedLegacyFixtureOptions = Omit<LegacyFixtureOptions, "saveTo" | "useLlm" | "noCache">;
+export declare function normalizeLegacyFixtureOptions(input: LegacyFixtureSource): NormalizedLegacyFixtureOptions;
+export declare function normalizeLegacyFixtureCommandOptions(command: LegacyFixtureCommand, input: LegacyFixtureSource): NormalizedLegacyFixtureOptions;
+export {};
+//# sourceMappingURL=fixture-service.d.ts.map

package/dist/tooling/fixture-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-service.d.ts","sourceRoot":"","sources":["../../src/tooling/fixture-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;iBAgB9B,CAAC;AAEH,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC7E,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;AAC/D,MAAM,MAAM,8BAA8B,GAAG,IAAI,CAC/C,oBAAoB,EACpB,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAChC,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,mBAAmB,GACzB,8BAA8B,CAQhC;AAUD,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,mBAAmB,GACzB,8BAA8B,CAoBhC"}

package/dist/tooling/fixture-service.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+//#region src/tooling/fixture-service.ts
+const legacyFixtureOptionsSchema = z.object({
+	_: z.array(z.string()).optional(),
+	all: z.boolean().optional(),
+	include: z.string().optional(),
+	exclude: z.string().optional(),
+	count: z.union([z.string(), z.number()]).optional(),
+	strategy: z.string().optional(),
+	limit: z.union([z.string(), z.number()]).optional(),
+	saveTo: z.string().optional(),
+	useLlm: z.boolean().optional(),
+	noCache: z.boolean().optional(),
+	"save-to": z.string().optional(),
+	"use-llm": z.boolean().optional(),
+	"no-cache": z.boolean().optional(),
+	nonInteractive: z.boolean().optional(),
+	userMode: z.enum(["login", "dummy"]).optional()
+});
+function normalizeLegacyFixtureOptions(input) {
+	const { saveTo, useLlm, noCache, ...options } = legacyFixtureOptionsSchema.parse(input);
+	return {
+		...options,
+		"save-to": saveTo ?? options["save-to"],
+		"use-llm": useLlm ?? options["use-llm"],
+		"no-cache": noCache ?? options["no-cache"]
+	};
+}
+function hasLegacyFixtureSelector(command, input) {
+	const hasInclude = input.include !== void 0 && input.include.trim().length > 0;
+	return command === "explore" ? hasInclude : input.all === true || hasInclude;
+}
+function normalizeLegacyFixtureCommandOptions(command, input) {
+	const normalized = normalizeLegacyFixtureOptions(input);
+	if (normalized.nonInteractive !== true) return normalized;
+	if (!hasLegacyFixtureSelector(command, normalized)) throw Object.assign(/* @__PURE__ */ new Error(`Missing fixture ${command} selector.`), {
+		code: "MISSING_ARGUMENT",
+		exitCode: 2
+	});
+	if (command !== "gen") return normalized;
+	return {
+		...normalized,
+		count: normalized.count || 5,
+		"save-to": normalized["save-to"] || "db",
+		"use-llm": normalized["use-llm"] ?? false,
+		"no-cache": normalized["no-cache"] ?? false,
+		userMode: normalized.userMode ?? "dummy"
+	};
+}
+//#endregion
+export { normalizeLegacyFixtureCommandOptions, normalizeLegacyFixtureOptions };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/tooling/index.d.ts

@@ -0,0 +1,2 @@
+export { tooling } from "./cli-tooling";
+//# sourceMappingURL=index.d.ts.map

package/dist/tooling/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tooling/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}

package/dist/tooling/index.js

@@ -0,0 +1,2 @@
+import { tooling } from "./cli-tooling.js";
+export { tooling };

package/dist/tooling/test-run-client.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export interface TestRunRequest {
+    files?: string[];
+    pattern?: string;
+    traces?: boolean;
+}
+interface TestRunResult {
+    ok: boolean;
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+        durationMs: number;
+    };
+    results: z.infer<typeof jsonValueSchema>[];
+}
+export interface TestRunClient {
+    status(): Promise<JsonObject>;
+    run(input: TestRunRequest): Promise<TestRunResult>;
+}
+declare const jsonValueSchema: z.ZodJSONSchema;
+declare const jsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+type JsonObject = z.infer<typeof jsonObjectSchema>;
+export declare function createDefaultTestRunClient(projectRoot?: string): TestRunClient;
+export {};
+//# sourceMappingURL=test-run-client.d.ts.map

package/dist/tooling/test-run-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-run-client.d.ts","sourceRoot":"","sources":["../../src/tooling/test-run-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,aAAa;IACrB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9B,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACpD;AAsBD,QAAA,MAAM,eAAe,iBAAW,CAAC;AACjC,QAAA,MAAM,gBAAgB,2CAAwC,CAAC;AAC/D,KAAK,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AA2InD,wBAAgB,0BAA0B,CAAC,WAAW,GAAE,MAA0B,GAAG,aAAa,CAMjG"}

package/dist/tooling/test-run-client.js

@@ -0,0 +1,120 @@
+import { findApiRootPath, init_utils } from "../utils/utils.js";
+import { init_config, loadConfig } from "../api/config.js";
+import { z } from "zod";
+//#region src/tooling/test-run-client.ts
+init_config();
+init_utils();
+var TestRunClientError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "TestRunClientError";
+	}
+};
+const jsonValueSchema = z.json();
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+const configSchema = z.object({
+	server: z.object({ listen: z.object({
+		host: z.string().optional(),
+		port: z.number().optional()
+	}).optional() }).optional(),
+	test: z.object({ devRunner: z.object({
+		enabled: z.boolean().optional(),
+		routePrefix: z.string().optional()
+	}).optional() }).optional()
+});
+const testRunResultSchema = z.object({
+	ok: z.boolean(),
+	summary: z.object({
+		total: z.number(),
+		passed: z.number(),
+		failed: z.number(),
+		skipped: z.number(),
+		durationMs: z.number()
+	}),
+	results: z.array(jsonValueSchema)
+});
+/**
+* sonamu.config를 소스(`src/sonamu.config.ts`)에서 읽도록 강제해 설정을 불러옵니다.
+*
+* loadConfig는 VITEST/HOT 환경변수로 dist/소스 설정을 고르므로, dist 빌드가 없는
+* 일반 개발 셸에서도 소스 설정을 읽도록 VITEST를 잠시 켜고 원래 값을 그대로 복원합니다.
+*/
+async function loadSourceConfig(dependencies) {
+	const previousVitest = process.env.VITEST;
+	process.env.VITEST = "true";
+	try {
+		return await dependencies.loadConfig(dependencies.projectRoot);
+	} finally {
+		if (previousVitest === void 0) delete process.env.VITEST;
+		else process.env.VITEST = previousVitest;
+	}
+}
+async function resolveBaseUrl(dependencies) {
+	let config;
+	try {
+		config = await loadSourceConfig(dependencies);
+	} catch {
+		throw new TestRunClientError("TEST_RUN_CONFIG_ERROR", "sonamu.config를 불러올 수 없습니다. 프로젝트 설정을 확인하세요.");
+	}
+	const parsedConfig = configSchema.parse(config);
+	const listen = parsedConfig.server?.listen;
+	const devRunner = parsedConfig.test?.devRunner;
+	if (devRunner?.enabled !== true) throw new TestRunClientError("TEST_RUN_CONFIG_ERROR", "sonamu.config의 test.devRunner.enabled를 true로 설정해야 합니다.");
+	const configuredHost = listen?.host ?? "localhost";
+	const host = ["0.0.0.0", "::"].includes(configuredHost) ? "127.0.0.1" : configuredHost;
+	const port = listen?.port ?? 3e3;
+	const routePrefix = devRunner.routePrefix ?? "/__test__";
+	return `http://${host}:${port}${(routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`).replace(/\/$/, "")}`;
+}
+async function requestJson(dependencies, url, init) {
+	let response;
+	try {
+		response = await dependencies.fetch(url, init);
+	} catch {
+		throw new TestRunClientError("TEST_RUN_NETWORK_ERROR", "로컬 DevRunner에 연결할 수 없습니다. sonamu dev 실행 상태를 확인하세요.");
+	}
+	if (!response.ok) throw new TestRunClientError("TEST_RUN_HTTP_ERROR", `DevRunner 요청이 HTTP ${response.status} 상태로 실패했습니다.`);
+	const object = jsonObjectSchema.safeParse(await response.json());
+	if (!object.success) throw new TestRunClientError("TEST_RUN_HTTP_ERROR", "DevRunner 응답이 JSON 객체가 아닙니다.");
+	return object.data;
+}
+function parseResult(value) {
+	const result = testRunResultSchema.safeParse(value);
+	if (!result.success) throw new TestRunClientError("TEST_RUN_HTTP_ERROR", "DevRunner 테스트 결과의 구조가 올바르지 않습니다.");
+	return result.data;
+}
+function createTestRunClient(dependencies) {
+	return {
+		async status() {
+			return requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/status`);
+		},
+		async run(input) {
+			const payload = {};
+			if (input.files !== void 0) payload.files = input.files;
+			if (input.pattern !== void 0) payload.pattern = input.pattern;
+			const result = parseResult(await requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/run`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(payload)
+			}));
+			if (!result.ok) throw Object.assign(new TestRunClientError("TEST_RUN_FAILED", "테스트 실행이 실패했습니다."), {
+				exitCode: 1,
+				result
+			});
+			return result;
+		}
+	};
+}
+function createDefaultTestRunClient(projectRoot = findApiRootPath()) {
+	return createTestRunClient({
+		projectRoot,
+		loadConfig,
+		fetch: globalThis.fetch
+	});
+}
+//#endregion
+export { createDefaultTestRunClient };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"test-run-client.js","names":[],"sources":["../../src/tooling/test-run-client.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { loadConfig } from \"../api/config\";\nimport { findApiRootPath } from \"../utils/utils\";\n\nexport interface TestRunRequest {\n  files?: string[];\n  pattern?: string;\n  traces?: boolean;\n}\n\ninterface TestRunResult {\n  ok: boolean;\n  summary: {\n    total: number;\n    passed: number;\n    failed: number;\n    skipped: number;\n    durationMs: number;\n  };\n  results: z.infer<typeof jsonValueSchema>[];\n}\n\nexport interface TestRunClient {\n  status(): Promise<JsonObject>;\n  run(input: TestRunRequest): Promise<TestRunResult>;\n}\n\ninterface TestRunClientDependencies {\n  projectRoot: string;\n  loadConfig(projectRoot: string): Promise<object>;\n  fetch: typeof globalThis.fetch;\n}\n\nclass TestRunClientError extends Error {\n  constructor(\n    readonly code:\n      | \"TEST_RUN_CONFIG_ERROR\"\n      | \"TEST_RUN_FAILED\"\n      | \"TEST_RUN_HTTP_ERROR\"\n      | \"TEST_RUN_NETWORK_ERROR\",\n    message: string,\n  ) {\n    super(message);\n    this.name = \"TestRunClientError\";\n  }\n}\n\nconst jsonValueSchema = z.json();\nconst jsonObjectSchema = z.record(z.string(), jsonValueSchema);\ntype JsonObject = z.infer<typeof jsonObjectSchema>;\nconst configSchema = z.object({\n  server: z\n    .object({\n      listen: z.object({ host: z.string().optional(), port: z.number().optional() }).optional(),\n    })\n    .optional(),\n  test: z\n    .object({\n      devRunner: z\n        .object({ enabled: z.boolean().optional(), routePrefix: z.string().optional() })\n        .optional(),\n    })\n    .optional(),\n});\nconst testRunResultSchema = z.object({\n  ok: z.boolean(),\n  summary: z.object({\n    total: z.number(),\n    passed: z.number(),\n    failed: z.number(),\n    skipped: z.number(),\n    durationMs: z.number(),\n  }),\n  results: z.array(jsonValueSchema),\n});\n\n/**\n * sonamu.config를 소스(`src/sonamu.config.ts`)에서 읽도록 강제해 설정을 불러옵니다.\n *\n * loadConfig는 VITEST/HOT 환경변수로 dist/소스 설정을 고르므로, dist 빌드가 없는\n * 일반 개발 셸에서도 소스 설정을 읽도록 VITEST를 잠시 켜고 원래 값을 그대로 복원합니다.\n */\nasync function loadSourceConfig(dependencies: TestRunClientDependencies): Promise<object> {\n  const previousVitest = process.env.VITEST;\n  process.env.VITEST = \"true\";\n  try {\n    return await dependencies.loadConfig(dependencies.projectRoot);\n  } finally {\n    if (previousVitest === undefined) {\n      delete process.env.VITEST;\n    } else {\n      process.env.VITEST = previousVitest;\n    }\n  }\n}\n\nasync function resolveBaseUrl(dependencies: TestRunClientDependencies): Promise<string> {\n  let config: object;\n  try {\n    config = await loadSourceConfig(dependencies);\n  } catch {\n    throw new TestRunClientError(\n      \"TEST_RUN_CONFIG_ERROR\",\n      \"sonamu.config를 불러올 수 없습니다. 프로젝트 설정을 확인하세요.\",\n    );\n  }\n  const parsedConfig = configSchema.parse(config);\n  const listen = parsedConfig.server?.listen;\n  const devRunner = parsedConfig.test?.devRunner;\n  if (devRunner?.enabled !== true) {\n    throw new TestRunClientError(\n      \"TEST_RUN_CONFIG_ERROR\",\n      \"sonamu.config의 test.devRunner.enabled를 true로 설정해야 합니다.\",\n    );\n  }\n  const configuredHost = listen?.host ?? \"localhost\";\n  const host = [\"0.0.0.0\", \"::\"].includes(configuredHost) ? \"127.0.0.1\" : configuredHost;\n  const port = listen?.port ?? 3000;\n  const routePrefix = devRunner.routePrefix ?? \"/__test__\";\n  const prefix = (routePrefix.startsWith(\"/\") ? routePrefix : `/${routePrefix}`).replace(/\\/$/, \"\");\n  return `http://${host}:${port}${prefix}`;\n}\n\nasync function requestJson(\n  dependencies: TestRunClientDependencies,\n  url: string,\n  init?: RequestInit,\n): Promise<JsonObject> {\n  let response: Response;\n  try {\n    response = await dependencies.fetch(url, init);\n  } catch {\n    throw new TestRunClientError(\n      \"TEST_RUN_NETWORK_ERROR\",\n      \"로컬 DevRunner에 연결할 수 없습니다. sonamu dev 실행 상태를 확인하세요.\",\n    );\n  }\n  if (!response.ok) {\n    throw new TestRunClientError(\n      \"TEST_RUN_HTTP_ERROR\",\n      `DevRunner 요청이 HTTP ${response.status} 상태로 실패했습니다.`,\n    );\n  }\n  const object = jsonObjectSchema.safeParse(await response.json());\n  if (!object.success) {\n    throw new TestRunClientError(\"TEST_RUN_HTTP_ERROR\", \"DevRunner 응답이 JSON 객체가 아닙니다.\");\n  }\n  return object.data;\n}\n\nfunction parseResult(value: JsonObject): TestRunResult {\n  const result = testRunResultSchema.safeParse(value);\n  if (!result.success) {\n    throw new TestRunClientError(\n      \"TEST_RUN_HTTP_ERROR\",\n      \"DevRunner 테스트 결과의 구조가 올바르지 않습니다.\",\n    );\n  }\n  return result.data;\n}\n\nfunction createTestRunClient(dependencies: TestRunClientDependencies): TestRunClient {\n  return {\n    async status() {\n      return requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/status`);\n    },\n    async run(input) {\n      const payload: TestRunRequest = {};\n      if (input.files !== undefined) payload.files = input.files;\n      if (input.pattern !== undefined) payload.pattern = input.pattern;\n      const result = parseResult(\n        await requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/run`, {\n          method: \"POST\",\n          headers: { \"Content-Type\": \"application/json\" },\n          body: JSON.stringify(payload),\n        }),\n      );\n      if (!result.ok) {\n        throw Object.assign(\n          new TestRunClientError(\"TEST_RUN_FAILED\", \"테스트 실행이 실패했습니다.\"),\n          { exitCode: 1, result },\n        );\n      }\n      return result;\n    },\n  };\n}\n\nexport function createDefaultTestRunClient(projectRoot: string = findApiRootPath()): TestRunClient {\n  return createTestRunClient({\n    projectRoot,\n    loadConfig,\n    fetch: globalThis.fetch,\n  });\n}\n"],"mappings":"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"}

package/dist/tsdown.api.config.js

@@ -0,0 +1,48 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+//#region tsdown.api.config.ts
+const srcRoot = path.resolve(process.cwd(), "src");
+const ignoredSuffixes = [
+	".test.ts",
+	".test-hold.ts",
+	".ignore.ts",
+	".d.ts"
+];
+const ignoredDirectories = /* @__PURE__ */ new Set([
+	"__mocks__",
+	"_templates",
+	"wasted_src"
+]);
+async function collectEntries(directory) {
+	const entries = {};
+	for (const entry of await readdir(directory)) {
+		if (ignoredDirectories.has(entry)) continue;
+		const absolutePath = path.join(directory, entry);
+		if ((await stat(absolutePath)).isDirectory()) {
+			Object.assign(entries, await collectEntries(absolutePath));
+			continue;
+		}
+		if (!absolutePath.endsWith(".ts") || ignoredSuffixes.some((suffix) => absolutePath.endsWith(suffix))) continue;
+		const entryName = path.relative(srcRoot, absolutePath).replace(/\.ts$/, "").split(path.sep).join("/");
+		entries[entryName] = absolutePath;
+	}
+	return entries;
+}
+var tsdown_api_config_default = {
+	clean: true,
+	deps: { neverBundle: [/^sonamu(?:\/.*)?$/] },
+	dts: false,
+	entry: await collectEntries(srcRoot),
+	fixedExtension: false,
+	format: "esm",
+	outDir: path.resolve(process.cwd(), "dist"),
+	platform: "node",
+	sourcemap: "inline",
+	target: "esnext",
+	treeshake: false,
+	unbundle: true
+};
+//#endregion
+export { tsdown_api_config_default as default };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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