@cartanova/qgrid-cli 1.7.3 → 1.9.0

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.http

@@ -138,7 +138,8 @@ Content-Type: application/json
   "timeout": 0,
   "model": "MODEL",
   "projectName": "PROJECTNAME",
-  "jsonSchema": "JSONSCHEMA"
+  "jsonSchema": "JSONSCHEMA",
+  "effort": "low"
 }
 
 ###

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) => {

package/bundle/src/sonamu.config.ts

@@ -5,23 +5,27 @@ import { getPrettyFormatter } from "@logtape/pretty";
 import dotenv from "dotenv";
 import { CachePresets, defineConfig } from "sonamu";
 import { drivers as cacheDrivers, store } from "sonamu/cache";
-import { drivers } from "sonamu/storage";
 
 dotenv.config({ path: path.join(import.meta.dirname, "../.env") });
 
 const host = process.env.HOST ?? "localhost";
 const port = Number(process.env.PORT ?? 44900);
 
+const connConfig = {
+  host: process.env.QGRID_DB_HOST ?? "localhost",
+  port: Number(process.env.QGRID_DB_PORT ?? 44901),
+  user: process.env.QGRID_DB_USER ?? "postgres",
+  password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+  database: process.env.QGRID_DB_NAME ?? "qgrid",
+};
+
 export default defineConfig({
   projectName: process.env.PROJECT_NAME ?? "SonamuProject",
   database: {
     name: process.env.QGRID_DB_NAME ?? "qgrid",
     defaultOptions: {
       connection: {
-        host: process.env.QGRID_DB_HOST ?? "localhost",
-        port: Number(process.env.QGRID_DB_PORT ?? 44901),
-        user: process.env.QGRID_DB_USER ?? "postgres",
-        password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+        ...connConfig,
         keepAlive: true,
         keepAliveInitialDelayMillis: 10000,
       },
@@ -164,31 +168,6 @@ export default defineConfig({
         }
       },
     },
-    storage: {
-      drivers: {
-        fs: drivers.fs({
-          location: path.join(import.meta.dirname, "/../public/uploaded"),
-          visibility: "public",
-          urlBuilder: {
-            async generateURL(key) {
-              return `/api/public/uploaded/${key}`;
-            },
-            async generateSignedURL(key) {
-              return `/api/public/uploaded/${key}`;
-            },
-          },
-        }),
-        s3: drivers.s3({
-          credentials: {
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? "",
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? "",
-          },
-          region: process.env.S3_REGION ?? "ap-northeast-2",
-          bucket: process.env.S3_BUCKET ?? "sonamu_default_bucket",
-          visibility: "private",
-        }),
-      },
-    },
     cache: {
       default: "main",
       stores: {
@@ -216,19 +195,34 @@ export default defineConfig({
         }
 
         const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher");
+        const { ensureTokensTrigger } = await import("./application/qgrid/token-trigger-setup");
+        const { TokenSubscriber } = await import("./application/qgrid/token-subscriber");
+
+        let triggerReady = true;
         try {
-          const { TokenModel } = await import("./application/token/token.model");
-          const entries = await TokenModel.findActive("A");
-          for (const e of entries) QgridDispatcher.addToken(e.token, e.name);
-          console.log(
-            `🌲 Server listening on http://${host}:${port} (${QgridDispatcher.tokens.size} tokens loaded)`,
-          );
+          await ensureTokensTrigger(connConfig);
         } catch (e) {
-          console.warn(`⚠ Dispatcher init failed: ${(e as Error).message}`);
-          console.log(`🌲 Server listening on http://${host}:${port} (no tokens)`);
+          triggerReady = false;
+          console.warn(
+            `⚠ Token trigger setup failed: ${(e as Error).message}. Continuing with LISTEN/reconcile.`,
+          );
         }
+
+        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);
+        QgridDispatcher.subscriber = subscriber;
+
+        const started = await subscriber.start();
+        const tokenInfo = started
+          ? `${QgridDispatcher.tokens.size} active tokens, LISTEN active`
+          : `degraded — token sync retry scheduled`;
+        const triggerInfo = triggerReady ? "" : ", trigger setup failed";
+        console.log(`🌲 Server listening on http://${host}:${port} (${tokenInfo}${triggerInfo})`);
       },
-      onShutdown: () => {
+      onShutdown: async () => {
+        const { QgridDispatcher } = await import("./application/qgrid/qgrid.dispatcher");
+        if (QgridDispatcher.subscriber) {
+          await QgridDispatcher.subscriber.stop();
+        }
         console.log("graceful shutdown");
       },
       onError: (error, _request, reply) => {

package/bundle/src/testing/setup-mocks.ts

@@ -1,4 +1,4 @@
-import type { PathLike } from "fs";
+import { type PathLike } from "fs";
 
 // import { Naite } from "sonamu";
 import { vi } from "vitest";

package/bundle/src/typings/fastify.d.ts

@@ -1,7 +1,7 @@
 /** biome-ignore-all lint/correctness/noUnusedImports: d.ts */
 import type fastify from "fastify";
 
-import type { UserSubsetSS } from "../application/sonamu.generated";
+import { type UserSubsetSS } from "../application/sonamu.generated";
 
 declare module "fastify" {
   export interface PassportUser extends UserSubsetSS {}

package/bundle/src/typings/sonamu.d.ts

@@ -1,6 +1,5 @@
 /** biome-ignore-all lint/correctness/noUnusedImports: d.ts */
-
-import {} from "sonamu";
+/* oxlint-disable no-empty-imports */
 
 declare module "sonamu" {
   export interface ContextExtend {
@@ -15,3 +14,5 @@ declare module "sonamu" {
     // CustomGuardKey: true
   }
 }
+
+export {};

package/bundle/src/utils/subset-loaders.ts

@@ -1,4 +1,4 @@
-import type { SubsetQuery } from "sonamu";
+import { type SubsetQuery } from "sonamu";
 
 export function getSubsetLoaders(subsets: string[], subsetQueries: Record<string, SubsetQuery>) {
   return subsets.reduce(