@cartanova/qgrid-cli 1.7.3 → 1.8.0

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -4,6 +4,8 @@
  * - 매 요청마다 새 claude CLI 프로세스 spawn → 응답 후 종료
  * - system 은 --append-system-prompt 로 분리 전달 (user turn 오염 방지)
  * - least-used round-robin 으로 토큰 선택
+ * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신
+ * - query 시 expires_at 비교 → 임박 시 preemptive refresh
  * - QuotaError 는 그대로 상위 전파 (자동 failover 없음, UI 에서 수동 토글)
  *
  * env allowlist: PATH, TMPDIR, CLAUDE_CODE_OAUTH_TOKEN + CLAUDE_CODE_DISABLE_*
@@ -13,8 +15,10 @@ import { mkdirSync, writeFileSync } from "node:fs";
 
 import { getLogger } from "@logtape/logtape";
 
+import { type TokenSubsetA } from "../sonamu.generated";
 import { type CliResult, type QueryInput, type TokenStats } from "./qgrid.types";
 import { maskToken, ProcessError, QuotaError, TimeoutError } from "./qgrid.types";
+import { type TokenSubscriber } from "./token-subscriber";
 
 const logger = getLogger(["qgrid"]);
 
@@ -32,11 +36,19 @@ const QGRID_CLAUDE_SETTINGS = {
   cleanupPeriodDays: 1,
 };
 
-class QgridDispatcherClass {
-  tokens = new Map<string, string>();
+// 토큰 만료 임박 임계값 — token.expiredAt이 1분 안에 만료된다면 query 시 체크하고 refresh.
+const REFRESH_SAFETY_MS = 60_000;
+
+export class QgridDispatcherClass {
+  tokens = new Map<number, TokenSubsetA>();
+
+  // key기반(tokenName) 누적 카운터. token 이 OAuth refresh 로 로테이트되도 tokenName 은 불변이라 카운터 유지됨
   requestCounts = new Map<string, number>();
   rrIndex = 0;
 
+  // sonamu.config onStart 에서 처리하는 변수
+  subscriber: TokenSubscriber | null = null;
+
   constructor() {
     mkdirSync(`${CLAUDE_CWD}/.claude`, { recursive: true });
     writeFileSync(
@@ -45,51 +57,75 @@ class QgridDispatcherClass {
     );
   }
 
+  countOf(name: string): number {
+    return this.requestCounts.get(name) ?? 0;
+  }
+
+  // TokenSubscriber 콜백 — 캐시 mutation
+  upsertCache(id: number, row: TokenSubsetA): void {
+    this.tokens.set(id, row);
+  }
+
+  removeCache(id: number): void {
+    this.tokens.delete(id);
+  }
+
+  replaceCache(rows: TokenSubsetA[]): void {
+    this.tokens = new Map(rows.map((r) => [r.id, r]));
+  }
+
   getStats(): TokenStats[] {
-    return [...this.tokens.entries()].map(([token, name]) => ({
-      token,
-      name,
-      requests: this.requestCounts.get(token) ?? 0,
+    return [...this.tokens.values()].map((r) => ({
+      token: r.token,
+      name: r.name,
+      requests: this.countOf(r.name),
     }));
   }
 
-  selectToken(): { token: string; name: string } | null {
-    const entries = [...this.tokens.entries()];
-    if (entries.length === 0) return null;
+  selectToken(): TokenSubsetA | null {
+    const rows = [...this.tokens.values()];
+    if (rows.length === 0) return null;
 
-    const minCount = Math.min(...entries.map(([t]) => this.requestCounts.get(t) ?? 0));
-    const idle = entries.filter(([t]) => (this.requestCounts.get(t) ?? 0) === minCount);
+    const minCount = Math.min(...rows.map((r) => this.countOf(r.name)));
+    const idle = rows.filter((r) => this.countOf(r.name) === minCount);
     const picked = idle[this.rrIndex % idle.length]!;
     this.rrIndex++;
-    return { token: picked[0], name: picked[1] };
+    return picked;
   }
 
   async query(input: QueryInput, timeoutMs?: number): Promise<CliResult> {
-    const sel = this.selectToken();
-    if (!sel) throw new QuotaError("No tokens available");
+    const electedToken = this.selectToken();
+    if (!electedToken) throw new QuotaError("No tokens available");
 
     // await 전에 count 선반영. 병렬 요청이 동시에 도착해도 각자 다른 토큰을 고르도록.
-    this.requestCounts.set(sel.token, (this.requestCounts.get(sel.token) ?? 0) + 1);
-
-    logger.info(`→ ${sel.name} (model: ${input.model ?? DEFAULT_MODEL})`);
-
-    const result = await executeClaude(input, sel.token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    return { ...result, tokenName: sel.name, model: input.model ?? DEFAULT_MODEL };
-  }
+    this.requestCounts.set(electedToken.name, this.countOf(electedToken.name) + 1);
 
-  addToken(token: string, name: string): void {
-    if (this.tokens.has(token)) return;
-    this.tokens.set(token, name);
-    this.requestCounts.set(token, 0);
-  }
+    let token = electedToken.token;
+    // expires_at 임박이면 refresh.
+    // refresh 후 DB save → trigger NOTIFY → subscriber 가 받아 캐시 갱신 (다른 dispatcher 도 동기화)
+    if (
+      electedToken.expires_at &&
+      Number(electedToken.expires_at) - Date.now() < REFRESH_SAFETY_MS &&
+      electedToken.refresh_token
+    ) {
+      try {
+        const { QgridFrame } = await import("./qgrid.frame");
+        token = await QgridFrame.refreshToken({
+          id: electedToken.id,
+          token: electedToken.token,
+          name: electedToken.name,
+          refresh_token: electedToken.refresh_token,
+        });
+      } catch (e) {
+        logger.warn(`refresh failed for ${electedToken.name}: ${(e as Error).message}`);
+        // refresh 실패 시 기존 token 으로 진행. executeClaude 가 401 받으면 caller 처리.
+      }
+    }
 
-  removeToken(token: string): void {
-    this.tokens.delete(token);
-    this.requestCounts.delete(token);
-  }
+    logger.info(`→ ${electedToken.name} (model: ${input.model ?? DEFAULT_MODEL})`);
 
-  hasToken(token: string): boolean {
-    return this.tokens.has(token);
+    const result = await executeClaude(input, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    return { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL };
   }
 }
 

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -85,7 +85,6 @@ class QgridFrameClass extends BaseFrameClass {
         ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),
       },
     ]);
-    QgridDispatcher.addToken(token, name);
     return { added: true };
   }
 
@@ -109,28 +108,19 @@ class QgridFrameClass extends BaseFrameClass {
         ...(hasRefreshToken ? { refresh_token: refreshToken } : {}),
       },
     ]);
-
-    if (hasNewToken) {
-      QgridDispatcher.removeToken(token);
-      QgridDispatcher.addToken(newToken, name ?? entry.name);
-    }
     return { updated: true };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async removeToken(token: string): Promise<{ removed: boolean }> {
-    if (!QgridDispatcher.hasToken(token)) return { removed: false };
-
     const entry = await TokenModel.findByToken("A", token);
-    if (entry) await TokenModel.del([entry.id]);
-    QgridDispatcher.removeToken(token);
+    if (!entry) return { removed: false };
+    await TokenModel.del([entry.id]);
     return { removed: true };
   }
 
   /**
-   * @param id token_id
-   * 토큰 활성화/비활성화 토글 (dispatcher 등록/제거 & DB의 active 필드 업데이트)
-   * @returns 토큰 활성화 여부
+   * 토큰 활성화/비활성화 토글 DB의 active 필드 업데이트
    */
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async toggleToken(id: number): Promise<{ active: boolean }> {
@@ -139,13 +129,6 @@ class QgridFrameClass extends BaseFrameClass {
 
     const newActive = !entry.active;
     await TokenModel.save([{ id, token: entry.token, active: newActive, name: entry.name }]);
-
-    if (newActive) {
-      QgridDispatcher.addToken(entry.token, entry.name);
-    } else {
-      QgridDispatcher.removeToken(entry.token);
-    }
-
     return { active: newActive };
   }
 
@@ -181,7 +164,6 @@ class QgridFrameClass extends BaseFrameClass {
       if (tokens.accountUuid) {
         const oldEntries = await TokenModel.findByAccountUuid("A", tokens.accountUuid);
         if (oldEntries.length > 0) {
-          for (const old of oldEntries) QgridDispatcher.removeToken(old.token);
           await TokenModel.del(oldEntries.map((o) => o.id));
         }
       }
@@ -195,7 +177,6 @@ class QgridFrameClass extends BaseFrameClass {
           account_uuid: tokens.accountUuid,
         },
       ]);
-      QgridDispatcher.addToken(tokens.accessToken, pending.name);
 
       return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
     } catch (e) {
@@ -251,14 +232,16 @@ class QgridFrameClass extends BaseFrameClass {
         name: token.name ?? "",
       },
     ]);
-    QgridDispatcher.removeToken(token.token);
-    QgridDispatcher.addToken(refreshed.accessToken, token.name);
     return refreshed.accessToken;
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async health(): Promise<HealthResponse> {
-    return { status: "ok", activeTokens: QgridDispatcher.tokens.size };
+    return {
+      status: "ok",
+      activeTokens: QgridDispatcher.tokens.size,
+      subscriber: QgridDispatcher.subscriber?.status() ?? null,
+    };
   }
 }
 

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -82,9 +82,18 @@ export type UsageResponse = z.infer<typeof UsageResponse>;
 
 // ─── Health ───
 
+export const SubscriberStatus = z.object({
+  connected: z.boolean(),
+  connectedAt: z.date().nullable(),
+  lastReconcileAt: z.date().nullable(),
+  attempt: z.number(),
+});
+export type SubscriberStatus = z.infer<typeof SubscriberStatus>;
+
 export const HealthResponse = z.object({
   status: z.string(),
   activeTokens: z.number(),
+  subscriber: SubscriberStatus.nullable(),
 });
 export type HealthResponse = z.infer<typeof HealthResponse>;
 

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -0,0 +1,176 @@
+/** tokens_changed LISTEN subscriber. */
+import { getLogger } from "@logtape/logtape";
+import { Client, type ClientConfig } from "pg";
+
+import { TokenModel } from "../token/token.model";
+import { type QgridDispatcherClass } from "./qgrid.dispatcher";
+import { type SubscriberStatus } from "./qgrid.types";
+
+const logger = getLogger(["qgrid", "subscriber"]);
+
+const TOKENS_CHANGED = "tokens_changed";
+const RECONCILE_INTERVAL_MS = 10 * 60 * 1000;
+const CONNECTION_TIMEOUT_MS = 5_000;
+const BACKOFF_BASE_MS = 500;
+const BACKOFF_CAP_MS = 30_000;
+
+type Payload = { op: "INSERT" | "UPDATE" | "DELETE"; id: number };
+
+export class TokenSubscriber {
+  client: Client | null = null;
+  reconcileTimer: NodeJS.Timeout | null = null;
+  reconnectTimer: NodeJS.Timeout | null = null;
+  shutdownRequested = false;
+  attempt = 0;
+  connectedAt: Date | null = null;
+  lastReconcileAt: Date | null = null;
+
+  constructor(
+    public connConfig: ClientConfig,
+    public dispatcher: QgridDispatcherClass,
+  ) {}
+
+  async start(): Promise<boolean> {
+    this.shutdownRequested = false;
+    this.ensureReconcileTimer();
+
+    try {
+      await this.connectAndReconcile();
+      return true;
+    } catch (e) {
+      logger.warn(`subscriber start failed: ${(e as Error).message}, scheduling retry`);
+      this.retryLater();
+      return false;
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.shutdownRequested = true;
+    if (this.reconcileTimer) {
+      clearInterval(this.reconcileTimer);
+      this.reconcileTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    await this.closeClient();
+  }
+
+  status(): SubscriberStatus {
+    return {
+      connected: this.client !== null && this.reconnectTimer === null,
+      connectedAt: this.connectedAt,
+      lastReconcileAt: this.lastReconcileAt,
+      attempt: this.attempt,
+    };
+  }
+
+  ensureReconcileTimer(): void {
+    if (this.reconcileTimer) return;
+
+    // LISTEN/NOTIFY 는 끊긴 동안 유실될 수 있어 주기적으로 DB 기준으로 맞춘다.
+    this.reconcileTimer = setInterval(() => {
+      this.reconcile().catch((e) =>
+        logger.warn(`periodic reconcile failed: ${(e as Error).message}`),
+      );
+    }, RECONCILE_INTERVAL_MS);
+  }
+
+  async connectAndReconcile(): Promise<void> {
+    await this.connectAndListen();
+    await this.reconcile();
+    this.attempt = 0;
+  }
+
+  async connectAndListen(): Promise<void> {
+    const client = new Client({
+      ...this.connConfig,
+      connectionTimeoutMillis: CONNECTION_TIMEOUT_MS,
+      keepAlive: true,
+      keepAliveInitialDelayMillis: 10_000,
+      application_name: "qgrid-listener",
+    });
+
+    client.on("error", (e) => {
+      logger.warn(`subscriber error: ${e.message}`);
+      this.retryLater();
+    });
+    client.on("end", () => {
+      if (!this.shutdownRequested) this.retryLater();
+    });
+    client.on("notification", (msg) => {
+      if (msg.channel !== TOKENS_CHANGED || !msg.payload) return;
+      this.handleNotification(msg.payload).catch((e) =>
+        logger.warn(`handle NOTIFY failed: ${(e as Error).message}`),
+      );
+    });
+
+    try {
+      await client.connect();
+      await client.query("SET statement_timeout = 0");
+      await client.query("SET idle_in_transaction_session_timeout = 0");
+      await client.query(`LISTEN ${client.escapeIdentifier(TOKENS_CHANGED)}`);
+    } catch (e) {
+      client.removeAllListeners();
+      await client.end().catch(() => {});
+      throw e;
+    }
+
+    this.client = client;
+    this.connectedAt = new Date();
+    logger.info(`subscribed to ${TOKENS_CHANGED}`);
+  }
+
+  retryLater(): void {
+    if (this.shutdownRequested) return;
+    if (this.reconnectTimer) return;
+
+    void this.closeClient();
+    this.attempt += 1;
+    const cap = Math.min(BACKOFF_BASE_MS * 2 ** this.attempt, BACKOFF_CAP_MS);
+    const delay = Math.floor(Math.random() * cap);
+    logger.info(`reconnecting in ${delay}ms (attempt ${this.attempt})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connectAndReconcile().catch((e) => {
+        logger.warn(`subscriber reconnect failed: ${(e as Error).message}`);
+        this.retryLater();
+      });
+    }, delay);
+  }
+
+  async closeClient(): Promise<void> {
+    const client = this.client;
+    if (!client) return;
+
+    this.client = null;
+    client.removeAllListeners();
+    await client.end().catch(() => {});
+  }
+
+  async handleNotification(payloadJson: string): Promise<void> {
+    const payload = JSON.parse(payloadJson) as Payload;
+    if (payload.op === "DELETE") {
+      this.dispatcher.removeCache(payload.id);
+      logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
+      return;
+    }
+    const row = await TokenModel.findOne("A", { id: payload.id });
+    if (!row || !row.active) {
+      this.dispatcher.removeCache(payload.id);
+      logger.info(
+        `NOTIFY ${payload.op} id=${payload.id} (${row?.name ?? "?"}) active=${row?.active ?? "missing"} → removed from cache`,
+      );
+      return;
+    }
+    this.dispatcher.upsertCache(payload.id, row);
+    logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=true → cache upserted`);
+  }
+
+  async reconcile(): Promise<void> {
+    const rows = await TokenModel.findActive("A");
+    this.dispatcher.replaceCache(rows);
+    this.lastReconcileAt = new Date();
+  }
+}

package/bundle/src/application/qgrid/token-trigger-setup.ts

@@ -0,0 +1,80 @@
+/** One-time setup for public.tokens -> tokens_changed NOTIFY triggers. */
+import { getLogger } from "@logtape/logtape";
+import { Client, type ClientConfig } from "pg";
+
+const logger = getLogger(["qgrid", "trigger-setup"]);
+
+const CONNECTION_TIMEOUT_MS = 5_000;
+const SETUP_LOCK_TIMEOUT_MS = 3_000;
+const SETUP_STATEMENT_TIMEOUT_MS = 10_000;
+
+const ADVISORY_LOCK_CLASS_ID = 717;
+const ADVISORY_LOCK_OBJECT_ID = 44900;
+
+const SETUP_SQL = `
+  CREATE OR REPLACE FUNCTION public.tokens_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', COALESCE(NEW.id, OLD.id)
+    )::text);
+    RETURN COALESCE(NEW, OLD);
+  END;
+  $func$;
+
+  DROP TRIGGER IF EXISTS tokens_changed_trigger ON public.tokens;
+  DROP TRIGGER IF EXISTS tokens_changed ON public.tokens;
+
+  CREATE OR REPLACE TRIGGER tokens_changed_ins_del
+  AFTER INSERT OR DELETE ON public.tokens
+  FOR EACH ROW EXECUTE FUNCTION public.tokens_notify();
+
+  CREATE OR REPLACE TRIGGER tokens_changed_upd
+  AFTER UPDATE ON public.tokens
+  FOR EACH ROW
+  WHEN (
+    OLD.active IS DISTINCT FROM NEW.active OR
+    OLD.token IS DISTINCT FROM NEW.token OR
+    OLD.refresh_token IS DISTINCT FROM NEW.refresh_token OR
+    OLD.expires_at IS DISTINCT FROM NEW.expires_at OR
+    OLD.name IS DISTINCT FROM NEW.name
+  )
+  EXECUTE FUNCTION public.tokens_notify();
+`;
+
+export async function ensureTokensTrigger(connConfig: ClientConfig): Promise<void> {
+  const client = new Client({
+    ...connConfig,
+    connectionTimeoutMillis: CONNECTION_TIMEOUT_MS,
+    application_name: "qgrid-trigger-setup",
+  });
+
+  let lockAcquired = false;
+  try {
+    await client.connect();
+    await client.query("SET search_path TO public");
+    await client.query(`SET lock_timeout = '${SETUP_LOCK_TIMEOUT_MS}ms'`);
+    await client.query(`SET statement_timeout = '${SETUP_STATEMENT_TIMEOUT_MS}ms'`);
+    await client.query("SELECT pg_advisory_lock($1, $2)", [
+      ADVISORY_LOCK_CLASS_ID,
+      ADVISORY_LOCK_OBJECT_ID,
+    ]);
+    lockAcquired = true;
+
+    await client.query(SETUP_SQL);
+    logger.info("trigger ensured (public.tokens_notify + tokens_changed_* triggers)");
+  } finally {
+    if (lockAcquired) {
+      await client
+        .query("SELECT pg_advisory_unlock($1, $2)", [
+          ADVISORY_LOCK_CLASS_ID,
+          ADVISORY_LOCK_OBJECT_ID,
+        ])
+        .catch(() => {});
+    }
+    await client.end().catch(() => {});
+  }
+}

package/bundle/src/application/request-log/request-log.entity.json

@@ -97,7 +97,9 @@
         "duration_ms",
         "cost_usd"
       ],
-      "cone": { "note": "리스트 조회용 Preview 서브셋. TEXT 컬럼(user_prompt, system_prompt, response) 제외" }
+      "cone": {
+        "note": "리스트 조회용 Preview 서브셋. TEXT 컬럼(user_prompt, system_prompt, response) 제외"
+      }
     }
   },
   "enums": {

package/bundle/src/application/sonamu.generated.sso.ts

@@ -3,13 +3,13 @@
  * 직접 수정하지 마세요.
  */
 
-import { PuriWrapper, DatabaseSchemaExtend, PuriLoaderQueries } from "sonamu";
+import { type PuriWrapper, type DatabaseSchemaExtend, type PuriLoaderQueries } from "sonamu";
 
 import {
-  RequestLogSubsetKey,
-  TokenSubsetKey,
-  RequestLogBaseSchema,
-  TokenBaseSchema,
+  type RequestLogSubsetKey,
+  type TokenSubsetKey,
+  type RequestLogBaseSchema,
+  type TokenBaseSchema,
 } from "./sonamu.generated";
 
 // SubsetQuery: RequestLog

package/bundle/src/application/token/token.types.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import { type z } from "zod";
 
 import { TokenBaseListParams, TokenBaseSchema } from "../sonamu.generated";
 

package/bundle/src/i18n/sd.generated.ts

@@ -11,7 +11,7 @@ function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {
   try {
     const ctx = Sonamu.getContext();
     return (ctx.locale as (typeof SUPPORTED_LOCALES)[number]) ?? DEFAULT_LOCALE;
-  } catch (_) {
+  } catch {
     return DEFAULT_LOCALE;
   }
 }

package/bundle/src/migrations/20260410171405_create__request_logs.ts

@@ -1,4 +1,4 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.createTable("request_logs", (table) => {

package/bundle/src/migrations/20260410171406_create__tokens.ts

@@ -1,4 +1,4 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.createTable("tokens", (table) => {

package/bundle/src/migrations/20260411120624_alter_tokens_alter2.ts

@@ -1,4 +1,4 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("tokens", (table) => {

package/bundle/src/migrations/20260415134649_alter_request_logs_alter1.ts

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.raw(

package/bundle/src/migrations/20260421223627_alter_request_logs_add1_alter1.ts

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("request_logs", (table) => {

package/bundle/src/migrations/20260423180818_alter_request_logs_add1_alter1.ts

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("request_logs", (table) => {

package/bundle/src/migrations/20260423182017_alter_request_logs_add2_drop1_alter1.ts

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("request_logs", (table) => {

package/bundle/src/migrations/20260423183613_alter_request_logs_add1_alter1.ts

@@ -1,4 +1,4 @@
-import { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("request_logs", (table) => {