sonamu 0.9.20 → 0.10.1

package/src/bin/__tests__/migrate-targets.test.ts

@@ -0,0 +1,28 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { getMigrateRunTargets } from "../migrate-targets";
+
+describe("getMigrateRunTargets", () => {
+  const originalEnv = { ...process.env };
+
+  afterEach(() => {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) {
+        delete process.env[key];
+      }
+    }
+    Object.assign(process.env, originalEnv);
+  });
+
+  it("includes fixture when running migrations in the test environment", () => {
+    process.env.NODE_ENV = "test";
+
+    expect(getMigrateRunTargets()).toEqual(["test", "fixture"]);
+  });
+
+  it("uses only the current environment outside test", () => {
+    process.env.NODE_ENV = "staging";
+
+    expect(getMigrateRunTargets()).toEqual(["staging"]);
+  });
+});

package/src/bin/__tests__/test-command.test.ts

@@ -1,4 +1,9 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const originalArgv = process.argv;
+const originalNodeEnv = process.env.NODE_ENV;
+const originalVitest = process.env.VITEST;
+const originalFetch = globalThis.fetch;
 
 // process.argv 파싱 로직을 검증하는 유닛 테스트
 // test-command.ts의 파싱 로직을 동일하게 구현하여 독립 검증
@@ -83,3 +88,79 @@ describe("test-command argument parsing", () => {
     expect(showTraces).toBe(true);
   });
 });
+
+describe("test-command dev server endpoint resolution", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    process.argv = [process.execPath, "sonamu", "test", "--status"];
+    process.env.NODE_ENV = "development";
+    delete process.env.VITEST;
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    process.argv = originalArgv;
+    globalThis.fetch = originalFetch;
+
+    if (originalNodeEnv === undefined) {
+      delete process.env.NODE_ENV;
+    } else {
+      process.env.NODE_ENV = originalNodeEnv;
+    }
+
+    if (originalVitest === undefined) {
+      delete process.env.VITEST;
+    } else {
+      process.env.VITEST = originalVitest;
+    }
+  });
+
+  it("status 명령은 NODE_ENV=test로 바꾸지 않고 dev server 설정의 endpoint를 호출한다", async () => {
+    const loadConfig = vi.fn(async () => {
+      expect(process.env.NODE_ENV).toBe("development");
+      expect(process.env.VITEST).toBe("true");
+      return {
+        server: {
+          listen: {
+            host: "127.0.0.1",
+            port: 4401,
+          },
+        },
+        test: {
+          devRunner: {
+            enabled: true,
+            routePrefix: "/__dev_test__",
+          },
+        },
+      };
+    });
+    const fetch = vi.fn(async () => {
+      return new Response(
+        JSON.stringify({
+          ready: true,
+          running: false,
+          lastRunAt: null,
+          sseAvailable: true,
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    });
+
+    vi.doMock("../../api/config", () => ({ loadConfig }));
+    vi.doMock("../../utils/utils", () => ({ findApiRootPath: () => "/tmp/api" }));
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    globalThis.fetch = fetch as typeof globalThis.fetch;
+
+    const { testCommand } = await import("../test-command");
+    await testCommand();
+
+    expect(loadConfig).toHaveBeenCalledWith("/tmp/api");
+    expect(fetch).toHaveBeenCalledWith("http://127.0.0.1:4401/__dev_test__/status");
+    expect(process.env.NODE_ENV).toBe("development");
+  });
+});

package/src/bin/cli.ts

@@ -1,8 +1,3 @@
-import chalk from "chalk";
-import dotenv from "dotenv";
-
-dotenv.config();
-
 import assert from "assert";
 import { execSync, spawn } from "child_process";
 import { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from "fs/promises";
@@ -11,6 +6,7 @@ import os from "os";
 import path from "path";
 import process from "process";
 
+import chalk from "chalk";
 import knex from "knex";
 import { type Knex } from "knex";
 import { tsicli } from "tsicli";
@@ -21,6 +17,7 @@ import { isValidPluginId, SUPPORTED_PLUGIN_IDS } from "../auth/plugins/entity-de
 import { type BetterAuthPluginId } from "../auth/plugins/entity-definitions";
 import { type SonamuDBConfig } from "../database/db";
 import { EntityManager } from "../entity/entity-manager";
+import { getSonamuEnvironment } from "../env";
 import { Migrator } from "../migration/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
 import {
@@ -36,6 +33,7 @@ import { findApiRootPath, findAppRootPath } from "../utils/utils";
 import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config";
 import { type BuildArtifact } from "./build-config";
 import { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from "./fixture";
+import { getMigrateRunTargets } from "./migrate-targets";
 import { testCommand } from "./test-command";
 
 let migrator: Migrator;
@@ -144,8 +142,9 @@ async function bootstrap() {
           name: "#targets",
           message: "Please input #targets",
           choices: [
-            { title: "Development", value: "development_master" },
-            { title: "Production", value: "production_master" },
+            { title: "Development", value: "development" },
+            { title: "Staging", value: "staging" },
+            { title: "Production", value: "production" },
             { title: "Fixture", value: "fixture" },
             { title: "Test", value: "test" },
           ],
@@ -284,7 +283,7 @@ function spawnApiDevServer(options?: { extraEnv?: Record<string, string> }) {
       stdio: "inherit",
       env: {
         ...process.env,
-        NODE_ENV: "development",
+        NODE_ENV: process.env.NODE_ENV ?? "development",
         HOT: "yes", // 얘가 있어야 HMR이 활성화됩니다.
         API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.
         ...options?.extraEnv,
@@ -553,15 +552,7 @@ async function migrate_apply(targets: (keyof SonamuDBConfig)[]) {
 
 async function migrate_run() {
   await setupMigrator();
-  const localHosts = ["localhost", "127.0.0.1", "0.0.0.0", "::1"];
-  const targets = Object.keys(Sonamu.dbConfig).filter((target) => {
-    const targetConfig = Sonamu.dbConfig[target as keyof SonamuDBConfig];
-    const host = (targetConfig?.connection as { host?: string })?.host ?? "localhost";
-    return localHosts.includes(host.toLowerCase());
-  });
-
-  // 로컬 데이터베이스에 대해서만 전체 마이그레이션에서 동작
-  await migrator.runAction("apply", targets as (keyof SonamuDBConfig)[]);
+  await migrator.runAction("apply", getMigrateRunTargets());
 }
 
 async function migrate_generate() {
@@ -598,7 +589,7 @@ async function migrate_status() {
 }
 
 async function fixture_init() {
-  const srcConfig = Sonamu.dbConfig.development_master;
+  const srcConfig = Sonamu.dbConfig[getSonamuEnvironment()];
   const targets = [
     {
       label: "(REMOTE) Fixture DB",

package/src/bin/fixture.ts

@@ -5,6 +5,7 @@ import { Sonamu } from "../api/sonamu";
 import { DB } from "../database/db";
 import { createKnexInstance } from "../database/knex";
 import { EntityManager } from "../entity/entity-manager";
+import { getSonamuEnvironment } from "../env";
 import { DataExplorer } from "../testing/data-explorer";
 import { type DataExplorerStrategy } from "../testing/data-explorer";
 import { FixtureGenerator } from "../testing/fixture-generator";
@@ -129,12 +130,12 @@ export async function fixtureGenCommand(options: FixtureCommandOptions) {
         const enableLLMCache = !options["no-cache"];
         const DEFAULT_PASSWORD = "Test1234!";
 
-        // 로그인 가능 경로에서는 sourceDb로 development_master 사용
+        // 로그인 가능 경로에서는 현재 환경의 읽기 DB를 sourceDb로 사용
         const sourceDb = DB.getDB("r");
         const generator = new FixtureGenerator(
           sourceDb,
           sourceDb,
-          "production_master",
+          getSonamuEnvironment(),
           EntityManager,
           { useLLM, enableLLMCache },
         );
@@ -395,8 +396,8 @@ export async function fixtureFetchCommand(options: FixtureCommandOptions) {
     const strategy: DataExplorerStrategy = options.strategy ?? "recent";
     const limit = options.limit ? Number.parseInt(options.limit, 10) : 10;
 
-    // fixture fetch: production 데이터를 fixture DB로 import합니다
-    const sourceDb = DB.getDB("r"); // production_master (또는 development_master)
+    // fixture fetch: 현재 환경 데이터를 fixture DB로 import합니다
+    const sourceDb = DB.getDB("r");
     const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
     const generator = new FixtureGenerator(sourceDb, fixtureDb, "fixture", EntityManager);
 

package/src/bin/migrate-targets.ts

@@ -0,0 +1,7 @@
+import { type SonamuDBConfig } from "../database/db";
+import { getSonamuEnvironment } from "../env";
+
+export function getMigrateRunTargets(): (keyof SonamuDBConfig)[] {
+  const environment = getSonamuEnvironment();
+  return environment === "test" ? ["test", "fixture"] : [environment];
+}

package/src/bin/test-command.ts

@@ -7,7 +7,7 @@ import { loadConfig } from "../api/config";
 import { type RunResult, type TestCaseResult } from "../testing";
 import { findApiRootPath } from "../utils/utils";
 
-async function loadTestConfig(): Promise<SonamuConfig> {
+async function loadDevServerConfig(): Promise<SonamuConfig> {
   const prevVitest = process.env.VITEST;
   process.env.VITEST = "true";
   try {
@@ -37,7 +37,7 @@ function resolveTestBaseUrl(config: SonamuConfig): {
 export async function testCommand(): Promise<void> {
   const args = process.argv.slice(3);
 
-  const config = await loadTestConfig();
+  const config = await loadDevServerConfig();
 
   // process.argv 파싱: sonamu test [file...] --pattern "이름" --traces --status
   const files: string[] = [];

package/src/database/__tests__/db.test.ts

@@ -0,0 +1,175 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { type EnvironmentSnapshots } from "../../env";
+import { DBClass } from "../db";
+
+describe("DBClass.generateDBConfig", () => {
+  const originalEnv = { ...process.env };
+  const emptySnapshots: EnvironmentSnapshots = {
+    test: {},
+    development: {},
+    staging: {},
+    production: {},
+  };
+
+  afterEach(() => {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) {
+        delete process.env[key];
+      }
+    }
+    Object.assign(process.env, originalEnv);
+  });
+
+  it("keeps defaultOptions.connection values when matching SONAMU_DB env vars are absent", () => {
+    delete process.env.SONAMU_DB_HOST;
+    delete process.env.SONAMU_DB_PORT;
+    delete process.env.SONAMU_DB_USER;
+    delete process.env.SONAMU_DB_PASSWORD;
+    delete process.env.SONAMU_DB_NAME;
+
+    const dbConfig = new DBClass().generateDBConfig(
+      {
+        database: "pg",
+        defaultOptions: {
+          connection: {
+            host: "default-host",
+            port: 15432,
+            user: "default-user",
+            password: "default-password",
+          },
+        },
+      },
+      "Miomock",
+    );
+
+    expect(dbConfig.development!.connection).toMatchObject({
+      host: "default-host",
+      port: 15432,
+      user: "default-user",
+      password: "default-password",
+      database: "miomock_development",
+    });
+  });
+
+  it("derives database names from projectName even when defaultOptions.connection.database is set", () => {
+    const dbConfig = new DBClass().generateDBConfig(
+      {
+        database: "pg",
+        defaultOptions: {
+          connection: {
+            database: "legacy_database",
+          },
+        },
+      },
+      "Miomock",
+      emptySnapshots,
+    );
+
+    expect(dbConfig.development!.connection).toMatchObject({
+      database: "miomock_development",
+    });
+    expect(dbConfig.production!.connection).toMatchObject({
+      database: "miomock_production",
+    });
+  });
+
+  it("fails fast when legacy database.name or database.environments keys are present", () => {
+    const legacyConfig = {
+      database: "pg",
+      name: "miomock",
+      environments: {
+        production: {},
+      },
+    } as Parameters<DBClass["generateDBConfig"]>[0];
+
+    expect(() => new DBClass().generateDBConfig(legacyConfig, "Miomock")).toThrow(
+      /database\.name and database\.environments were removed/,
+    );
+  });
+
+  it("lets readonly env vars override only the readonly connection fields", () => {
+    process.env.SONAMU_DB_HOST = "writer-host";
+    process.env.SONAMU_DB_USER = "writer-user";
+    process.env.SONAMU_DB_PASSWORD = "writer-password";
+    process.env.SONAMU_DB_READONLY_HOST = "readonly-host";
+
+    const dbConfig = new DBClass().generateDBConfig(
+      {
+        database: "pg",
+        defaultOptions: {
+          connection: {
+            port: 15432,
+          },
+        },
+      },
+      "Miomock",
+    );
+
+    expect(dbConfig.development_readonly!.connection).toMatchObject({
+      host: "readonly-host",
+      port: 15432,
+      user: "writer-user",
+      password: "writer-password",
+      database: "miomock_development",
+    });
+  });
+
+  it("does not let current process connection values leak into other environment snapshots", () => {
+    const dbConfig = new DBClass().generateDBConfig(
+      {
+        database: "pg",
+        defaultOptions: {
+          connection: {
+            host: "development-host",
+            port: 15432,
+            user: "development-user",
+            password: "development-password",
+            ssl: true,
+          },
+        },
+      },
+      "Miomock",
+      {
+        ...emptySnapshots,
+        staging: {
+          SONAMU_DB_HOST: "staging-host",
+        },
+      },
+    );
+
+    expect(dbConfig.staging!.connection).toMatchObject({
+      host: "staging-host",
+      port: 5432,
+      user: "postgres",
+      database: "miomock_staging",
+      ssl: true,
+    });
+    expect(dbConfig.staging!.connection).not.toMatchObject({
+      password: "development-password",
+    });
+  });
+
+  it("does not reuse SONAMU_DB_NAME as the fixture database name", () => {
+    const dbConfig = new DBClass().generateDBConfig(
+      {
+        database: "pg",
+        defaultOptions: {},
+      },
+      "Miomock",
+      {
+        ...emptySnapshots,
+        test: {
+          SONAMU_DB_NAME: "miomock_test",
+        },
+      },
+    );
+
+    expect(dbConfig.test!.connection).toMatchObject({
+      database: "miomock_test",
+    });
+    expect(dbConfig.fixture!.connection).toMatchObject({
+      database: "miomock_fixture",
+    });
+  });
+});