sonamu 0.10.12 → 0.10.13

package/dist/testing/dev-test-routes.js

@@ -2,7 +2,7 @@ import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { createSSEFactory, init_sse } from "../stream/sse.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { DevVitestManager, init_dev_vitest_manager } from "./dev-vitest-manager.js";
-import { z as z$1 } from "zod";
+import { z } from "zod";
 import { randomUUID } from "crypto";
 //#region src/testing/dev-test-routes.ts
 function toPathPrefix(basePath) {
@@ -24,11 +24,6 @@ function relativizeNode(node, basePath) {
 		children: node.children.map((c) => relativizeNode(c, prefix))
 	};
 }
-function isRunNodeProgressData(data) {
-	if (typeof data !== "object" || data === null) return false;
-	const d = data;
-	return d.schemaVersion === 1 && typeof d.runId === "string" && typeof d.startedAt === "string" && typeof d.at === "string" && (d.kind === "file" || d.kind === "suite" || d.kind === "test") && (d.phase === "ready" || d.phase === "result") && typeof d.fileId === "string" && typeof d.nodeId === "string" && (d.parentId === null || typeof d.parentId === "string") && typeof d.node === "object" && d.node !== null;
-}
 function relativizeResult(result, basePath) {
 	const prefix = toPathPrefix(basePath);
 	return {
@@ -36,19 +31,24 @@ function relativizeResult(result, basePath) {
 		results: result.results.map((n) => relativizeNode(n, prefix))
 	};
 }
-async function registerDevTestRoutes(server, config) {
+async function registerDevTestRoutes(server, config, dependencies) {
 	const prefix = config.routePrefix ?? "/__test__";
-	const manager = new DevVitestManager();
+	const defaultManager = dependencies?.manager === void 0 ? new DevVitestManager() : null;
+	const manager = dependencies?.manager ?? defaultManager;
+	if (manager === null) throw new Error("DevVitestManager dependency is unavailable");
 	await manager.start(config.vitestConfigPath);
-	Sonamu.devVitestManager = manager;
-	const sseAvailable = !!Sonamu.config.server.plugins?.sse;
+	if (defaultManager !== null) Sonamu.devVitestManager = defaultManager;
+	const sseAvailable = dependencies?.sseAvailable ?? !!Sonamu.config.server.plugins?.sse;
 	if (sseAvailable) server.get(`${prefix}/events`, (request, reply) => {
 		const sse = createSSEFactory(request.socket, reply, TestEventSchema);
 		const status = manager.getStatus();
 		sse.publish("snapshot", {
 			schemaVersion: SCHEMA_VERSION,
 			serverTime: (/* @__PURE__ */ new Date()).toISOString(),
-			status
+			status: {
+				...status,
+				sseAvailable
+			}
 		});
 		const heartbeatTimer = setInterval(() => {
 			sse.publish("heartbeat", {
@@ -56,19 +56,26 @@ async function registerDevTestRoutes(server, config) {
 				at: (/* @__PURE__ */ new Date()).toISOString()
 			});
 		}, HEARTBEAT_INTERVAL_MS);
-		const basePath = Sonamu.apiRootPath;
+		const basePath = dependencies?.apiRootPath ?? Sonamu.apiRootPath;
 		const listener = (event, data) => {
-			const key = event;
+			const parsedKey = TestEventNameSchema.safeParse(event);
+			if (!parsedKey.success) return;
+			const key = parsedKey.data;
 			if (key === "runNodeProgress") {
-				if (!isRunNodeProgressData(data)) return;
+				const progressEnvelope = TestEventSchema.partial().safeParse({ runNodeProgress: data });
+				if (!progressEnvelope.success || progressEnvelope.data.runNodeProgress === void 0) return;
+				const progress = progressEnvelope.data.runNodeProgress;
 				const relativized = {
-					...data,
-					node: relativizeNode(data.node, basePath)
+					...progress,
+					node: relativizeNode(progress.node, basePath)
 				};
 				sse.publish(key, relativized);
 				return;
 			}
-			sse.publish(key, data);
+			const parsedEnvelope = TestEventSchema.partial().safeParse({ [key]: data });
+			if (!parsedEnvelope.success || parsedEnvelope.data[key] === void 0) return;
+			const parsedData = parsedEnvelope.data[key];
+			sse.publish(key, parsedData);
 		};
 		manager.addEventListener(listener);
 		let cleaned = false;
@@ -82,19 +89,8 @@ async function registerDevTestRoutes(server, config) {
 		request.socket.on("error", cleanup);
 	});
 	server.post(`${prefix}/run`, async (request, reply) => {
-		if (!Sonamu.devVitestManager) {
-			reply.status(503);
-			return {
-				ok: false,
-				error: "DevVitestManager is not initialized"
-			};
-		}
 		const runId = randomUUID();
-		const body = request.body;
-		const runRequest = {
-			files: body?.files,
-			pattern: body?.pattern
-		};
+		const runRequest = RunRequestSchema.parse(request.body ?? {});
 		manager.emitEvent("runQueued", {
 			schemaVersion: SCHEMA_VERSION,
 			runId,
@@ -108,7 +104,7 @@ async function registerDevTestRoutes(server, config) {
 				runId,
 				startedAt
 			});
-			const result = relativizeResult(await Sonamu.devVitestManager.run(runRequest, runId), Sonamu.apiRootPath);
+			const result = relativizeResult(await manager.run(runRequest, runId), dependencies?.apiRootPath ?? Sonamu.apiRootPath);
 			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
 			manager.emitEvent("runCompleted", {
 				schemaVersion: SCHEMA_VERSION,
@@ -138,20 +134,16 @@ async function registerDevTestRoutes(server, config) {
 	});
 	server.get(`${prefix}/status`, async () => {
 		return {
-			...Sonamu.devVitestManager?.getStatus() ?? {
-				ready: false,
-				running: false,
-				lastRunAt: null
-			},
+			...manager.getStatus(),
 			sseAvailable
 		};
 	});
 	server.addHook("onClose", async () => {
-		await Sonamu.devVitestManager?.shutdown();
-		Sonamu.devVitestManager = null;
+		await manager.shutdown();
+		if (defaultManager !== null) Sonamu.devVitestManager = null;
 	});
 }
-var SCHEMA_VERSION, HEARTBEAT_INTERVAL_MS, SerializedTraceSchema, TestCaseResultSchema, TestEventSchema;
+var SCHEMA_VERSION, HEARTBEAT_INTERVAL_MS, SerializedTraceSchema, TestCaseResultSchema, RunResultSchema, RunRequestSchema, TestEventSchema, TestEventNameSchema;
 //#endregion
 __esmMin((() => {
 	init_sonamu();
@@ -159,24 +151,24 @@ __esmMin((() => {
 	init_dev_vitest_manager();
 	SCHEMA_VERSION = 1;
 	HEARTBEAT_INTERVAL_MS = 3e4;
-	SerializedTraceSchema = z$1.object({
-		key: z$1.string(),
-		value: z$1.unknown(),
-		filePath: z$1.string(),
-		lineNumber: z$1.number(),
-		at: z$1.string()
+	SerializedTraceSchema = z.object({
+		key: z.string(),
+		value: z.unknown(),
+		filePath: z.string(),
+		lineNumber: z.number(),
+		at: z.string()
 	});
-	TestCaseResultSchema = z$1.lazy(() => z$1.object({
-		id: z$1.string(),
-		kind: z$1.enum([
+	TestCaseResultSchema = z.lazy(() => z.object({
+		id: z.string(),
+		kind: z.enum([
 			"file",
 			"suite",
 			"test"
 		]),
-		name: z$1.string(),
-		fullName: z$1.string(),
-		file: z$1.string(),
-		state: z$1.enum([
+		name: z.string(),
+		fullName: z.string(),
+		file: z.string(),
+		state: z.enum([
 			"passed",
 			"failed",
 			"skipped",
@@ -184,82 +176,107 @@ __esmMin((() => {
 			"running",
 			"unknown"
 		]),
-		durationMs: z$1.number().nullable(),
-		counts: z$1.object({
-			total: z$1.number(),
-			passed: z$1.number(),
-			failed: z$1.number(),
-			skipped: z$1.number()
+		durationMs: z.number().nullable(),
+		counts: z.object({
+			total: z.number(),
+			passed: z.number(),
+			failed: z.number(),
+			skipped: z.number()
 		}),
-		error: z$1.object({
-			message: z$1.string(),
-			stack: z$1.string().optional()
+		error: z.object({
+			message: z.string(),
+			stack: z.string().optional()
 		}).nullable(),
-		traces: z$1.array(SerializedTraceSchema),
-		children: z$1.array(TestCaseResultSchema)
+		traces: z.array(SerializedTraceSchema),
+		children: z.array(TestCaseResultSchema)
 	}));
-	TestEventSchema = z$1.object({
-		snapshot: z$1.object({
-			schemaVersion: z$1.number(),
-			serverTime: z$1.string(),
-			status: z$1.object({
-				ready: z$1.boolean(),
-				running: z$1.boolean(),
-				lastRunAt: z$1.string().nullable()
+	RunResultSchema = 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(TestCaseResultSchema)
+	});
+	RunRequestSchema = z.object({
+		files: z.array(z.string()).optional(),
+		pattern: z.string().optional()
+	});
+	TestEventSchema = z.object({
+		snapshot: z.object({
+			schemaVersion: z.number(),
+			serverTime: z.string(),
+			status: z.object({
+				ready: z.boolean(),
+				running: z.boolean(),
+				lastRunAt: z.string().nullable(),
+				sseAvailable: z.boolean()
 			})
 		}),
-		runQueued: z$1.object({
-			schemaVersion: z$1.number(),
-			runId: z$1.string(),
-			queuedAt: z$1.string(),
-			request: z$1.object({
-				files: z$1.array(z$1.string()).optional(),
-				pattern: z$1.string().optional()
+		runQueued: z.object({
+			schemaVersion: z.number(),
+			runId: z.string(),
+			queuedAt: z.string(),
+			request: z.object({
+				files: z.array(z.string()).optional(),
+				pattern: z.string().optional()
 			})
 		}),
-		runStarted: z$1.object({
-			schemaVersion: z$1.number(),
-			runId: z$1.string(),
-			startedAt: z$1.string()
+		runStarted: z.object({
+			schemaVersion: z.number(),
+			runId: z.string(),
+			startedAt: z.string()
 		}),
-		runCompleted: z$1.object({
-			schemaVersion: z$1.number(),
-			runId: z$1.string(),
-			startedAt: z$1.string(),
-			finishedAt: z$1.string(),
-			result: z$1.record(z$1.string(), z$1.unknown())
+		runCompleted: z.object({
+			schemaVersion: z.number(),
+			runId: z.string(),
+			startedAt: z.string(),
+			finishedAt: z.string(),
+			result: RunResultSchema
 		}),
-		runErrored: z$1.object({
-			schemaVersion: z$1.number(),
-			runId: z$1.string(),
-			finishedAt: z$1.string(),
-			error: z$1.object({
-				message: z$1.string(),
-				stack: z$1.string().optional()
+		runErrored: z.object({
+			schemaVersion: z.number(),
+			runId: z.string(),
+			finishedAt: z.string(),
+			error: z.object({
+				message: z.string(),
+				stack: z.string().optional()
 			})
 		}),
-		runNodeProgress: z$1.object({
-			schemaVersion: z$1.literal(1),
-			runId: z$1.string(),
-			startedAt: z$1.string(),
-			at: z$1.string(),
-			kind: z$1.enum([
+		runNodeProgress: z.object({
+			schemaVersion: z.literal(1),
+			runId: z.string(),
+			startedAt: z.string(),
+			at: z.string(),
+			kind: z.enum([
 				"file",
 				"suite",
 				"test"
 			]),
-			phase: z$1.enum(["ready", "result"]),
-			fileId: z$1.string(),
-			nodeId: z$1.string(),
-			parentId: z$1.string().nullable(),
+			phase: z.enum(["ready", "result"]),
+			fileId: z.string(),
+			nodeId: z.string(),
+			parentId: z.string().nullable(),
 			node: TestCaseResultSchema
 		}),
-		heartbeat: z$1.object({
-			schemaVersion: z$1.number(),
-			at: z$1.string()
+		heartbeat: z.object({
+			schemaVersion: z.number(),
+			at: z.string()
 		})
 	});
+	TestEventNameSchema = z.enum([
+		"snapshot",
+		"runQueued",
+		"runStarted",
+		"runCompleted",
+		"runErrored",
+		"runNodeProgress",
+		"heartbeat"
+	]);
 }))();
 export { registerDevTestRoutes };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dev-test-routes.js","names":["z"],"sources":["../../src/testing/dev-test-routes.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\n\nimport { type FastifyInstance } from \"fastify\";\nimport { z } from \"zod\";\n\nimport { type SonamuDevRunnerConfig } from \"../api/config\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type SerializedTrace } from \"../naite/naite\";\nimport { createSSEFactory } from \"../stream/sse\";\nimport { type SSEConnection } from \"../stream/sse\";\nimport { type ManagerStatus, type RunResult, type TestCaseResult } from \"./dev-vitest-manager\";\nimport { DevVitestManager } from \"./dev-vitest-manager\";\n\nconst SCHEMA_VERSION = 1;\nconst HEARTBEAT_INTERVAL_MS = 30_000;\n\nconst SerializedTraceSchema = z.object({\n  key: z.string(),\n  value: z.unknown(),\n  filePath: z.string(),\n  lineNumber: z.number(),\n  at: z.string(),\n});\n\nconst TestCaseResultSchema: z.ZodType<TestCaseResult> = z.lazy(() =>\n  z.object({\n    id: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    name: z.string(),\n    fullName: z.string(),\n    file: z.string(),\n    state: z.enum([\"passed\", \"failed\", \"skipped\", \"todo\", \"running\", \"unknown\"]),\n    durationMs: z.number().nullable(),\n    counts: z.object({\n      total: z.number(),\n      passed: z.number(),\n      failed: z.number(),\n      skipped: z.number(),\n    }),\n    error: z\n      .object({\n        message: z.string(),\n        stack: z.string().optional(),\n      })\n      .nullable(),\n    traces: z.array(SerializedTraceSchema),\n    children: z.array(TestCaseResultSchema),\n  }),\n);\n\nconst TestEventSchema = z.object({\n  snapshot: z.object({\n    schemaVersion: z.number(),\n    serverTime: z.string(),\n    status: z.object({\n      ready: z.boolean(),\n      running: z.boolean(),\n      lastRunAt: z.string().nullable(),\n    }),\n  }),\n  runQueued: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    queuedAt: z.string(),\n    request: z.object({\n      files: z.array(z.string()).optional(),\n      pattern: z.string().optional(),\n    }),\n  }),\n  runStarted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n  }),\n  runCompleted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n    finishedAt: z.string(),\n    result: z.record(z.string(), z.unknown()),\n  }),\n  runErrored: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    finishedAt: z.string(),\n    error: z.object({\n      message: z.string(),\n      stack: z.string().optional(),\n    }),\n  }),\n  runNodeProgress: z.object({\n    schemaVersion: z.literal(1),\n    runId: z.string(),\n    startedAt: z.string(),\n    at: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    phase: z.enum([\"ready\", \"result\"]),\n    fileId: z.string(),\n    nodeId: z.string(),\n    parentId: z.string().nullable(),\n    node: TestCaseResultSchema,\n  }),\n  heartbeat: z.object({\n    schemaVersion: z.number(),\n    at: z.string(),\n  }),\n});\n\ntype TestEvents = z.infer<typeof TestEventSchema>;\n\nfunction toPathPrefix(basePath: string): string {\n  return basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\nfunction relativizeTrace(trace: SerializedTrace, prefix: string): SerializedTrace {\n  return { ...trace, filePath: trace.filePath.replace(prefix, \"\") };\n}\n\nfunction relativizeNode(node: TestCaseResult, basePath: string): TestCaseResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...node,\n    name: node.name.replace(prefix, \"\"),\n    file: node.file.replace(prefix, \"\"),\n    traces: node.traces.map((t) => relativizeTrace(t, prefix)),\n    children: node.children.map((c) => relativizeNode(c, prefix)),\n  };\n}\n\nfunction isRunNodeProgressData(data: unknown): data is TestEvents[\"runNodeProgress\"] {\n  if (typeof data !== \"object\" || data === null) return false;\n  const d = data as Record<string, unknown>;\n  return (\n    d.schemaVersion === 1 &&\n    typeof d.runId === \"string\" &&\n    typeof d.startedAt === \"string\" &&\n    typeof d.at === \"string\" &&\n    (d.kind === \"file\" || d.kind === \"suite\" || d.kind === \"test\") &&\n    (d.phase === \"ready\" || d.phase === \"result\") &&\n    typeof d.fileId === \"string\" &&\n    typeof d.nodeId === \"string\" &&\n    (d.parentId === null || typeof d.parentId === \"string\") &&\n    typeof d.node === \"object\" &&\n    d.node !== null\n  );\n}\n\nfunction relativizeResult(result: RunResult, basePath: string): RunResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...result,\n    results: result.results.map((n) => relativizeNode(n, prefix)),\n  };\n}\n\nexport async function registerDevTestRoutes(\n  server: FastifyInstance,\n  config: SonamuDevRunnerConfig,\n): Promise<void> {\n  const prefix = config.routePrefix ?? \"/__test__\";\n\n  const manager = new DevVitestManager();\n  await manager.start(config.vitestConfigPath);\n  Sonamu.devVitestManager = manager;\n\n  const sseAvailable = !!Sonamu.config.server.plugins?.sse;\n\n  if (sseAvailable) {\n    server.get(`${prefix}/events`, (request, reply): void => {\n      const sse: SSEConnection<typeof TestEventSchema> = createSSEFactory(\n        request.socket,\n        reply,\n        TestEventSchema,\n      );\n\n      const status: ManagerStatus = manager.getStatus();\n      sse.publish(\"snapshot\", {\n        schemaVersion: SCHEMA_VERSION,\n        serverTime: new Date().toISOString(),\n        status,\n      });\n\n      const heartbeatTimer = setInterval(() => {\n        sse.publish(\"heartbeat\", {\n          schemaVersion: SCHEMA_VERSION,\n          at: new Date().toISOString(),\n        });\n      }, HEARTBEAT_INTERVAL_MS);\n\n      const basePath = Sonamu.apiRootPath;\n      const listener = (event: string, data: unknown) => {\n        const key = event as keyof TestEvents;\n        if (key === \"runNodeProgress\") {\n          if (!isRunNodeProgressData(data)) return;\n          const relativized = {\n            ...data,\n            node: relativizeNode(data.node, basePath),\n          };\n          sse.publish(key, relativized);\n          return;\n        }\n        sse.publish(key, data as TestEvents[typeof key]);\n      };\n      manager.addEventListener(listener);\n\n      let cleaned = false;\n      const cleanup = () => {\n        if (cleaned) return;\n        cleaned = true;\n        clearInterval(heartbeatTimer);\n        manager.removeEventListener(listener);\n      };\n      request.socket.on(\"close\", cleanup);\n      request.socket.on(\"error\", cleanup);\n    });\n  }\n\n  server.post(`${prefix}/run`, async (request, reply) => {\n    if (!Sonamu.devVitestManager) {\n      reply.status(503);\n      return { ok: false, error: \"DevVitestManager is not initialized\" };\n    }\n\n    const runId = randomUUID();\n    const body = request.body as { files?: string[]; pattern?: string } | null;\n    const runRequest = {\n      files: body?.files,\n      pattern: body?.pattern,\n    };\n\n    manager.emitEvent(\"runQueued\", {\n      schemaVersion: SCHEMA_VERSION,\n      runId,\n      queuedAt: new Date().toISOString(),\n      request: runRequest,\n    });\n\n    try {\n      const startedAt = new Date().toISOString();\n      manager.emitEvent(\"runStarted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n      });\n\n      const rawResult: RunResult = await Sonamu.devVitestManager.run(runRequest, runId);\n      const result = relativizeResult(rawResult, Sonamu.apiRootPath);\n\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runCompleted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n        finishedAt,\n        result,\n      });\n\n      return result;\n    } catch (err) {\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runErrored\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        finishedAt,\n        error: {\n          message: err instanceof Error ? err.message : String(err),\n          stack: err instanceof Error ? err.stack : undefined,\n        },\n      });\n\n      reply.status(500);\n      return { ok: false, error: err instanceof Error ? err.message : String(err) };\n    }\n  });\n\n  server.get(`${prefix}/status`, async () => {\n    const status: ManagerStatus = Sonamu.devVitestManager?.getStatus() ?? {\n      ready: false,\n      running: false,\n      lastRunAt: null,\n    };\n    return { ...status, sseAvailable };\n  });\n\n  server.addHook(\"onClose\", async () => {\n    await Sonamu.devVitestManager?.shutdown();\n    Sonamu.devVitestManager = null;\n  });\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dev-test-routes.js","names":[],"sources":["../../src/testing/dev-test-routes.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\n\nimport { type FastifyInstance } from \"fastify\";\nimport { z } from \"zod\";\n\nimport { type SonamuDevRunnerConfig } from \"../api/config\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { type SerializedTrace } from \"../naite/naite\";\nimport { createSSEFactory } from \"../stream/sse\";\nimport { type SSEConnection } from \"../stream/sse\";\nimport {\n  type ManagerStatus,\n  type RunResult,\n  type TestCaseResult,\n  type TestEventPayload,\n} from \"./dev-vitest-manager\";\nimport { DevVitestManager } from \"./dev-vitest-manager\";\n\nconst SCHEMA_VERSION = 1;\nconst HEARTBEAT_INTERVAL_MS = 30_000;\n\nexport type DevTestRouteManager = Pick<\n  DevVitestManager,\n  | \"start\"\n  | \"run\"\n  | \"getStatus\"\n  | \"emitEvent\"\n  | \"addEventListener\"\n  | \"removeEventListener\"\n  | \"shutdown\"\n>;\n\nexport type DevTestRouteDependencies = {\n  manager?: DevTestRouteManager;\n  apiRootPath?: string;\n  sseAvailable?: boolean;\n};\n\nconst SerializedTraceSchema = z.object({\n  key: z.string(),\n  value: z.unknown(),\n  filePath: z.string(),\n  lineNumber: z.number(),\n  at: z.string(),\n});\n\nconst TestCaseResultSchema: z.ZodType<TestCaseResult> = z.lazy(() =>\n  z.object({\n    id: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    name: z.string(),\n    fullName: z.string(),\n    file: z.string(),\n    state: z.enum([\"passed\", \"failed\", \"skipped\", \"todo\", \"running\", \"unknown\"]),\n    durationMs: z.number().nullable(),\n    counts: z.object({\n      total: z.number(),\n      passed: z.number(),\n      failed: z.number(),\n      skipped: z.number(),\n    }),\n    error: z\n      .object({\n        message: z.string(),\n        stack: z.string().optional(),\n      })\n      .nullable(),\n    traces: z.array(SerializedTraceSchema),\n    children: z.array(TestCaseResultSchema),\n  }),\n);\n\nconst RunResultSchema: z.ZodType<RunResult> = 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(TestCaseResultSchema),\n});\nconst RunRequestSchema = z.object({\n  files: z.array(z.string()).optional(),\n  pattern: z.string().optional(),\n});\n\nconst TestEventSchema = z.object({\n  snapshot: z.object({\n    schemaVersion: z.number(),\n    serverTime: z.string(),\n    status: z.object({\n      ready: z.boolean(),\n      running: z.boolean(),\n      lastRunAt: z.string().nullable(),\n      sseAvailable: z.boolean(),\n    }),\n  }),\n  runQueued: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    queuedAt: z.string(),\n    request: z.object({\n      files: z.array(z.string()).optional(),\n      pattern: z.string().optional(),\n    }),\n  }),\n  runStarted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n  }),\n  runCompleted: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    startedAt: z.string(),\n    finishedAt: z.string(),\n    result: RunResultSchema,\n  }),\n  runErrored: z.object({\n    schemaVersion: z.number(),\n    runId: z.string(),\n    finishedAt: z.string(),\n    error: z.object({\n      message: z.string(),\n      stack: z.string().optional(),\n    }),\n  }),\n  runNodeProgress: z.object({\n    schemaVersion: z.literal(1),\n    runId: z.string(),\n    startedAt: z.string(),\n    at: z.string(),\n    kind: z.enum([\"file\", \"suite\", \"test\"]),\n    phase: z.enum([\"ready\", \"result\"]),\n    fileId: z.string(),\n    nodeId: z.string(),\n    parentId: z.string().nullable(),\n    node: TestCaseResultSchema,\n  }),\n  heartbeat: z.object({\n    schemaVersion: z.number(),\n    at: z.string(),\n  }),\n});\n\ntype TestEvents = z.infer<typeof TestEventSchema>;\nconst TestEventNameSchema = z.enum([\n  \"snapshot\",\n  \"runQueued\",\n  \"runStarted\",\n  \"runCompleted\",\n  \"runErrored\",\n  \"runNodeProgress\",\n  \"heartbeat\",\n]);\n\nfunction toPathPrefix(basePath: string): string {\n  return basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\nfunction relativizeTrace(trace: SerializedTrace, prefix: string): SerializedTrace {\n  return { ...trace, filePath: trace.filePath.replace(prefix, \"\") };\n}\n\nfunction relativizeNode(node: TestCaseResult, basePath: string): TestCaseResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...node,\n    name: node.name.replace(prefix, \"\"),\n    file: node.file.replace(prefix, \"\"),\n    traces: node.traces.map((t) => relativizeTrace(t, prefix)),\n    children: node.children.map((c) => relativizeNode(c, prefix)),\n  };\n}\n\nfunction relativizeResult(result: RunResult, basePath: string): RunResult {\n  const prefix = toPathPrefix(basePath);\n  return {\n    ...result,\n    results: result.results.map((n) => relativizeNode(n, prefix)),\n  };\n}\n\nexport async function registerDevTestRoutes(\n  server: FastifyInstance,\n  config: SonamuDevRunnerConfig,\n  dependencies?: DevTestRouteDependencies,\n): Promise<void> {\n  const prefix = config.routePrefix ?? \"/__test__\";\n\n  const defaultManager = dependencies?.manager === undefined ? new DevVitestManager() : null;\n  const manager = dependencies?.manager ?? defaultManager;\n  if (manager === null) {\n    throw new Error(\"DevVitestManager dependency is unavailable\");\n  }\n  await manager.start(config.vitestConfigPath);\n  if (defaultManager !== null) {\n    Sonamu.devVitestManager = defaultManager;\n  }\n\n  const sseAvailable = dependencies?.sseAvailable ?? !!Sonamu.config.server.plugins?.sse;\n\n  if (sseAvailable) {\n    server.get(`${prefix}/events`, (request, reply): void => {\n      const sse: SSEConnection<typeof TestEventSchema> = createSSEFactory(\n        request.socket,\n        reply,\n        TestEventSchema,\n      );\n\n      const status: ManagerStatus = manager.getStatus();\n      sse.publish(\"snapshot\", {\n        schemaVersion: SCHEMA_VERSION,\n        serverTime: new Date().toISOString(),\n        // UI는 HTTP status와 같은 형태를 기대하므로 SSE 스냅샷에도 sseAvailable을 포함합니다.\n        status: { ...status, sseAvailable },\n      });\n\n      const heartbeatTimer = setInterval(() => {\n        sse.publish(\"heartbeat\", {\n          schemaVersion: SCHEMA_VERSION,\n          at: new Date().toISOString(),\n        });\n      }, HEARTBEAT_INTERVAL_MS);\n\n      const basePath = dependencies?.apiRootPath ?? Sonamu.apiRootPath;\n      const listener = (event: string, data: TestEventPayload) => {\n        const parsedKey = TestEventNameSchema.safeParse(event);\n        if (!parsedKey.success) return;\n        const key = parsedKey.data;\n        if (key === \"runNodeProgress\") {\n          const progressEnvelope = TestEventSchema.partial().safeParse({ runNodeProgress: data });\n          if (!progressEnvelope.success || progressEnvelope.data.runNodeProgress === undefined) {\n            return;\n          }\n          const progress = progressEnvelope.data.runNodeProgress;\n          const relativized = {\n            ...progress,\n            node: relativizeNode(progress.node, basePath),\n          };\n          sse.publish(key, relativized);\n          return;\n        }\n        const parsedEnvelope = TestEventSchema.partial().safeParse({ [key]: data });\n        if (!parsedEnvelope.success || parsedEnvelope.data[key] === undefined) return;\n        const parsedData = parsedEnvelope.data[key];\n        // SAFETY: key와 payload는 같은 TestEventSchema 항목으로 함께 검증되었습니다.\n        sse.publish(key, parsedData as TestEvents[typeof key]);\n      };\n      manager.addEventListener(listener);\n\n      let cleaned = false;\n      const cleanup = () => {\n        if (cleaned) return;\n        cleaned = true;\n        clearInterval(heartbeatTimer);\n        manager.removeEventListener(listener);\n      };\n      request.socket.on(\"close\", cleanup);\n      request.socket.on(\"error\", cleanup);\n    });\n  }\n\n  server.post(`${prefix}/run`, async (request, reply) => {\n    const runId = randomUUID();\n    const runRequest = RunRequestSchema.parse(request.body ?? {});\n\n    manager.emitEvent(\"runQueued\", {\n      schemaVersion: SCHEMA_VERSION,\n      runId,\n      queuedAt: new Date().toISOString(),\n      request: runRequest,\n    });\n\n    try {\n      const startedAt = new Date().toISOString();\n      manager.emitEvent(\"runStarted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n      });\n\n      const rawResult: RunResult = await manager.run(runRequest, runId);\n      const result = relativizeResult(rawResult, dependencies?.apiRootPath ?? Sonamu.apiRootPath);\n\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runCompleted\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        startedAt,\n        finishedAt,\n        result,\n      });\n\n      return result;\n    } catch (err) {\n      const finishedAt = new Date().toISOString();\n      manager.emitEvent(\"runErrored\", {\n        schemaVersion: SCHEMA_VERSION,\n        runId,\n        finishedAt,\n        error: {\n          message: err instanceof Error ? err.message : String(err),\n          stack: err instanceof Error ? err.stack : undefined,\n        },\n      });\n\n      reply.status(500);\n      return { ok: false, error: err instanceof Error ? err.message : String(err) };\n    }\n  });\n\n  server.get(`${prefix}/status`, async () => {\n    const status: ManagerStatus = manager.getStatus();\n    return { ...status, sseAvailable };\n  });\n\n  server.addHook(\"onClose\", async () => {\n    await manager.shutdown();\n    if (defaultManager !== null) {\n      Sonamu.devVitestManager = null;\n    }\n  });\n}\n"],"mappings":"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"}

package/dist/testing/dev-vitest-manager.d.ts

@@ -1,3 +1,5 @@
+import { type UserConfig as ViteUserConfig } from "vite";
+import { type CliOptions, type Vitest } from "vitest/node";
 import { type SerializedTrace } from "../naite/naite";
 export type TestNodeKind = "file" | "suite" | "test";
 export type TestState = "passed" | "failed" | "skipped" | "todo" | "running" | "unknown";
@@ -9,12 +11,7 @@ export type TestCaseResult = {
     file: string;
     state: TestState;
     durationMs: number | null;
-    counts: {
-        total: number;
-        passed: number;
-        failed: number;
-        skipped: number;
-    };
+    counts: TestCounts;
     error: {
         message: string;
         stack?: string;
@@ -22,6 +19,12 @@ export type TestCaseResult = {
     traces: SerializedTrace[];
     children: TestCaseResult[];
 };
+export type TestCounts = {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+};
 export type RunResult = {
     ok: boolean;
     summary: {
@@ -38,8 +41,50 @@ export type ManagerStatus = {
     running: boolean;
     lastRunAt: string | null;
 };
-export type TestEventListener = (event: string, data: unknown) => void;
+export type TestEventPayload = {
+    schemaVersion: number;
+    runId: string;
+    queuedAt: string;
+    request: RunRequest;
+} | {
+    schemaVersion: number;
+    runId: string;
+    startedAt: string;
+} | {
+    schemaVersion: number;
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    result: RunResult;
+} | {
+    schemaVersion: number;
+    runId: string;
+    finishedAt: string;
+    error: {
+        message: string;
+        stack?: string;
+    };
+} | {
+    schemaVersion: 1;
+    runId: string;
+    startedAt: string;
+    at: string;
+    kind: TestNodeKind;
+    phase: "ready" | "result";
+    fileId: string;
+    nodeId: string;
+    parentId: string | null;
+    node: TestCaseResult;
+};
+export type RunRequest = {
+    files?: string[];
+    pattern?: string;
+};
+export type TestEventListener = (event: string, data: TestEventPayload) => void;
+export type ManagedVitest = Pick<Vitest, "standalone" | "close" | "onFilterWatchedSpecification" | "invalidateFile" | "globTestSpecifications" | "runTestSpecifications" | "setGlobalTestNamePattern" | "resetGlobalTestNamePattern">;
+export type DevVitestFactory = (mode: "test", options: CliOptions, viteOverrides: ViteUserConfig) => Promise<ManagedVitest>;
 export declare class DevVitestManager {
+    private readonly vitestFactory?;
     private vitest;
     private running;
     private lastRunAt;
@@ -48,9 +93,10 @@ export declare class DevVitestManager {
     private closed;
     private eventListeners;
     private currentRunContext;
+    constructor(vitestFactory?: DevVitestFactory | undefined);
     addEventListener(listener: TestEventListener): void;
     removeEventListener(listener: TestEventListener): void;
-    emitEvent(event: string, data: unknown): void;
+    emitEvent(event: string, data: TestEventPayload): void;
     start(vitestConfigPath?: string): Promise<void>;
     run(opts: {
         files?: string[];

package/dist/testing/dev-vitest-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dev-vitest-manager.d.ts","sourceRoot":"","sources":["../../src/testing/dev-vitest-manager.ts"],"names":[],"mappings":"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"}