sonamu 0.8.26 → 0.9.0

package/dist/testing/global-setup.js

@@ -1,54 +1,58 @@
-import { loadConfig } from "../api/config.js";
+import { init_config, loadConfig } from "../api/config.js";
 import { ParallelDBManager } from "./parallel-db-manager.js";
+
+//#region src/testing/global-setup.ts
+init_config();
 /**
- * vitest globalSetup 함수를 생성합니다.
- * sonamu.config.ts의 test 설정을 읽어서 병렬 테스트 환경을 구성합니다.
- *
- * @example
- * ```typescript
- * // src/testing/global.ts
- * export { setup } from "sonamu/test";
- * ```
- *
- * @example
- * ```typescript
- * // src/testing/global.ts
- * import { createGlobalSetup } from "sonamu/test";
- * export const setup = createGlobalSetup({ rootPath: process.cwd() });
- * ```
- */ export function createGlobalSetup() {
-    return async function setup() {
-        const { findApiRootPath } = await import("../utils/utils.js");
-        const rootPath = findApiRootPath();
-        const config = await loadConfig(rootPath);
-        // 병렬 테스트가 비활성화된 경우 아무것도 하지 않음
-        if (!config.test?.parallel) {
-            return async function teardown() {
-            // no-op
-            };
-        }
-        const maxWorkers = config.test.maxWorkers ?? 4;
-        const templateDb = `${config.database.name}_test`;
-        const connectionConfig = {
-            client: config.database.database ?? "pg",
-            connection: config.database.environments?.test?.connection ?? config.database.defaultOptions.connection
-        };
-        const manager = new ParallelDBManager(maxWorkers, connectionConfig, templateDb);
-        await manager.createWorkerDatabases();
-        return async function teardown() {
-            await manager.dropWorkerDatabases();
-        };
-    };
+* vitest globalSetup 함수를 생성합니다.
+* sonamu.config.ts의 test 설정을 읽어서 병렬 테스트 환경을 구성합니다.
+*
+* @example
+* ```typescript
+* // src/testing/global.ts
+* export { setup } from "sonamu/test";
+* ```
+*
+* @example
+* ```typescript
+* // src/testing/global.ts
+* import { createGlobalSetup } from "sonamu/test";
+* export const setup = createGlobalSetup({ rootPath: process.cwd() });
+* ```
+*/
+function createGlobalSetup() {
+	return async function setup$1() {
+		const { findApiRootPath } = await import("../utils/utils.js");
+		const rootPath = findApiRootPath();
+		const config = await loadConfig(rootPath);
+		if (!config.test?.parallel) {
+			return async function teardown() {};
+		}
+		const maxWorkers = config.test.maxWorkers ?? 4;
+		const templateDb = `${config.database.name}_test`;
+		const connectionConfig = {
+			client: config.database.database ?? "pg",
+			connection: config.database.environments?.test?.connection ?? config.database.defaultOptions.connection
+		};
+		const manager = new ParallelDBManager(maxWorkers, connectionConfig, templateDb);
+		await manager.createWorkerDatabases();
+		return async function teardown() {
+			await manager.dropWorkerDatabases();
+		};
+	};
 }
 /**
- * 기본 globalSetup 함수입니다.
- * sonamu.config.ts의 test 설정을 읽어서 병렬 테스트 환경을 구성합니다.
- *
- * @example
- * ```typescript
- * // src/testing/global.ts
- * export { setup } from "sonamu/test";
- * ```
- */ export const setup = createGlobalSetup();
+* 기본 globalSetup 함수입니다.
+* sonamu.config.ts의 test 설정을 읽어서 병렬 테스트 환경을 구성합니다.
+*
+* @example
+* ```typescript
+* // src/testing/global.ts
+* export { setup } from "sonamu/test";
+* ```
+*/
+const setup = createGlobalSetup();
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { createGlobalSetup, setup };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/testing/index.js

@@ -1,12 +1,20 @@
-export * from "./bootstrap.js";
-export * from "./data-explorer.js";
-export * from "./dev-vitest-manager.js";
-export * from "./fixture-generator.js";
-export * from "./fixture-loader.js";
-export * from "./fixture-manager.js";
-export * from "./global-setup.js";
-export * from "./naite-vitest-reporter.js";
-export * from "./parallel-db-manager.js";
-export * from "./vitest-helpers.js";
+import { FixtureManager, FixtureManagerClass, init_fixture_manager } from "./fixture-manager.js";
+import { DataExplorer, init_data_explorer } from "./data-explorer.js";
+import { FixtureGenerator, init_fixture_generator } from "./fixture-generator.js";
+import { bootstrap, runWithContext, runWithMockContext, test, testAs } from "./bootstrap.js";
+import { DevVitestManager, init_dev_vitest_manager } from "./dev-vitest-manager.js";
+import { createFixtureLoader } from "./fixture-loader.js";
+import { ParallelDBManager } from "./parallel-db-manager.js";
+import { createGlobalSetup, setup } from "./global-setup.js";
+import { NaiteVitestReporter } from "./naite-vitest-reporter.js";
+import { getSonamuTestConfig } from "./vitest-helpers.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2Jvb3RzdHJhcFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGF0YS1leHBsb3JlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGV2LXZpdGVzdC1tYW5hZ2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maXh0dXJlLWdlbmVyYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZml4dHVyZS1sb2FkZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpeHR1cmUtbWFuYWdlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZ2xvYmFsLXNldHVwXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uYWl0ZS12aXRlc3QtcmVwb3J0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BhcmFsbGVsLWRiLW1hbmFnZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZpdGVzdC1oZWxwZXJzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBYztBQUM1QixjQUFjLHFCQUFrQjtBQUNoQyxjQUFjLDBCQUF1QjtBQUNyQyxjQUFjLHlCQUFzQjtBQUNwQyxjQUFjLHNCQUFtQjtBQUNqQyxjQUFjLHVCQUFvQjtBQUNsQyxjQUFjLG9CQUFpQjtBQUMvQixjQUFjLDZCQUEwQjtBQUN4QyxjQUFjLDJCQUF3QjtBQUN0QyxjQUFjLHNCQUFtQiJ9
+//#region src/testing/index.ts
+init_data_explorer();
+init_dev_vitest_manager();
+init_fixture_generator();
+init_fixture_manager();
+
+//#endregion
+export { DataExplorer, DevVitestManager, FixtureGenerator, FixtureManager, FixtureManagerClass, NaiteVitestReporter, ParallelDBManager, bootstrap, createFixtureLoader, createGlobalSetup, getSonamuTestConfig, runWithContext, runWithMockContext, setup, test, testAs };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYm9vdHN0cmFwXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRhLWV4cGxvcmVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXYtdml0ZXN0LW1hbmFnZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpeHR1cmUtZ2VuZXJhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maXh0dXJlLWxvYWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZml4dHVyZS1tYW5hZ2VyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9nbG9iYWwtc2V0dXBcIjtcbmV4cG9ydCAqIGZyb20gXCIuL25haXRlLXZpdGVzdC1yZXBvcnRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGFyYWxsZWwtZGItbWFuYWdlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdml0ZXN0LWhlbHBlcnNcIjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/dist/testing/naite-vitest-reporter.js

@@ -1,17 +1,22 @@
 import { NaiteReporter } from "../naite/naite-reporter.js";
+
+//#region src/testing/naite-vitest-reporter.ts
 /**
- * Naite Vitest Reporter
- *
- * 테스트 런 시작/종료를 정확히 감지하여 NaiteReporter에 알립니다.
- * - onTestRunStart: 테스트 런 시작 시 (첫 실행 및 watch 재실행 포함)
- * - onTestRunEnd: 각 런 종료 시
- */ export const NaiteVitestReporter = {
-    async onTestRunStart () {
-        await NaiteReporter.startTestRun();
-    },
-    async onTestRunEnd () {
-        await NaiteReporter.endTestRun();
-    }
+* Naite Vitest Reporter
+*
+* 테스트 런 시작/종료를 정확히 감지하여 NaiteReporter에 알립니다.
+* - onTestRunStart: 테스트 런 시작 시 (첫 실행 및 watch 재실행 포함)
+* - onTestRunEnd: 각 런 종료 시
+*/
+const NaiteVitestReporter = {
+	async onTestRunStart() {
+		await NaiteReporter.startTestRun();
+	},
+	async onTestRunEnd() {
+		await NaiteReporter.endTestRun();
+	}
 };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL25haXRlLXZpdGVzdC1yZXBvcnRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOYWl0ZVJlcG9ydGVyIH0gZnJvbSBcIi4uL25haXRlL25haXRlLXJlcG9ydGVyXCI7XG5cbi8qKlxuICogTmFpdGUgVml0ZXN0IFJlcG9ydGVyXG4gKlxuICog7YWM7Iqk7Yq4IOufsCDsi5zsnpEv7KKF66OM66W8IOygle2Zle2eiCDqsJDsp4DtlZjsl6wgTmFpdGVSZXBvcnRlcuyXkCDslYzrpr3ri4jri6QuXG4gKiAtIG9uVGVzdFJ1blN0YXJ0OiDthYzsiqTtirgg65+wIOyLnOyekSDsi5wgKOyyqyDsi6Ttlokg67CPIHdhdGNoIOyerOyLpO2WiSDtj6ztlagpXG4gKiAtIG9uVGVzdFJ1bkVuZDog6rCBIOufsCDsooXro4wg7IucXG4gKi9cbmV4cG9ydCBjb25zdCBOYWl0ZVZpdGVzdFJlcG9ydGVyID0ge1xuICBhc3luYyBvblRlc3RSdW5TdGFydCgpIHtcbiAgICBhd2FpdCBOYWl0ZVJlcG9ydGVyLnN0YXJ0VGVzdFJ1bigpO1xuICB9LFxuXG4gIGFzeW5jIG9uVGVzdFJ1bkVuZCgpIHtcbiAgICBhd2FpdCBOYWl0ZVJlcG9ydGVyLmVuZFRlc3RSdW4oKTtcbiAgfSxcbn07XG4iXSwibmFtZXMiOlsiTmFpdGVSZXBvcnRlciIsIk5haXRlVml0ZXN0UmVwb3J0ZXIiLCJvblRlc3RSdW5TdGFydCIsInN0YXJ0VGVzdFJ1biIsIm9uVGVzdFJ1bkVuZCIsImVuZFRlc3RSdW4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGFBQWEsUUFBUSw2QkFBMEI7QUFFeEQ7Ozs7OztDQU1DLEdBQ0QsT0FBTyxNQUFNQyxzQkFBc0I7SUFDakMsTUFBTUM7UUFDSixNQUFNRixjQUFjRyxZQUFZO0lBQ2xDO0lBRUEsTUFBTUM7UUFDSixNQUFNSixjQUFjSyxVQUFVO0lBQ2hDO0FBQ0YsRUFBRSJ9
+//#endregion
+export { NaiteVitestReporter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFpdGUtdml0ZXN0LXJlcG9ydGVyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL25haXRlLXZpdGVzdC1yZXBvcnRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOYWl0ZVJlcG9ydGVyIH0gZnJvbSBcIi4uL25haXRlL25haXRlLXJlcG9ydGVyXCI7XG5cbi8qKlxuICogTmFpdGUgVml0ZXN0IFJlcG9ydGVyXG4gKlxuICog7YWM7Iqk7Yq4IOufsCDsi5zsnpEv7KKF66OM66W8IOygle2Zle2eiCDqsJDsp4DtlZjsl6wgTmFpdGVSZXBvcnRlcuyXkCDslYzrpr3ri4jri6QuXG4gKiAtIG9uVGVzdFJ1blN0YXJ0OiDthYzsiqTtirgg65+wIOyLnOyekSDsi5wgKOyyqyDsi6Ttlokg67CPIHdhdGNoIOyerOyLpO2WiSDtj6ztlagpXG4gKiAtIG9uVGVzdFJ1bkVuZDog6rCBIOufsCDsooXro4wg7IucXG4gKi9cbmV4cG9ydCBjb25zdCBOYWl0ZVZpdGVzdFJlcG9ydGVyID0ge1xuICBhc3luYyBvblRlc3RSdW5TdGFydCgpIHtcbiAgICBhd2FpdCBOYWl0ZVJlcG9ydGVyLnN0YXJ0VGVzdFJ1bigpO1xuICB9LFxuXG4gIGFzeW5jIG9uVGVzdFJ1bkVuZCgpIHtcbiAgICBhd2FpdCBOYWl0ZVJlcG9ydGVyLmVuZFRlc3RSdW4oKTtcbiAgfSxcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFTQSxNQUFhLHNCQUFzQjtDQUNqQyxNQUFNLGlCQUFpQjtBQUNyQixRQUFNLGNBQWMsY0FBYzs7Q0FHcEMsTUFBTSxlQUFlO0FBQ25CLFFBQU0sY0FBYyxZQUFZOztDQUVuQyJ9

package/dist/testing/parallel-db-manager.d.ts

@@ -1,4 +1,4 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
 /**
  * 병렬 테스트를 위한 Worker별 DB 관리 클래스입니다.
  *

package/dist/testing/parallel-db-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallel-db-manager.d.ts","sourceRoot":"","sources":["../../src/testing/parallel-db-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC;;;;;GAKG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAFV,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,IAAI,CAAC,MAAM,EACrB,UAAU,EAAE,MAAM;IAErC;;;OAGG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IA6C5C;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC1C;;;OAGG;IACH,WAAW,IAAI,MAAM;IAKrB;;OAEG;IACH,cAAc,IAAI,OAAO;CAG1B"}
+{"version":3,"file":"parallel-db-manager.d.ts","sourceRoot":"","sources":["../../src/testing/parallel-db-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAIjC;;;;;GAKG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAFV,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,IAAI,CAAC,MAAM,EACrB,UAAU,EAAE,MAAM;IAErC;;;OAGG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IA6C5C;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC1C;;;OAGG;IACH,WAAW,IAAI,MAAM;IAKrB;;OAEG;IACH,cAAc,IAAI,OAAO;CAG1B"}

package/dist/testing/parallel-db-manager.js

@@ -1,88 +1,73 @@
-import { createKnexInstance } from "../database/knex.js";
+import { createKnexInstance, init_knex } from "../database/knex.js";
+
+//#region src/testing/parallel-db-manager.ts
+init_knex();
 /**
- * 병렬 테스트를 위한 Worker별 DB 관리 클래스입니다.
- *
- * Vitest의 globalSetup/globalTeardown에서 사용하여
- * 템플릿 DB에서 worker 수만큼 테스트 DB를 복제/삭제합니다.
- */ export class ParallelDBManager {
-    maxWorkers;
-    dbConfig;
-    templateDb;
-    constructor(maxWorkers, dbConfig, templateDb){
-        this.maxWorkers = maxWorkers;
-        this.dbConfig = dbConfig;
-        this.templateDb = templateDb;
-    }
-    /**
-   * Worker별 테스트 DB를 템플릿에서 복제하여 생성합니다.
-   * globalSetup에서 호출됩니다.
-   */ async createWorkerDatabases() {
-        // postgres DB에 연결하여 CREATE DATABASE 실행
-        const adminDb = createKnexInstance({
-            ...this.dbConfig
-        });
-        try {
-            const workerDbNames = Array.from({
-                length: this.maxWorkers
-            }, (_, i)=>`${this.templateDb}_${i + 1}`);
-            // 1. 기존 연결 종료 (병렬) worker DB + template DB (PG 18에서 FILE_COPY 시 template에 exclusive access 필요)
-            await Promise.all([
-                ...workerDbNames,
-                this.templateDb
-            ].map((dbName)=>adminDb.raw(`
+* 병렬 테스트를 위한 Worker별 DB 관리 클래스입니다.
+*
+* Vitest의 globalSetup/globalTeardown에서 사용하여
+* 템플릿 DB에서 worker 수만큼 테스트 DB를 복제/삭제합니다.
+*/
+var ParallelDBManager = class {
+	constructor(maxWorkers, dbConfig, templateDb) {
+		this.maxWorkers = maxWorkers;
+		this.dbConfig = dbConfig;
+		this.templateDb = templateDb;
+	}
+	/**
+	* Worker별 테스트 DB를 템플릿에서 복제하여 생성합니다.
+	* globalSetup에서 호출됩니다.
+	*/
+	async createWorkerDatabases() {
+		const adminDb = createKnexInstance({ ...this.dbConfig });
+		try {
+			const workerDbNames = Array.from({ length: this.maxWorkers }, (_, i) => `${this.templateDb}_${i + 1}`);
+			await Promise.all([...workerDbNames, this.templateDb].map((dbName) => adminDb.raw(`
             SELECT pg_terminate_backend(pg_stat_activity.pid)
             FROM pg_stat_activity
             WHERE pg_stat_activity.datname = ?
             AND pid <> pg_backend_pid()
-          `, [
-                    dbName
-                ])));
-            // 2. 기존 DB 삭제 (병렬)
-            await Promise.all(workerDbNames.map((dbName)=>adminDb.raw(`DROP DATABASE IF EXISTS "${dbName}"`)));
-            // 3. 템플릿에서 복제 (병렬)
-            await Promise.all(workerDbNames.map((dbName)=>adminDb.raw(`CREATE DATABASE "${dbName}" TEMPLATE "${this.templateDb}" STRATEGY FILE_COPY`)));
-        } finally{
-            await adminDb.destroy();
-        }
-    }
-    /**
-   * 생성한 Worker DB들을 삭제합니다.
-   * globalTeardown에서 호출됩니다.
-   */ async dropWorkerDatabases() {
-        const adminDb = createKnexInstance({
-            ...this.dbConfig
-        });
-        try {
-            const workerDbNames = Array.from({
-                length: this.maxWorkers
-            }, (_, i)=>`${this.templateDb}_${i + 1}`);
-            // 연결 종료 (병렬)
-            await Promise.all(workerDbNames.map((dbName)=>adminDb.raw(`
+          `, [dbName])));
+			await Promise.all(workerDbNames.map((dbName) => adminDb.raw(`DROP DATABASE IF EXISTS "${dbName}"`)));
+			await Promise.all(workerDbNames.map((dbName) => adminDb.raw(`CREATE DATABASE "${dbName}" TEMPLATE "${this.templateDb}" STRATEGY FILE_COPY`)));
+		} finally {
+			await adminDb.destroy();
+		}
+	}
+	/**
+	* 생성한 Worker DB들을 삭제합니다.
+	* globalTeardown에서 호출됩니다.
+	*/
+	async dropWorkerDatabases() {
+		const adminDb = createKnexInstance({ ...this.dbConfig });
+		try {
+			const workerDbNames = Array.from({ length: this.maxWorkers }, (_, i) => `${this.templateDb}_${i + 1}`);
+			await Promise.all(workerDbNames.map((dbName) => adminDb.raw(`
             SELECT pg_terminate_backend(pg_stat_activity.pid)
             FROM pg_stat_activity
             WHERE pg_stat_activity.datname = ?
             AND pid <> pg_backend_pid()
-          `, [
-                    dbName
-                ])));
-            // DB 삭제 (병렬)
-            await Promise.all(workerDbNames.map((dbName)=>adminDb.raw(`DROP DATABASE IF EXISTS "${dbName}"`)));
-        } finally{
-            await adminDb.destroy();
-        }
-    }
-    /**
-   * 현재 Worker의 ID를 반환합니다.
-   * Vitest는 VITEST_POOL_ID 환경변수로 worker를 식별합니다.
-   */ getWorkerId() {
-        // VITEST_POOL_ID는 1부터 시작
-        return parseInt(process.env.VITEST_POOL_ID ?? "1", 10);
-    }
-    /**
-   * 병렬 테스트 모드인지 확인합니다.
-   */ isParallelMode() {
-        return process.env.SONAMU_WORKER_DB === "true";
-    }
-}
+          `, [dbName])));
+			await Promise.all(workerDbNames.map((dbName) => adminDb.raw(`DROP DATABASE IF EXISTS "${dbName}"`)));
+		} finally {
+			await adminDb.destroy();
+		}
+	}
+	/**
+	* 현재 Worker의 ID를 반환합니다.
+	* Vitest는 VITEST_POOL_ID 환경변수로 worker를 식별합니다.
+	*/
+	getWorkerId() {
+		return parseInt(process.env.VITEST_POOL_ID ?? "1", 10);
+	}
+	/**
+	* 병렬 테스트 모드인지 확인합니다.
+	*/
+	isParallelMode() {
+		return process.env.SONAMU_WORKER_DB === "true";
+	}
+};
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { ParallelDBManager };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/testing/vitest-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { ViteUserConfig } from "vitest/config";
+import { type ViteUserConfig } from "vitest/config";
 type VitestConfig = ViteUserConfig["test"];
 /**
  * sonamu.config.ts의 test 설정을 기반으로 vitest 테스트 설정을 반환합니다.

package/dist/testing/vitest-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vitest-helpers.d.ts","sourceRoot":"","sources":["../../src/testing/vitest-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,YAAY,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAoBvF"}
+{"version":3,"file":"vitest-helpers.d.ts","sourceRoot":"","sources":["../../src/testing/vitest-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,KAAK,YAAY,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAoBvF"}

package/dist/testing/vitest-helpers.js

@@ -1,36 +1,40 @@
-import { loadConfig } from "../api/config.js";
+import { init_config, loadConfig } from "../api/config.js";
+
+//#region src/testing/vitest-helpers.ts
+init_config();
 /**
- * sonamu.config.ts의 test 설정을 기반으로 vitest 테스트 설정을 반환합니다.
- *
- * @example
- * ```typescript
- * // vitest.config.ts
- * import { getSonamuTestConfig } from "sonamu/test";
- * import { defineConfig } from "vitest/config";
- *
- * export default defineConfig(async () => ({
- *   test: await getSonamuTestConfig({
- *     setupFiles: ["./src/testing/setup-mocks.ts"],
- *   }),
- * }));
- * ```
- */ export async function getSonamuTestConfig(options) {
-    const { findApiRootPath } = await import("../utils/utils.js");
-    const config = await loadConfig(findApiRootPath());
-    const isParallel = config.test?.parallel ?? false;
-    const maxWorkers = config.test?.maxWorkers ?? 4;
-    if (isParallel) {
-        return {
-            pool: "forks",
-            maxWorkers,
-            isolate: false,
-            env: {
-                SONAMU_WORKER_DB: "true"
-            },
-            ...options
-        };
-    }
-    return options;
+* sonamu.config.ts의 test 설정을 기반으로 vitest 테스트 설정을 반환합니다.
+*
+* @example
+* ```typescript
+* // vitest.config.ts
+* import { getSonamuTestConfig } from "sonamu/test";
+* import { defineConfig } from "vitest/config";
+*
+* export default defineConfig(async () => ({
+*   test: await getSonamuTestConfig({
+*     setupFiles: ["./src/testing/setup-mocks.ts"],
+*   }),
+* }));
+* ```
+*/
+async function getSonamuTestConfig(options) {
+	const { findApiRootPath } = await import("../utils/utils.js");
+	const config = await loadConfig(findApiRootPath());
+	const isParallel = config.test?.parallel ?? false;
+	const maxWorkers = config.test?.maxWorkers ?? 4;
+	if (isParallel) {
+		return {
+			pool: "forks",
+			maxWorkers,
+			isolate: false,
+			env: { SONAMU_WORKER_DB: "true" },
+			...options
+		};
+	}
+	return options;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { getSonamuTestConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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