sonamu 0.10.13 → 0.11.0

package/src/entity/__tests__/entity-manager-explicit-root-registration.contract.test.ts

@@ -0,0 +1,107 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { Sonamu } from "../../api/sonamu";
+import { EntityManager } from "../entity-manager";
+
+const temporaryRoots: string[] = [];
+
+const POST_ENTITY_JSON = {
+  id: "Post",
+  table: "posts",
+  title: "게시글",
+  props: [
+    { name: "id", type: "integer" },
+    { name: "title", type: "string", length: 128 },
+  ],
+  indexes: [],
+  subsets: {},
+  enums: {},
+};
+
+async function createApiRootWithEntity(): Promise<string> {
+  const apiRootPath = await mkdtemp(path.join(os.tmpdir(), "sonamu-explicit-root-"));
+  temporaryRoots.push(apiRootPath);
+  const entityDirectory = path.join(apiRootPath, "src", "application", "post");
+  await mkdir(entityDirectory, { recursive: true });
+  await writeFile(
+    path.join(entityDirectory, "post.entity.json"),
+    JSON.stringify(POST_ENTITY_JSON, null, 2),
+    "utf8",
+  );
+  return apiRootPath;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
+  );
+});
+
+describe("EntityManager 명시적 API 루트 등록", () => {
+  it("Sonamu 초기화 전에도 명시한 루트의 entity.json을 등록한다", async () => {
+    const apiRootPath = await createApiRootWithEntity();
+    const previousAutoloaded = EntityManager.isAutoloaded;
+    EntityManager.isAutoloaded = false;
+
+    // 명시적 루트 경로는 Sonamu singleton 초기화 없이 동작해야 합니다.
+    expect(() => Sonamu.apiRootPath).toThrow(/init/i);
+    try {
+      await expect(EntityManager.autoload(true, apiRootPath)).resolves.toBeUndefined();
+
+      expect(EntityManager.isAutoloaded).toBe(true);
+      expect(EntityManager.exists("Post")).toBe(true);
+      expect(EntityManager.get("Post").table).toBe("posts");
+      expect(EntityManager.modulePaths.get("PostBaseSchema")).toBe("sonamu.generated");
+    } finally {
+      EntityManager.isAutoloaded = previousAutoloaded;
+    }
+  });
+
+  it("reload()는 autoload에 넘긴 명시적 루트를 그대로 다시 읽는다", async () => {
+    const apiRootPath = await createApiRootWithEntity();
+    const previousAutoloaded = EntityManager.isAutoloaded;
+    EntityManager.isAutoloaded = false;
+
+    expect(() => Sonamu.apiRootPath).toThrow(/init/i);
+    try {
+      await EntityManager.autoload(true, apiRootPath);
+      expect(EntityManager.exists("Post")).toBe(true);
+
+      // 보존한 루트를 잃으면 초기화되지 않은 Sonamu.apiRootPath로 폴백해 throw합니다.
+      await expect(EntityManager.reload(true)).resolves.toBeUndefined();
+      expect(EntityManager.exists("Post")).toBe(true);
+      expect(EntityManager.get("Post").table).toBe("posts");
+    } finally {
+      EntityManager.isAutoloaded = previousAutoloaded;
+    }
+  });
+
+  it("reload()에 넘긴 루트는 보존된 루트보다 우선한다", async () => {
+    const firstRootPath = await createApiRootWithEntity();
+    const secondRootPath = await createApiRootWithEntity();
+    // 두 번째 루트에만 존재하는 entity로 어느 루트를 읽었는지 구분합니다.
+    const commentDirectory = path.join(secondRootPath, "src", "application", "comment");
+    await mkdir(commentDirectory, { recursive: true });
+    await writeFile(
+      path.join(commentDirectory, "comment.entity.json"),
+      JSON.stringify({ ...POST_ENTITY_JSON, id: "Comment", table: "comments" }, null, 2),
+      "utf8",
+    );
+
+    const previousAutoloaded = EntityManager.isAutoloaded;
+    EntityManager.isAutoloaded = false;
+    try {
+      await EntityManager.autoload(true, firstRootPath);
+      expect(EntityManager.exists("Comment")).toBe(false);
+
+      await EntityManager.reload(true, secondRootPath);
+      expect(EntityManager.exists("Comment")).toBe(true);
+    } finally {
+      EntityManager.isAutoloaded = previousAutoloaded;
+    }
+  });
+});

package/src/entity/entity-manager.ts

@@ -48,13 +48,17 @@ class EntityManagerClass {
   public modulePaths: Map<string, string> = new Map();
   private tableSpecs: Map<string, TableSpec> = new Map();
   public isAutoloaded: boolean = false;
+  // reload()가 Sonamu 초기화 없이도 같은 루트를 다시 읽도록 명시적 api root를 보존합니다.
+  private explicitApiRootPath: string | undefined;
 
   // 경로 전달받아 모든 entity.json 파일 로드
-  async autoload(doSilent: boolean = false) {
+  async autoload(doSilent: boolean = false, explicitApiRootPath?: string) {
     if (this.isAutoloaded) {
       return;
     }
-    const pathPattern = path.join(Sonamu.apiRootPath, "/src/application/**/*.entity.json");
+    this.explicitApiRootPath = explicitApiRootPath;
+    const apiRootPath = explicitApiRootPath ?? Sonamu.apiRootPath;
+    const pathPattern = path.join(apiRootPath, "/src/application/**/*.entity.json");
 
     for await (const file of glob(path.resolve(pathPattern))) {
       const json = parseEntityJson((await readFile(file)).toString());
@@ -62,7 +66,7 @@ class EntityManagerClass {
       // entity.json 스키마 검증
       const error = this.schemaValidate(json);
       if (error) {
-        const relativePath = path.relative(Sonamu.apiRootPath, file);
+        const relativePath = path.relative(apiRootPath, file);
         const errorMessage = prettifyError(error);
         if (!doSilent) {
           console.error(
@@ -71,11 +75,14 @@ class EntityManagerClass {
         }
       }
 
-      await this.register(json, { deferSearchTextJsonSourceValidation: true });
+      await this.register(json, {
+        deferSearchTextJsonSourceValidation: true,
+        apiRootPath,
+      });
     }
 
-    await this.registerNonEntityTypeModulePaths();
-    await this.validateAllRegisteredSearchTextJsonSources();
+    await this.registerNonEntityTypeModulePaths(apiRootPath);
+    await this.validateAllRegisteredSearchTextJsonSources(apiRootPath);
 
     this.isAutoloaded = true;
   }
@@ -85,36 +92,36 @@ class EntityManagerClass {
     return result.success ? null : result.error;
   }
 
-  async reload(doSilent: boolean = false) {
+  async reload(doSilent: boolean = false, explicitApiRootPath?: string) {
     this.entities.clear();
     this.modulePaths.clear();
     this.tableSpecs.clear();
     this.isAutoloaded = false;
 
-    return await this.autoload(doSilent);
+    return await this.autoload(doSilent, explicitApiRootPath ?? this.explicitApiRootPath);
   }
 
   async register(
     json: EntityJson,
-    options: { deferSearchTextJsonSourceValidation?: boolean } = {},
+    options: { deferSearchTextJsonSourceValidation?: boolean; apiRootPath?: string } = {},
   ): Promise<void> {
     const { Entity } = await import("./entity");
     const entity = new Entity(json);
-    await entity.registerModulePaths();
+    await entity.registerModulePaths(options.apiRootPath);
     if (!options.deferSearchTextJsonSourceValidation) {
-      await this.validateSearchTextJsonSources(entity);
+      await this.validateSearchTextJsonSources(entity, options.apiRootPath);
     }
     entity.registerTableSpecs();
     this.entities.set(json.id, entity);
   }
 
-  async validateAllRegisteredSearchTextJsonSources(): Promise<void> {
+  async validateAllRegisteredSearchTextJsonSources(apiRootPath?: string): Promise<void> {
     for (const entity of this.entities.values()) {
-      await this.validateSearchTextJsonSources(entity);
+      await this.validateSearchTextJsonSources(entity, apiRootPath);
     }
   }
 
-  private async validateSearchTextJsonSources(entity: Entity): Promise<void> {
+  private async validateSearchTextJsonSources(entity: Entity, apiRootPath?: string): Promise<void> {
     const propsByName = new Map(entity.props.map((prop) => [prop.name, prop]));
 
     for (const prop of entity.props) {
@@ -128,7 +135,11 @@ class EntityManagerClass {
           continue;
         }
 
-        const zodType = await this.resolveSearchTextJsonSourceType(entity, sourceProp.id);
+        const zodType = await this.resolveSearchTextJsonSourceType(
+          entity,
+          sourceProp.id,
+          apiRootPath,
+        );
         if (!zodType) {
           throw new Error(
             `searchText source "${source.name}"의 json 타입 "${sourceProp.id}"을(를) 로드할 수 없습니다.`,
@@ -147,6 +158,7 @@ class EntityManagerClass {
   private async resolveSearchTextJsonSourceType(
     entity: Entity,
     typeId: string,
+    explicitApiRootPath?: string,
   ): Promise<z.ZodTypeAny | null> {
     const localType = entity.types[typeId];
     if (localType instanceof z.ZodType) {
@@ -173,7 +185,7 @@ class EntityManagerClass {
     }
 
     const moduleFilePath = path.join(
-      Sonamu.apiRootPath,
+      explicitApiRootPath ?? Sonamu.apiRootPath,
       runtimePath(`dist/application/${modulePath}.js`),
     );
     const importedMembers = await importMembers<unknown>(moduleFilePath);
@@ -296,10 +308,10 @@ class EntityManagerClass {
     return inflection.camelize(entityBaseName.replace(/-/g, "_"));
   }
 
-  private async registerNonEntityTypeModulePaths(): Promise<void> {
+  private async registerNonEntityTypeModulePaths(apiRootPath: string): Promise<void> {
     const typePathsPatterns = [
-      path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.types.ts")),
-      path.join(Sonamu.apiRootPath, runtimePath("src/application/**/*.generated.ts")),
+      path.join(apiRootPath, runtimePath("src/application/**/*.types.ts")),
+      path.join(apiRootPath, runtimePath("src/application/**/*.generated.ts")),
     ];
     const typePaths = (
       await Promise.all(typePathsPatterns.map((pattern) => globAsync(pattern)))

package/src/entity/entity.ts

@@ -827,7 +827,12 @@ export class Entity {
     });
   }
 
-  async registerModulePaths() {
+  /**
+   * Entity가 노출하는 타입 이름과 모듈 경로를 EntityManager에 등록합니다.
+   *
+   * @param explicitApiRootPath - Sonamu 초기화 없이 등록할 때 사용할 API 루트 경로
+   */
+  async registerModulePaths(explicitApiRootPath?: string) {
     const basePath = `${this.names.parentFs}`;
 
     // base-scheme
@@ -853,7 +858,7 @@ export class Entity {
     // types
     const typesModulePath = `${basePath}/${this.names.parentFs}.types`;
     const typesFilePath = path.join(
-      Sonamu.apiRootPath,
+      explicitApiRootPath ?? Sonamu.apiRootPath,
       runtimePath(`dist/application/${typesModulePath}.js`),
     );
 

package/src/logger/__tests__/configure.test.ts

@@ -0,0 +1,33 @@
+import { dispose, getLogger, type Config, type LogRecord } from "@logtape/logtape";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { configureLogTape } from "../configure";
+
+describe("CLI LogTape 설정 합성", () => {
+  afterEach(async () => {
+    globalThis.sonamuKitCliLogTapeOverride = undefined;
+    await dispose();
+  });
+
+  it("CLI 출력 설정과 프로젝트 카테고리 설정을 함께 유지한다", async () => {
+    const cliRecords: LogRecord[] = [];
+    const appRecords: LogRecord[] = [];
+    const cliConfig: Config<string, string> = {
+      sinks: { default: (record) => cliRecords.push(record) },
+      loggers: [{ category: [], lowestLevel: "debug", sinks: ["default"] }],
+      reset: true,
+    };
+    globalThis.sonamuKitCliLogTapeOverride = { config: cliConfig, applied: false };
+
+    await configureLogTape({
+      sinks: { default: (record) => appRecords.push(record) },
+      loggers: [{ category: ["app"], lowestLevel: "debug", sinks: ["default"] }],
+    });
+    getLogger(["cli"]).debug("CLI 로그");
+    getLogger(["app"]).debug("프로젝트 로그");
+
+    expect(globalThis.sonamuKitCliLogTapeOverride.applied).toBe(true);
+    expect(cliRecords.map((record) => record.category[0])).toEqual(["cli", "app"]);
+    expect(appRecords).toHaveLength(1);
+  });
+});

package/src/logger/configure.ts

@@ -1,5 +1,6 @@
 import { configure, getConsoleSink } from "@logtape/logtape";
 import {
+  type Config,
   type Filter,
   type FilterLike,
   type LoggerConfig,
@@ -12,6 +13,23 @@ import { type FastifyReply, type FastifyRequest } from "fastify";
 
 import { isSameCategory } from "./category";
 
+interface ExternalLogTapeConfiguration {
+  readonly config: Config<string, string>;
+  applied: boolean;
+}
+
+declare global {
+  var sonamuKitCliLogTapeOverride: ExternalLogTapeConfiguration | undefined;
+}
+
+function getExternalLogTapeConfiguration(): ExternalLogTapeConfiguration | undefined {
+  return globalThis.sonamuKitCliLogTapeOverride;
+}
+
+export function hasExternalLogTapeConfiguration(): boolean {
+  return getExternalLogTapeConfiguration() !== undefined;
+}
+
 export type SonamuLoggingOptions<TSinkId extends string, TFilterId extends string> = {
   // fastify 로깅 카테고리 (a.b.c의 형태로 넣으면 [a, b, c]로 들어갑니다.)
   // 기본값은 ["fastify"] 입니다.
@@ -107,19 +125,42 @@ function defaultFastifyFilter(fastifyCategory: readonly string[]): Filter {
 export async function configureLogTape<TSinkId extends string, TFilterId extends string>(
   options: SonamuLoggingOptions<TSinkId, TFilterId>,
 ) {
+  const external = getExternalLogTapeConfiguration();
   const fastifyCategory = options.fastifyCategory ?? ["fastify"];
 
-  const sinks = {
+  const projectSinks = {
     "fastify-console": defaultFastifySink(fastifyCategory),
     ...options.sinks,
-  };
+  } satisfies Record<string, Sink>;
+  const externalSinkIds = new Map<string, string>();
+  const externalSinks: Record<string, Sink> = {};
+  for (const [sinkId, sink] of Object.entries(external?.config.sinks ?? {})) {
+    let namespacedId = `sonamu-cli:${sinkId}`;
+    while (
+      Object.hasOwn(projectSinks, namespacedId) ||
+      Object.hasOwn(externalSinks, namespacedId)
+    ) {
+      namespacedId = `${namespacedId}-`;
+    }
+    externalSinkIds.set(sinkId, namespacedId);
+    externalSinks[namespacedId] = sink;
+  }
+  const sinks = { ...projectSinks, ...externalSinks };
 
   const filters = {
     "fastify-console": defaultFastifyFilter(fastifyCategory),
     ...options.filters,
+    ...external?.config.filters,
   };
 
-  const loggers = new Set<LoggerConfig<string, string>>(options.loggers ?? []);
+  const externalLoggers = (external?.config.loggers ?? []).map((logger) => ({
+    ...logger,
+    sinks: logger.sinks?.map((sinkId) => externalSinkIds.get(sinkId) ?? sinkId),
+  }));
+  const loggers = new Set<LoggerConfig<string, string>>([
+    ...externalLoggers,
+    ...(options.loggers ?? []),
+  ]);
 
   // logtape의 meta logger 표시를 비활성화
   loggers.add({
@@ -136,5 +177,6 @@ export async function configureLogTape<TSinkId extends string, TFilterId extends
     });
   }
 
+  if (external !== undefined) external.applied = true;
   return configure({ sinks, filters, loggers: [...loggers], reset: true });
 }

package/src/migration/__tests__/migrator.test.ts

@@ -1,3 +1,5 @@
+import { type Knex } from "knex";
+import knex from "knex";
 import { afterEach, describe, expect, it } from "vitest";
 
 import { type SonamuConfig } from "../../api/config";
@@ -89,6 +91,55 @@ describe("Migrator environment target filtering", () => {
   });
 });
 
+describe("Migrator 최신 적용 batch 조회", () => {
+  const presets: SonamuDBPreset[] = [
+    "test",
+    "fixture",
+    "development",
+    "staging",
+    "production",
+    "test_readonly",
+    "development_readonly",
+    "staging_readonly",
+    "production_readonly",
+  ];
+  const baseDbConfig =
+    /* SAFETY: 모든 Sonamu DB preset에 유효한 PostgreSQL 테스트 설정을 제공합니다. */ Object.fromEntries(
+      presets.map((preset) => [preset, { client: "postgresql", connection: { database: preset } }]),
+    ) as SonamuDBConfig;
+
+  afterEach(() => {
+    Sonamu.dbConfig = baseDbConfig;
+  });
+
+  it("PostgreSQL 42P01은 사용자 migration table 이름과 오류 문구에 관계없이 미적용 상태로 처리한다", async () => {
+    const clientTemplate = knex({ client: "pg" });
+    // SAFETY: knex({ client: "pg" })가 생성한 실제 PostgreSQL client 생성자입니다.
+    const PostgreSqlClient = clientTemplate.client.constructor as typeof Knex.Client;
+    class MissingMigrationTableClient extends PostgreSqlClient {
+      async acquireRawConnection(): Promise<never> {
+        throw Object.assign(new Error('relation "sonamu_history" does not exist'), {
+          code: "42P01",
+        });
+      }
+    }
+    await clientTemplate.destroy();
+    Sonamu.dbConfig = {
+      ...baseDbConfig,
+      development: {
+        client: MissingMigrationTableClient,
+        connection: { database: "sonamu_test" },
+        migrations: { tableName: "sonamu_history" },
+      },
+    };
+
+    await expect(new Migrator().getLatestAppliedBatch("development")).resolves.toEqual({
+      batchNo: 0,
+      files: [],
+    });
+  });
+});
+
 describe("SlackConfirm target validation", () => {
   const presets: SonamuDBPreset[] = [
     "test",

package/src/migration/migrator.ts

@@ -41,6 +41,8 @@ export type MigrationResult = {
   applied: string[];
 }[];
 
+type ShadowMigrationTarget = Extract<MigrationTarget, "fixture" | "test">;
+
 function padDatePart(number: number, size: number = 2): string {
   return number.toString().padStart(size, "0");
 }
@@ -95,13 +97,9 @@ export class Migrator {
     const maybePostgresError =
       /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ error as {
         code?: unknown;
-        message?: unknown;
       };
-    return (
-      maybePostgresError.code === "42P01" &&
-      isStringValue(maybePostgresError.message) &&
-      maybePostgresError.message.includes("knex_migrations")
-    );
+    // PostgreSQL undefined_table 코드는 사용자 지정 migration table에도 동일하게 적용됩니다.
+    return maybePostgresError.code === "42P01";
   }
 
   /** 현재 실행 환경에서 허용된 마이그레이션 대상 키를 반환합니다. */
@@ -375,6 +373,61 @@ export class Migrator {
     }
   }
 
+  /**
+   * 대상 DB에서 가장 최근에 적용된 migration batch를 반환합니다.
+   *
+   * @category 분리형 마이그레이션 API
+   */
+  async getLatestAppliedBatch(
+    connKey: MigrationTarget,
+  ): Promise<{ batchNo: number; files: string[] }> {
+    this.assertMigrationTarget(connKey);
+    const knexOptions = Sonamu.dbConfig[connKey];
+    const connection =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ knexOptions.connection as Knex.PgConnectionConfig;
+    const tConn = createKnexInstance({
+      ...knexOptions,
+      connection: {
+        ...connection,
+        connectionTimeoutMillis: MIGRATION_CONN_TIMEOUT_MS,
+      },
+      pool: {
+        ...knexOptions.pool,
+        min: 0,
+        acquireTimeoutMillis: MIGRATION_CONN_TIMEOUT_MS,
+        createTimeoutMillis: MIGRATION_CONN_TIMEOUT_MS,
+        propagateCreateError: true,
+      },
+    });
+
+    try {
+      const tableName = knexOptions.migrations?.tableName ?? "knex_migrations";
+      const schemaName = knexOptions.migrations?.schemaName;
+      const migrationsTable =
+        schemaName === undefined
+          ? tConn<{ id: number; name: string; batch: number }>(tableName)
+          : tConn<{ id: number; name: string; batch: number }>(tableName).withSchema(schemaName);
+      const latest = await migrationsTable.clone().select("batch").orderBy("batch", "desc").first();
+      if (latest === undefined) return { batchNo: 0, files: [] };
+
+      // 같은 batch 안에서는 Knex 실행 순서대로 롤백 계획을 고정한다.
+      const rows = await migrationsTable
+        .clone()
+        .select("name")
+        .where("batch", latest.batch)
+        .orderBy("id", "asc");
+      return {
+        batchNo: latest.batch,
+        files: rows.map(({ name }) => name.replace(/\.ts$/, "")),
+      };
+    } catch (caught) {
+      if (this.isMissingMigrationTableError(caught)) return { batchNo: 0, files: [] };
+      throw caught;
+    } finally {
+      await tConn.destroy();
+    }
+  }
+
   /**
    * 최신 상태인 기준 DB와 엔티티 정의를 비교해 생성 예정 코드를 반환합니다.
    *
@@ -659,15 +712,41 @@ export class Migrator {
    *
    * @category 분리형 마이그레이션 API
    */
-  async runShadowTest(options?: MigrationRunOptions): Promise<MigrationResult> {
-    const baseTestConn =
-      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Sonamu.dbConfig
-        .test.connection as Knex.PgConnectionConfig;
-    const workerId = process.env.SONAMU_WORKER_DB === "true" ? process.env.VITEST_POOL_ID : null;
+  async runShadowTest(
+    options?: MigrationRunOptions & { target?: MigrationTarget },
+  ): Promise<MigrationResult> {
+    const target = options?.target ?? "test";
+    if (target !== "test" && target !== "fixture") {
+      // 운영 계열 DB는 설정 조회나 연결 생성보다 먼저 차단한다.
+      throw Object.assign(new Error(`지원하지 않는 Shadow 마이그레이션 대상입니다: ${target}`), {
+        code: "INVALID_SHADOW_MIGRATION_TARGET",
+        target,
+      });
+    }
+    const shadowTarget: ShadowMigrationTarget = target;
+    const baseTargetConn =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Sonamu.dbConfig[
+        shadowTarget
+      ].connection as Knex.PgConnectionConfig;
+    const configuredDatabase = baseTargetConn.database;
+    if (!configuredDatabase) {
+      throw Object.assign(new Error(`Shadow 대상 DB 이름이 없습니다: ${shadowTarget}`), {
+        code: "INVALID_SHADOW_DATABASE_CONFIG",
+        target: shadowTarget,
+      });
+    }
+    const workerId =
+      shadowTarget === "test" && process.env.SONAMU_WORKER_DB === "true"
+        ? process.env.VITEST_POOL_ID
+        : null;
     const templateDatabase =
-      workerId !== null ? `${baseTestConn.database}_${workerId ?? "1"}` : baseTestConn.database;
-    const tdbConn = { ...baseTestConn, database: templateDatabase };
+      workerId !== null ? `${configuredDatabase}_${workerId ?? "1"}` : configuredDatabase;
     const shadowDatabase = `${templateDatabase}__migration_shadow`;
+    const createShadowConnection = (database: string) =>
+      createKnexInstance({
+        ...Sonamu.dbConfig[shadowTarget],
+        connection: { ...baseTargetConn, database },
+      });
 
     // 테스트 상황에서는 트랜잭션을 초기화하고, 새 데이터베이스 커넥션을 가져와야 함
     if (isTest()) {
@@ -676,33 +755,23 @@ export class Migrator {
     }
 
     // 기존 Shadow DB 삭제 후 Shadow DB 생성
-    const tdb = createKnexInstance({
-      ...Sonamu.dbConfig.test,
-      connection: {
-        ...baseTestConn,
-        database: "postgres",
-      },
-    });
+    const tdb = createShadowConnection("postgres");
     try {
       !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
-      await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
-      await tdb.raw(`
+      await tdb.raw("DROP DATABASE IF EXISTS ??", [shadowDatabase]);
+      await tdb.raw(
+        `
         SELECT pg_terminate_backend(pg_stat_activity.pid)
         FROM pg_stat_activity
-        WHERE datname = '${tdbConn.database}'
+        WHERE datname = ?
           AND pid <> pg_backend_pid();
-      `);
-      await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
+      `,
+        [templateDatabase],
+      );
+      await tdb.raw("CREATE DATABASE ?? TEMPLATE ??", [shadowDatabase, templateDatabase]);
 
       // Shadow DB에 연결
-      const sdb = createKnexInstance({
-        ...Sonamu.dbConfig.test,
-        connection: {
-          ...tdbConn,
-          database: shadowDatabase,
-          password: tdbConn.password,
-        },
-      });
+      const sdb = createShadowConnection(shadowDatabase);
 
       // shadow DB 테스트 진행
       try {
@@ -742,7 +811,7 @@ export class Migrator {
       // Shadow DB 삭제
       !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
       try {
-        await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+        await tdb.raw("DROP DATABASE IF EXISTS ??", [shadowDatabase]);
       } catch (e) {
         console.error("Shadow DB 정리 실패:", e); // 이게 없으면 조용히 누수
       } finally {

package/src/syncer/api-parser.ts

@@ -1,8 +1,8 @@
 import assert from "assert";
 import { readFile } from "fs/promises";
 
+import ts from "@typescript/typescript6";
 import inflection from "inflection";
-import ts from "typescript";
 
 import { registeredApis } from "../api/decorators";
 import { type ExtendedApi } from "../api/decorators";