@cartanova/qgrid-cli 2.4.2 → 2.4.4

package/bundle/src/migrations/20260710090000_alter_tokens_add_weight.ts

@@ -0,0 +1,38 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("tokens", (table) => {
+    table.integer("weight").notNullable().defaultTo(1);
+  });
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION public.tokens_weight_notify() RETURNS trigger
+    LANGUAGE plpgsql
+    SET search_path = pg_catalog, public
+    AS $func$
+    BEGIN
+      PERFORM pg_notify('tokens_changed', json_build_object(
+        'op', TG_OP,
+        'id', NEW.id
+      )::text);
+      RETURN NEW;
+    END;
+    $func$;
+
+    DROP TRIGGER IF EXISTS tokens_weight_changed_upd ON public.tokens;
+    CREATE TRIGGER tokens_weight_changed_upd
+    AFTER UPDATE OF weight ON public.tokens
+    FOR EACH ROW
+    WHEN (OLD.weight IS DISTINCT FROM NEW.weight)
+    EXECUTE FUNCTION public.tokens_weight_notify();
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`
+    DROP TRIGGER IF EXISTS tokens_weight_changed_upd ON public.tokens;
+    DROP FUNCTION IF EXISTS public.tokens_weight_notify();
+  `);
+  await knex.schema.alterTable("tokens", (table) => {
+    table.dropColumns("weight");
+  });
+}

package/bundle/src/server-bootstrap.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { bootstrapServer } from "./server-bootstrap";
+
+describe("server bootstrap", () => {
+  it("finishes required migrations before binding the server socket", async () => {
+    const calls: string[] = [];
+    const init = vi.fn(async () => {
+      calls.push("init");
+    });
+    const migrate = vi.fn(async () => {
+      calls.push("migrate");
+    });
+    const listen = vi.fn(async () => {
+      calls.push("listen");
+    });
+
+    await bootstrapServer({ init, migrate, listen });
+
+    expect(calls).toEqual(["init", "migrate", "listen"]);
+  });
+
+  it("does not bind the socket when a required migration fails", async () => {
+    const failure = new Error("migration failed");
+    const listen = vi.fn();
+
+    await expect(
+      bootstrapServer({
+        init: vi.fn(async () => {}),
+        migrate: vi.fn(async () => {
+          throw failure;
+        }),
+        listen,
+      }),
+    ).rejects.toBe(failure);
+
+    expect(listen).not.toHaveBeenCalled();
+  });
+});

package/bundle/src/server-bootstrap.ts

@@ -0,0 +1,21 @@
+import { Sonamu } from "sonamu";
+
+import { runRequiredMigrations } from "./startup-migrations";
+
+type BootstrapSteps = {
+  init: () => Promise<void>;
+  migrate: () => Promise<void>;
+  listen: () => Promise<unknown>;
+};
+
+export async function bootstrapServer(
+  steps: BootstrapSteps = {
+    init: () => Sonamu.init(),
+    migrate: runRequiredMigrations,
+    listen: () => Sonamu.createServer(),
+  },
+): Promise<void> {
+  await steps.init();
+  await steps.migrate();
+  await steps.listen();
+}

package/bundle/src/sonamu.config.ts

@@ -11,7 +11,6 @@ import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher";
 import { QgridFrame } from "./application/qgrid/qgrid.frame";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup";
-import { TokenModel } from "./application/token/token.model";
 import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher";
 import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher";
 
@@ -94,6 +93,9 @@ export default defineConfig({
   },
   server: {
     listen: { port, host },
+    fastify: {
+      bodyLimit: 10 * 1024 * 1024,
+    },
     plugins: {
       formbody: true,
       qs: true,
@@ -178,17 +180,6 @@ export default defineConfig({
       onStart: async () => {
         const log = getLogger(["qgrid", "startup"]);
 
-        try {
-          const knex = TokenModel.getDB("w");
-          const migrationsDir = path.join(import.meta.dirname, "../src/migrations");
-          const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });
-          if (migrations.length > 0) {
-            log.info(`migration: ${migrations.length} applied (batch ${batch})`);
-          }
-        } catch (e) {
-          log.warn(`migration skipped: ${(e as Error).message}`);
-        }
-
         let triggerReady = true;
         try {
           await ensureTokensTrigger(connConfig);

package/bundle/src/startup-migrations.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from "vitest";
+
+const { latest } = vi.hoisted(() => ({ latest: vi.fn() }));
+
+vi.mock("./application/token/token.model", () => ({
+  TokenModel: {
+    getDB: () => ({ migrate: { latest } }),
+  },
+}));
+
+import { runRequiredMigrations } from "./startup-migrations";
+
+describe("required startup migrations", () => {
+  it("terminates with a failure status when migration fails", async () => {
+    const failure = new Error("tokens.weight migration failed");
+    const exit = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw failure;
+    });
+    latest.mockRejectedValueOnce(failure);
+
+    await expect(runRequiredMigrations()).rejects.toBe(failure);
+
+    expect(exit).toHaveBeenCalledWith(1);
+  });
+});

package/bundle/src/startup-migrations.ts

@@ -0,0 +1,20 @@
+import path from "node:path";
+
+import { getLogger } from "@logtape/logtape";
+
+import { TokenModel } from "./application/token/token.model";
+
+export async function runRequiredMigrations(): Promise<void> {
+  const log = getLogger(["qgrid", "startup"]);
+  try {
+    const knex = TokenModel.getDB("w");
+    const migrationsDir = path.join(import.meta.dirname, "../src/migrations");
+    const [batch, migrations] = await knex.migrate.latest({ directory: migrationsDir });
+    if (migrations.length > 0) {
+      log.info(`migration: ${migrations.length} applied (batch ${batch})`);
+    }
+  } catch (error) {
+    log.error(`migration failed: ${(error as Error).message}`);
+    process.exit(1);
+  }
+}

package/bundle/src/testing/global.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  dropWorkerDatabases,
+  provisionWorkerDatabases,
+  recreateWorkerDatabases,
+  resolveMaxWorkers,
+} from "./global";
+
+describe("parallel test database setup", () => {
+  it("recreates worker databases from the template through an admin connection", async () => {
+    const query = vi.fn().mockResolvedValue({});
+
+    await recreateWorkerDatabases(
+      { query } as never,
+      "qgrid_test",
+      "qgrid_test_run_a",
+      2,
+    );
+
+    const sql = query.mock.calls.map(([text]) => String(text).replaceAll(/\s+/g, " ").trim());
+    expect(sql).toContain('DROP DATABASE IF EXISTS "qgrid_test_run_a_1"');
+    expect(sql).toContain(
+      'CREATE DATABASE "qgrid_test_run_a_1" TEMPLATE "qgrid_test" STRATEGY FILE_COPY',
+    );
+    expect(sql).toContain('DROP DATABASE IF EXISTS "qgrid_test_run_a_2"');
+    expect(query).toHaveBeenCalledWith(expect.stringContaining("pg_terminate_backend"), [
+      "qgrid_test",
+    ]);
+  });
+
+  it("terminates worker sessions before dropping worker databases", async () => {
+    const query = vi.fn().mockResolvedValue({});
+
+    await dropWorkerDatabases({ query } as never, "qgrid_test_run_a", 1);
+
+    expect(query.mock.calls[0]?.[1]).toEqual(["qgrid_test_run_a_1"]);
+    expect(query.mock.calls[1]?.[0]).toBe('DROP DATABASE IF EXISTS "qgrid_test_run_a_1"');
+  });
+
+  it("attempts cleanup for every planned database after individual failures", async () => {
+    const query = vi.fn(async (text: string, values?: string[]) => {
+      if (values?.[0] === "qgrid_test_run_a_1" || text.includes('"qgrid_test_run_a_1"')) {
+        throw new Error("db1 cleanup failed");
+      }
+      return {};
+    });
+
+    await expect(
+      dropWorkerDatabases({ query } as never, "qgrid_test_run_a", 2),
+    ).rejects.toBeInstanceOf(AggregateError);
+
+    expect(query).toHaveBeenCalledWith(expect.stringContaining("pg_terminate_backend"), [
+      "qgrid_test_run_a_2",
+    ]);
+    expect(query).toHaveBeenCalledWith('DROP DATABASE IF EXISTS "qgrid_test_run_a_2"');
+  });
+
+  it("uses the worker count resolved by Vitest", () => {
+    expect(resolveMaxWorkers({ config: { maxWorkers: 5 } })).toBe(5);
+  });
+
+  it("uses a fresh admin connection to clean every planned DB after setup failure", async () => {
+    const setupQuery = vi.fn(async (text: string) => {
+      if (text.includes('CREATE DATABASE "qgrid_test_run_a_2"')) {
+        throw new Error("clone failed");
+      }
+      return {};
+    });
+    const cleanupQuery = vi.fn().mockResolvedValue({});
+    const createClient = vi
+      .fn()
+      .mockReturnValueOnce({
+        connect: vi.fn().mockResolvedValue(undefined),
+        end: vi.fn().mockResolvedValue(undefined),
+        query: setupQuery,
+      })
+      .mockReturnValueOnce({
+        connect: vi.fn().mockResolvedValue(undefined),
+        end: vi.fn().mockResolvedValue(undefined),
+        query: cleanupQuery,
+      });
+
+    await expect(
+      provisionWorkerDatabases(
+        createClient,
+        "qgrid_test",
+        "qgrid_test_run_a",
+        2,
+      ),
+    ).rejects.toThrow("clone failed");
+
+    const drops = cleanupQuery.mock.calls
+      .map(([text]) => String(text).replaceAll(/\s+/g, " ").trim())
+      .filter((text) => text.startsWith("DROP DATABASE"));
+    expect(createClient).toHaveBeenCalledTimes(2);
+    expect(drops).toContain('DROP DATABASE IF EXISTS "qgrid_test_run_a_1"');
+    expect(drops).toContain('DROP DATABASE IF EXISTS "qgrid_test_run_a_2"');
+  });
+
+  it("preserves both setup and cleanup failures", async () => {
+    const setupError = new Error("clone failed");
+    const cleanupError = new Error("cleanup failed");
+    const createClient = vi
+      .fn()
+      .mockReturnValueOnce({
+        connect: vi.fn().mockResolvedValue(undefined),
+        end: vi.fn().mockResolvedValue(undefined),
+        query: vi.fn().mockRejectedValue(setupError),
+      })
+      .mockReturnValueOnce({
+        connect: vi.fn().mockResolvedValue(undefined),
+        end: vi.fn().mockResolvedValue(undefined),
+        query: vi.fn().mockRejectedValue(cleanupError),
+      });
+
+    const rejected = provisionWorkerDatabases(
+      createClient,
+      "qgrid_test",
+      "qgrid_test_run_a",
+      2,
+    ).catch((error: unknown) => error);
+
+    const combinedError = (await rejected) as AggregateError;
+    expect(combinedError).toBeInstanceOf(AggregateError);
+    expect(combinedError.errors[0]).toBe(setupError);
+    expect(combinedError.errors[1]).toBeInstanceOf(AggregateError);
+    expect((combinedError.errors[1] as AggregateError).errors).toContain(cleanupError);
+  });
+});

package/bundle/src/testing/global.ts

@@ -1,20 +1,150 @@
 import dotenv from "dotenv";
+import { Client } from "pg";
 
 dotenv.config();
 
-type SonamuGlobalSetupModule = {
-  setup: () => Promise<(() => Promise<void>) | void>;
-};
-
-// sonamu/test 의 barrel export 는 bootstrap.js 를 함께 로드하고, bootstrap.js 는 top-level 에서
-// vitest 를 import 한다. Vitest 4 globalSetup 컨텍스트에서는 이 import 가 internal state 에러를
-// 만들기 때문에 global-setup.js 만 직접 로드한다.
-export async function setup(): Promise<(() => Promise<void>) | void> {
-  const globalSetupUrl = new URL(
-    "../../node_modules/sonamu/dist/testing/global-setup.js",
-    import.meta.url,
+const MAX_WORKERS = 4;
+const TEMPLATE_DB = process.env.QGRID_TEST_DB_NAME ?? "qgrid_test";
+
+type QueryClient = Pick<Client, "query">;
+type AdminClient = Pick<Client, "connect" | "end" | "query">;
+type AdminClientFactory = () => AdminClient;
+type VitestProject = { config?: { maxWorkers?: number } };
+
+function quoteIdentifier(value: string): string {
+  if (!/^[A-Za-z0-9_]+$/.test(value)) {
+    throw new Error(`invalid database identifier: ${value}`);
+  }
+  return `"${value}"`;
+}
+
+function workerDatabaseNames(templateDb: string, maxWorkers: number): string[] {
+  return Array.from({ length: maxWorkers }, (_, index) => `${templateDb}_${index + 1}`);
+}
+
+async function terminateConnections(client: QueryClient, database: string): Promise<void> {
+  await client.query(
+    `
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1
+        AND pid <> pg_backend_pid()
+    `,
+    [database],
   );
-  const { setup: sonamuSetup } = (await import(globalSetupUrl.href)) as SonamuGlobalSetupModule;
+}
+
+export async function recreateWorkerDatabases(
+  client: QueryClient,
+  templateDb: string,
+  runDatabase: string,
+  maxWorkers: number,
+): Promise<string[]> {
+  const workers = workerDatabaseNames(runDatabase, maxWorkers);
+  for (const database of [...workers, templateDb]) {
+    await terminateConnections(client, database);
+  }
+  for (const database of workers) {
+    await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`);
+    await client.query(
+      `CREATE DATABASE ${quoteIdentifier(database)} TEMPLATE ${quoteIdentifier(templateDb)} STRATEGY FILE_COPY`,
+    );
+  }
+  return workers;
+}
+
+export async function dropWorkerDatabases(
+  client: QueryClient,
+  templateDb: string,
+  maxWorkers: number,
+): Promise<void> {
+  const errors: unknown[] = [];
+  for (const database of workerDatabaseNames(templateDb, maxWorkers)) {
+    await terminateConnections(client, database).catch((error) => {
+      errors.push(error);
+    });
+    await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`).catch((error) => {
+      errors.push(error);
+    });
+  }
+  if (errors.length > 0) {
+    const cleanupError = new AggregateError(errors, "failed to clean one or more test databases", {
+      cause: errors[0],
+    });
+    throw cleanupError;
+  }
+}
+
+function createAdminClient(): Client {
+  return new Client({
+    host: process.env.QGRID_DB_HOST ?? "localhost",
+    port: Number(process.env.QGRID_DB_PORT ?? 5432),
+    user: process.env.QGRID_DB_USER ?? "postgres",
+    password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+    database: "postgres",
+    application_name: "qgrid-vitest-global-setup",
+  });
+}
+
+export function resolveMaxWorkers(project?: VitestProject): number {
+  const maxWorkers = project?.config?.maxWorkers;
+  return Number.isInteger(maxWorkers) && maxWorkers !== undefined && maxWorkers > 0
+    ? maxWorkers
+    : MAX_WORKERS;
+}
+
+export async function provisionWorkerDatabases(
+  createClient: AdminClientFactory,
+  templateDb: string,
+  runDatabase: string,
+  maxWorkers: number,
+): Promise<void> {
+  const client = createClient();
+  await client.connect();
+  try {
+    await recreateWorkerDatabases(client, templateDb, runDatabase, maxWorkers);
+  } catch (setupError) {
+    await client.end().catch(() => {});
+    const cleanupClient = createClient();
+    let cleanupError: unknown;
+    try {
+      await cleanupClient.connect();
+      await dropWorkerDatabases(cleanupClient, runDatabase, maxWorkers);
+    } catch (error) {
+      cleanupError = error;
+    } finally {
+      await cleanupClient.end().catch((error) => {
+        cleanupError ??= error;
+      });
+    }
+    if (cleanupError) {
+      const combinedError = new AggregateError(
+        [setupError, cleanupError],
+        "test database setup and cleanup both failed",
+        { cause: setupError },
+      );
+      throw combinedError;
+    }
+    throw setupError;
+  }
+  await client.end();
+}
+
+export async function setup(project?: VitestProject): Promise<() => Promise<void>> {
+  const runDatabase = process.env.QGRID_TEST_RUN_DB;
+  if (!runDatabase || process.env.QGRID_DB_NAME !== runDatabase) {
+    throw new Error("Vitest test database name was not configured consistently");
+  }
+  const maxWorkers = resolveMaxWorkers(project);
+  await provisionWorkerDatabases(createAdminClient, TEMPLATE_DB, runDatabase, maxWorkers);
 
-  return sonamuSetup();
+  return async () => {
+    const teardownClient = createAdminClient();
+    await teardownClient.connect();
+    try {
+      await dropWorkerDatabases(teardownClient, runDatabase, maxWorkers);
+    } finally {
+      await teardownClient.end();
+    }
+  };
 }

package/bundle/src/testing/test-database-name.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  configureTestRunDatabaseName,
+  createTestRunDatabaseName,
+} from "./test-database-name";
+
+const originalRunDatabase = process.env.QGRID_TEST_RUN_DB;
+const originalDatabase = process.env.QGRID_DB_NAME;
+
+describe("test run database name", () => {
+  afterEach(() => {
+    if (originalRunDatabase === undefined) delete process.env.QGRID_TEST_RUN_DB;
+    else process.env.QGRID_TEST_RUN_DB = originalRunDatabase;
+    if (originalDatabase === undefined) delete process.env.QGRID_DB_NAME;
+    else process.env.QGRID_DB_NAME = originalDatabase;
+  });
+
+  it("uses one run-unique basename for setup and Sonamu workers", () => {
+    delete process.env.QGRID_TEST_RUN_DB;
+    process.env.QGRID_DB_NAME = "qgrid";
+
+    const runDatabase = configureTestRunDatabaseName();
+
+    expect(runDatabase).toMatch(/^qgrid_test_[A-Za-z0-9_]+$/);
+    expect(process.env.QGRID_TEST_RUN_DB).toBe(runDatabase);
+    expect(process.env.QGRID_DB_NAME).toBe(runDatabase);
+  });
+
+  it("adds controller-specific entropy when processes share a prefix", () => {
+    expect(createTestRunDatabaseName("shared_ci", "controller_1")).toBe(
+      "shared_ci_controller_1",
+    );
+    expect(createTestRunDatabaseName("shared_ci", "controller_2")).toBe(
+      "shared_ci_controller_2",
+    );
+  });
+});

package/bundle/src/testing/test-database-name.ts

@@ -0,0 +1,21 @@
+import { randomUUID } from "node:crypto";
+
+let configuredRunDatabase: string | undefined;
+
+export function createTestRunDatabaseName(prefix: string, entropy: string): string {
+  const safePrefix = prefix.replaceAll(/[^A-Za-z0-9_]/g, "_");
+  const safeEntropy = entropy.replaceAll(/[^A-Za-z0-9_]/g, "_");
+  const maxPrefixLength = 63 - safeEntropy.length - 1;
+  return `${safePrefix.slice(0, maxPrefixLength)}_${safeEntropy}`;
+}
+
+export function configureTestRunDatabaseName(): string {
+  if (configuredRunDatabase) return configuredRunDatabase;
+  const prefix = process.env.QGRID_TEST_RUN_DB ?? "qgrid_test";
+  const entropy = `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+  const runDatabase = createTestRunDatabaseName(prefix, entropy);
+  configuredRunDatabase = runDatabase;
+  process.env.QGRID_TEST_RUN_DB = runDatabase;
+  process.env.QGRID_DB_NAME = runDatabase;
+  return runDatabase;
+}