@cartanova/qgrid-cli 2.6.1 → 2.6.2

package/bundle/dist/application/sonamu.generated.sso.js

@@ -59,11 +59,27 @@ const requestLogSubsetQueries = {
 			tool_call_count: "request_logs.tool_call_count",
 			is_image_generation: "request_logs.is_image_generation"
 		});
+	},
+	C: (qbWrapper) => {
+		return qbWrapper.from("request_logs").select({
+			id: "request_logs.id",
+			token_name: "request_logs.token_name",
+			model_name: "request_logs.model_name",
+			input_tokens: "request_logs.input_tokens",
+			output_tokens: "request_logs.output_tokens",
+			cache_read_tokens: "request_logs.cache_read_tokens",
+			cache_creation_tokens: "request_logs.cache_creation_tokens",
+			cache_creation_5m_tokens: "request_logs.cache_creation_5m_tokens",
+			cache_creation_1h_tokens: "request_logs.cache_creation_1h_tokens",
+			cost_usd: "request_logs.cost_usd",
+			cost_source: "request_logs.cost_source"
+		});
 	}
 };
 const requestLogLoaderQueries = {
 	A: [],
-	P: []
+	P: [],
+	C: []
 };
 const requestLogStepSubsetQueries = {
 	A: (qbWrapper) => {
@@ -154,4 +170,4 @@ const tokenLoaderQueries = { A: [] };
 //#endregion
 export { requestLogLoaderQueries, requestLogStepLoaderQueries, requestLogStepSubsetQueries, requestLogSubsetQueries, tokenLoaderQueries, tokenSubsetQueries };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.generated.sso.js","names":[],"sources":["../../src/application/sonamu.generated.sso.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n\nimport { type PuriWrapper, type DatabaseSchemaExtend, type PuriLoaderQueries } from \"sonamu\";\n\nimport {\n  type RequestLogSubsetKey,\n  type RequestLogStepSubsetKey,\n  type TokenSubsetKey,\n  type RequestLogBaseSchema,\n  type RequestLogStepBaseSchema,\n  type TokenBaseSchema,\n} from \"./sonamu.generated\";\n\n// SubsetQuery: RequestLog\nexport const requestLogSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_logs\").select({\n      id: \"request_logs.id\",\n      created_at: \"request_logs.created_at\",\n      token_name: \"request_logs.token_name\",\n      project_name: \"request_logs.project_name\",\n      model_name: \"request_logs.model_name\",\n      requested_model_name: \"request_logs.requested_model_name\",\n      fallback_count: \"request_logs.fallback_count\",\n      user_prompt: \"request_logs.user_prompt\",\n      system_prompt: \"request_logs.system_prompt\",\n      response: \"request_logs.response\",\n      input_tokens: \"request_logs.input_tokens\",\n      output_tokens: \"request_logs.output_tokens\",\n      cache_read_tokens: \"request_logs.cache_read_tokens\",\n      cache_creation_tokens: \"request_logs.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_logs.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_logs.cache_creation_1h_tokens\",\n      duration_ms: \"request_logs.duration_ms\",\n      ttft_ms: \"request_logs.ttft_ms\",\n      cost_usd: \"request_logs.cost_usd\",\n      cost_source: \"request_logs.cost_source\",\n      image_cost_usd: \"request_logs.image_cost_usd\",\n      image_cost_method: \"request_logs.image_cost_method\",\n      effort: \"request_logs.effort\",\n      history: \"request_logs.history\",\n      tools: \"request_logs.tools\",\n      status: \"request_logs.status\",\n      error_message: \"request_logs.error_message\",\n      tool_call_count: \"request_logs.tool_call_count\",\n      is_image_generation: \"request_logs.is_image_generation\",\n    });\n  },\n  P: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_logs\").select({\n      id: \"request_logs.id\",\n      created_at: \"request_logs.created_at\",\n      token_name: \"request_logs.token_name\",\n      project_name: \"request_logs.project_name\",\n      model_name: \"request_logs.model_name\",\n      requested_model_name: \"request_logs.requested_model_name\",\n      fallback_count: \"request_logs.fallback_count\",\n      input_tokens: \"request_logs.input_tokens\",\n      output_tokens: \"request_logs.output_tokens\",\n      cache_read_tokens: \"request_logs.cache_read_tokens\",\n      cache_creation_tokens: \"request_logs.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_logs.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_logs.cache_creation_1h_tokens\",\n      duration_ms: \"request_logs.duration_ms\",\n      ttft_ms: \"request_logs.ttft_ms\",\n      cost_usd: \"request_logs.cost_usd\",\n      cost_source: \"request_logs.cost_source\",\n      image_cost_usd: \"request_logs.image_cost_usd\",\n      image_cost_method: \"request_logs.image_cost_method\",\n      effort: \"request_logs.effort\",\n      status: \"request_logs.status\",\n      tool_call_count: \"request_logs.tool_call_count\",\n      is_image_generation: \"request_logs.is_image_generation\",\n    });\n  },\n};\n\n// LoaderQuery: RequestLog\nexport const requestLogLoaderQueries = {\n  A: [],\n  P: [],\n} as const satisfies PuriLoaderQueries<RequestLogSubsetKey>;\n\n// SubsetQuery: RequestLogStep\nexport const requestLogStepSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      created_at: \"request_log_steps.created_at\",\n      step_index: \"request_log_steps.step_index\",\n      type: \"request_log_steps.type\",\n      model_name: \"request_log_steps.model_name\",\n      requested_model_name: \"request_log_steps.requested_model_name\",\n      fallback_count: \"request_log_steps.fallback_count\",\n      input_tokens: \"request_log_steps.input_tokens\",\n      output_tokens: \"request_log_steps.output_tokens\",\n      cache_read_tokens: \"request_log_steps.cache_read_tokens\",\n      cache_creation_tokens: \"request_log_steps.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_log_steps.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_log_steps.cache_creation_1h_tokens\",\n      cost_usd: \"request_log_steps.cost_usd\",\n      cost_source: \"request_log_steps.cost_source\",\n      duration_ms: \"request_log_steps.duration_ms\",\n      ttft_ms: \"request_log_steps.ttft_ms\",\n      finish_reason: \"request_log_steps.finish_reason\",\n      reasoning_text: \"request_log_steps.reasoning_text\",\n      reasoning_tokens: \"request_log_steps.reasoning_tokens\",\n      tool_call_index: \"request_log_steps.tool_call_index\",\n      tool_call_id: \"request_log_steps.tool_call_id\",\n      tool_name: \"request_log_steps.tool_name\",\n      tool_args: \"request_log_steps.tool_args\",\n      tool_result: \"request_log_steps.tool_result\",\n      tool_duration_ms: \"request_log_steps.tool_duration_ms\",\n      error: \"request_log_steps.error\",\n    });\n  },\n  T: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      created_at: \"request_log_steps.created_at\",\n      step_index: \"request_log_steps.step_index\",\n      type: \"request_log_steps.type\",\n      model_name: \"request_log_steps.model_name\",\n      requested_model_name: \"request_log_steps.requested_model_name\",\n      fallback_count: \"request_log_steps.fallback_count\",\n      input_tokens: \"request_log_steps.input_tokens\",\n      output_tokens: \"request_log_steps.output_tokens\",\n      cache_read_tokens: \"request_log_steps.cache_read_tokens\",\n      cache_creation_tokens: \"request_log_steps.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_log_steps.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_log_steps.cache_creation_1h_tokens\",\n      cost_usd: \"request_log_steps.cost_usd\",\n      cost_source: \"request_log_steps.cost_source\",\n      duration_ms: \"request_log_steps.duration_ms\",\n      ttft_ms: \"request_log_steps.ttft_ms\",\n      finish_reason: \"request_log_steps.finish_reason\",\n      reasoning_tokens: \"request_log_steps.reasoning_tokens\",\n      tool_call_index: \"request_log_steps.tool_call_index\",\n      tool_call_id: \"request_log_steps.tool_call_id\",\n      tool_name: \"request_log_steps.tool_name\",\n      tool_duration_ms: \"request_log_steps.tool_duration_ms\",\n      error: \"request_log_steps.error\",\n    });\n  },\n  I: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      tool_args: \"request_log_steps.tool_args\",\n    });\n  },\n};\n\n// LoaderQuery: RequestLogStep\nexport const requestLogStepLoaderQueries = {\n  A: [],\n  T: [],\n  I: [],\n} as const satisfies PuriLoaderQueries<RequestLogStepSubsetKey>;\n\n// SubsetQuery: Token\nexport const tokenSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"tokens\").select({\n      id: \"tokens.id\",\n      created_at: \"tokens.created_at\",\n      provider: \"tokens.provider\",\n      credentials: \"tokens.credentials\",\n      name: \"tokens.name\",\n      active: \"tokens.active\",\n      ord: \"tokens.ord\",\n      quota_threshold: \"tokens.quota_threshold\",\n      weight: \"tokens.weight\",\n    });\n  },\n};\n\n// LoaderQuery: Token\nexport const tokenLoaderQueries = {\n  A: [],\n} as const satisfies PuriLoaderQueries<TokenSubsetKey>;\n\n// ForeignKey Types\nexport type RequestLogStepForeignKeys = \"request_log_id\";\n\n// DatabaseSchema\ndeclare module \"sonamu\" {\n  export interface DatabaseSchemaExtend {\n    request_logs: RequestLogBaseSchema;\n    request_log_steps: RequestLogStepBaseSchema;\n    tokens: TokenBaseSchema;\n  }\n\n  export interface DatabaseForeignKeys {\n    request_log_steps: RequestLogStepForeignKeys;\n  }\n}\n"],"mappings":";AAiBA,MAAa,0BAA0B;CACrC,IAAI,cAAiD;EACnD,OAAO,UAAU,KAAK,cAAc,CAAC,CAAC,OAAO;GAC3C,IAAI;GACJ,YAAY;GACZ,YAAY;GACZ,cAAc;GACd,YAAY;GACZ,sBAAsB;GACtB,gBAAgB;GAChB,aAAa;GACb,eAAe;GACf,UAAU;GACV,cAAc;GACd,eAAe;GACf,mBAAmB;GACnB,uBAAuB;GACvB,0BAA0B;GAC1B,0BAA0B;GAC1B,aAAa;GACb,SAAS;GACT,UAAU;GACV,aAAa;GACb,gBAAgB;GAChB,mBAAmB;GACnB,QAAQ;GACR,SAAS;GACT,OAAO;GACP,QAAQ;GACR,eAAe;GACf,iBAAiB;GACjB,qBAAqB;EACvB,CAAC;CACH;CACA,IAAI,cAAiD;EACnD,OAAO,UAAU,KAAK,cAAc,CAAC,CAAC,OAAO;GAC3C,IAAI;GACJ,YAAY;GACZ,YAAY;GACZ,cAAc;GACd,YAAY;GACZ,sBAAsB;GACtB,gBAAgB;GAChB,cAAc;GACd,eAAe;GACf,mBAAmB;GACnB,uBAAuB;GACvB,0BAA0B;GAC1B,0BAA0B;GAC1B,aAAa;GACb,SAAS;GACT,UAAU;GACV,aAAa;GACb,gBAAgB;GAChB,mBAAmB;GACnB,QAAQ;GACR,QAAQ;GACR,iBAAiB;GACjB,qBAAqB;EACvB,CAAC;CACH;AACF;AAGA,MAAa,0BAA0B;CACrC,GAAG,CAAC;CACJ,GAAG,CAAC;AACN;AAGA,MAAa,8BAA8B;CACzC,IAAI,cAAiD;EACnD,OAAO,UAAU,KAAK,mBAAmB,CAAC,CAAC,OAAO;GAChD,IAAI;GACJ,YAAY;GACZ,YAAY;GACZ,MAAM;GACN,YAAY;GACZ,sBAAsB;GACtB,gBAAgB;GAChB,cAAc;GACd,eAAe;GACf,mBAAmB;GACnB,uBAAuB;GACvB,0BAA0B;GAC1B,0BAA0B;GAC1B,UAAU;GACV,aAAa;GACb,aAAa;GACb,SAAS;GACT,eAAe;GACf,gBAAgB;GAChB,kBAAkB;GAClB,iBAAiB;GACjB,cAAc;GACd,WAAW;GACX,WAAW;GACX,aAAa;GACb,kBAAkB;GAClB,OAAO;EACT,CAAC;CACH;CACA,IAAI,cAAiD;EACnD,OAAO,UAAU,KAAK,mBAAmB,CAAC,CAAC,OAAO;GAChD,IAAI;GACJ,YAAY;GACZ,YAAY;GACZ,MAAM;GACN,YAAY;GACZ,sBAAsB;GACtB,gBAAgB;GAChB,cAAc;GACd,eAAe;GACf,mBAAmB;GACnB,uBAAuB;GACvB,0BAA0B;GAC1B,0BAA0B;GAC1B,UAAU;GACV,aAAa;GACb,aAAa;GACb,SAAS;GACT,eAAe;GACf,kBAAkB;GAClB,iBAAiB;GACjB,cAAc;GACd,WAAW;GACX,kBAAkB;GAClB,OAAO;EACT,CAAC;CACH;CACA,IAAI,cAAiD;EACnD,OAAO,UAAU,KAAK,mBAAmB,CAAC,CAAC,OAAO;GAChD,IAAI;GACJ,WAAW;EACb,CAAC;CACH;AACF;AAGA,MAAa,8BAA8B;CACzC,GAAG,CAAC;CACJ,GAAG,CAAC;CACJ,GAAG,CAAC;AACN;AAGA,MAAa,qBAAqB,EAChC,IAAI,cAAiD;CACnD,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,OAAO;EACrC,IAAI;EACJ,YAAY;EACZ,UAAU;EACV,aAAa;EACb,MAAM;EACN,QAAQ;EACR,KAAK;EACL,iBAAiB;EACjB,QAAQ;CACV,CAAC;AACH,EACF;AAGA,MAAa,qBAAqB,EAChC,GAAG,CAAC,EACN"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.generated.sso.js","names":[],"sources":["../../src/application/sonamu.generated.sso.ts"],"sourcesContent":["/**\n * @generated\n * 직접 수정하지 마세요.\n */\n\nimport { type PuriWrapper, type DatabaseSchemaExtend, type PuriLoaderQueries } from \"sonamu\";\n\nimport {\n  type RequestLogSubsetKey,\n  type RequestLogStepSubsetKey,\n  type TokenSubsetKey,\n  type RequestLogBaseSchema,\n  type RequestLogStepBaseSchema,\n  type TokenBaseSchema,\n} from \"./sonamu.generated\";\n\n// SubsetQuery: RequestLog\nexport const requestLogSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_logs\").select({\n      id: \"request_logs.id\",\n      created_at: \"request_logs.created_at\",\n      token_name: \"request_logs.token_name\",\n      project_name: \"request_logs.project_name\",\n      model_name: \"request_logs.model_name\",\n      requested_model_name: \"request_logs.requested_model_name\",\n      fallback_count: \"request_logs.fallback_count\",\n      user_prompt: \"request_logs.user_prompt\",\n      system_prompt: \"request_logs.system_prompt\",\n      response: \"request_logs.response\",\n      input_tokens: \"request_logs.input_tokens\",\n      output_tokens: \"request_logs.output_tokens\",\n      cache_read_tokens: \"request_logs.cache_read_tokens\",\n      cache_creation_tokens: \"request_logs.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_logs.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_logs.cache_creation_1h_tokens\",\n      duration_ms: \"request_logs.duration_ms\",\n      ttft_ms: \"request_logs.ttft_ms\",\n      cost_usd: \"request_logs.cost_usd\",\n      cost_source: \"request_logs.cost_source\",\n      image_cost_usd: \"request_logs.image_cost_usd\",\n      image_cost_method: \"request_logs.image_cost_method\",\n      effort: \"request_logs.effort\",\n      history: \"request_logs.history\",\n      tools: \"request_logs.tools\",\n      status: \"request_logs.status\",\n      error_message: \"request_logs.error_message\",\n      tool_call_count: \"request_logs.tool_call_count\",\n      is_image_generation: \"request_logs.is_image_generation\",\n    });\n  },\n  P: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_logs\").select({\n      id: \"request_logs.id\",\n      created_at: \"request_logs.created_at\",\n      token_name: \"request_logs.token_name\",\n      project_name: \"request_logs.project_name\",\n      model_name: \"request_logs.model_name\",\n      requested_model_name: \"request_logs.requested_model_name\",\n      fallback_count: \"request_logs.fallback_count\",\n      input_tokens: \"request_logs.input_tokens\",\n      output_tokens: \"request_logs.output_tokens\",\n      cache_read_tokens: \"request_logs.cache_read_tokens\",\n      cache_creation_tokens: \"request_logs.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_logs.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_logs.cache_creation_1h_tokens\",\n      duration_ms: \"request_logs.duration_ms\",\n      ttft_ms: \"request_logs.ttft_ms\",\n      cost_usd: \"request_logs.cost_usd\",\n      cost_source: \"request_logs.cost_source\",\n      image_cost_usd: \"request_logs.image_cost_usd\",\n      image_cost_method: \"request_logs.image_cost_method\",\n      effort: \"request_logs.effort\",\n      status: \"request_logs.status\",\n      tool_call_count: \"request_logs.tool_call_count\",\n      is_image_generation: \"request_logs.is_image_generation\",\n    });\n  },\n  C: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_logs\").select({\n      id: \"request_logs.id\",\n      token_name: \"request_logs.token_name\",\n      model_name: \"request_logs.model_name\",\n      input_tokens: \"request_logs.input_tokens\",\n      output_tokens: \"request_logs.output_tokens\",\n      cache_read_tokens: \"request_logs.cache_read_tokens\",\n      cache_creation_tokens: \"request_logs.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_logs.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_logs.cache_creation_1h_tokens\",\n      cost_usd: \"request_logs.cost_usd\",\n      cost_source: \"request_logs.cost_source\",\n    });\n  },\n};\n\n// LoaderQuery: RequestLog\nexport const requestLogLoaderQueries = {\n  A: [],\n  P: [],\n  C: [],\n} as const satisfies PuriLoaderQueries<RequestLogSubsetKey>;\n\n// SubsetQuery: RequestLogStep\nexport const requestLogStepSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      created_at: \"request_log_steps.created_at\",\n      step_index: \"request_log_steps.step_index\",\n      type: \"request_log_steps.type\",\n      model_name: \"request_log_steps.model_name\",\n      requested_model_name: \"request_log_steps.requested_model_name\",\n      fallback_count: \"request_log_steps.fallback_count\",\n      input_tokens: \"request_log_steps.input_tokens\",\n      output_tokens: \"request_log_steps.output_tokens\",\n      cache_read_tokens: \"request_log_steps.cache_read_tokens\",\n      cache_creation_tokens: \"request_log_steps.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_log_steps.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_log_steps.cache_creation_1h_tokens\",\n      cost_usd: \"request_log_steps.cost_usd\",\n      cost_source: \"request_log_steps.cost_source\",\n      duration_ms: \"request_log_steps.duration_ms\",\n      ttft_ms: \"request_log_steps.ttft_ms\",\n      finish_reason: \"request_log_steps.finish_reason\",\n      reasoning_text: \"request_log_steps.reasoning_text\",\n      reasoning_tokens: \"request_log_steps.reasoning_tokens\",\n      tool_call_index: \"request_log_steps.tool_call_index\",\n      tool_call_id: \"request_log_steps.tool_call_id\",\n      tool_name: \"request_log_steps.tool_name\",\n      tool_args: \"request_log_steps.tool_args\",\n      tool_result: \"request_log_steps.tool_result\",\n      tool_duration_ms: \"request_log_steps.tool_duration_ms\",\n      error: \"request_log_steps.error\",\n    });\n  },\n  T: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      created_at: \"request_log_steps.created_at\",\n      step_index: \"request_log_steps.step_index\",\n      type: \"request_log_steps.type\",\n      model_name: \"request_log_steps.model_name\",\n      requested_model_name: \"request_log_steps.requested_model_name\",\n      fallback_count: \"request_log_steps.fallback_count\",\n      input_tokens: \"request_log_steps.input_tokens\",\n      output_tokens: \"request_log_steps.output_tokens\",\n      cache_read_tokens: \"request_log_steps.cache_read_tokens\",\n      cache_creation_tokens: \"request_log_steps.cache_creation_tokens\",\n      cache_creation_5m_tokens: \"request_log_steps.cache_creation_5m_tokens\",\n      cache_creation_1h_tokens: \"request_log_steps.cache_creation_1h_tokens\",\n      cost_usd: \"request_log_steps.cost_usd\",\n      cost_source: \"request_log_steps.cost_source\",\n      duration_ms: \"request_log_steps.duration_ms\",\n      ttft_ms: \"request_log_steps.ttft_ms\",\n      finish_reason: \"request_log_steps.finish_reason\",\n      reasoning_tokens: \"request_log_steps.reasoning_tokens\",\n      tool_call_index: \"request_log_steps.tool_call_index\",\n      tool_call_id: \"request_log_steps.tool_call_id\",\n      tool_name: \"request_log_steps.tool_name\",\n      tool_duration_ms: \"request_log_steps.tool_duration_ms\",\n      error: \"request_log_steps.error\",\n    });\n  },\n  I: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"request_log_steps\").select({\n      id: \"request_log_steps.id\",\n      tool_args: \"request_log_steps.tool_args\",\n    });\n  },\n};\n\n// LoaderQuery: RequestLogStep\nexport const requestLogStepLoaderQueries = {\n  A: [],\n  T: [],\n  I: [],\n} as const satisfies PuriLoaderQueries<RequestLogStepSubsetKey>;\n\n// SubsetQuery: Token\nexport const tokenSubsetQueries = {\n  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {\n    return qbWrapper.from(\"tokens\").select({\n      id: \"tokens.id\",\n      created_at: \"tokens.created_at\",\n      provider: \"tokens.provider\",\n      credentials: \"tokens.credentials\",\n      name: \"tokens.name\",\n      active: \"tokens.active\",\n      ord: \"tokens.ord\",\n      quota_threshold: \"tokens.quota_threshold\",\n      weight: \"tokens.weight\",\n    });\n  },\n};\n\n// LoaderQuery: Token\nexport const tokenLoaderQueries = {\n  A: [],\n} as const satisfies PuriLoaderQueries<TokenSubsetKey>;\n\n// ForeignKey Types\nexport type RequestLogStepForeignKeys = \"request_log_id\";\n\n// DatabaseSchema\ndeclare module \"sonamu\" {\n  export interface DatabaseSchemaExtend {\n    request_logs: RequestLogBaseSchema;\n    request_log_steps: RequestLogStepBaseSchema;\n    tokens: TokenBaseSchema;\n  }\n\n  export interface DatabaseForeignKeys {\n    request_log_steps: RequestLogStepForeignKeys;\n  }\n}\n"],"mappings":"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"}

package/bundle/dist/application/token/token.model.js

@@ -3,7 +3,9 @@ import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm
 import { SD } from "../../i18n/sd.generated.js";
 import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso.js";
 import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
+import { getLogger } from "@logtape/logtape";
 //#region src/application/token/token.model.ts
+const logger = getLogger(["qgrid", "token"]);
 const DEFAULT_QUOTA_THRESHOLD = 80;
 const DEFAULT_WEIGHT = 1;
 function applyCreateDefaults(sp) {
@@ -122,6 +124,45 @@ var TokenModelClass = class extends BaseModelClass {
 	async updateFields(id, fields) {
 		return this.getPuri("w").transaction((trx) => trx.table("tokens").where("id", id).update(fields));
 	}
+	/**
+	* 세션 만료 토큰을 라우팅에서 제외한다. `active=true` 조건부 갱신이므로 공유 DB 를 쓰는
+	* 여러 인스턴스가 동시에 같은 만료를 감지해도 true 를 받는 프로세스는 하나뿐이다
+	* (호출부의 알림 발송 게이트).
+	*
+	* 단, 대상이 해당 provider 의 마지막 활성 토큰이면 갱신하지 않고 false 를 반환한다.
+	* client_id 취소나 OAuth 계약 변경처럼 전 토큰이 동시에 실패하는 상황에서 풀이
+	* 통째로 비는 것을 막는 안전판이다.
+	*/
+	/**
+	* 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).
+	*
+	* @returns 처음 들어온 계정인지 — 호출부의 신규 등록 알림 게이트. 재로그인은
+	*   기존 토큰을 대체하는 것이라 알릴 사건이 아니다.
+	*
+	*   provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고
+	*   중복 제거 없이 저장한다(죽은 row 가 남는다). 이때는 기존 토큰 유무를 알 수 없어
+	*   신규로 보지 않는다 — 재로그인을 신규로 잘못 알리는 편보다 조용한 편이 낫다.
+	*/
+	async replaceByAccount(provider, accountId, saveParams) {
+		let isNew = false;
+		if (accountId) {
+			const oldEntries = await this.findByAccountIdentifier("A", provider, accountId);
+			if (oldEntries.length > 0) await this.del(oldEntries.map((o) => o.id));
+			else isNew = true;
+		} else logger.warn(`${provider} login without account identifier: dedup skipped for ${saveParams.name ?? "unnamed"}`);
+		await this.save([saveParams]);
+		return { isNew };
+	}
+	async deactivateIfActive(id) {
+		const wdb = this.getPuri("w");
+		if (((await wdb.knex.raw(`UPDATE tokens SET active = false
+       WHERE id = ? AND active = true
+         AND (SELECT count(*) FROM tokens peer
+              WHERE peer.provider = tokens.provider AND peer.active) > 1`, [id])).rowCount ?? 0) > 0) return true;
+		const survivor = (await wdb.knex.raw("SELECT provider FROM tokens WHERE id = ? AND active = true", [id])).rows[0];
+		if (survivor) logger.error(`refusing to auto-deactivate token ${id}: last active ${survivor.provider} token — systemic refresh failure suspected, keeping the pool non-empty`);
+		return false;
+	}
 	async reorder(ids) {
 		await this.getPuri("w").transaction(async (trx) => {
 			for (let i = 0; i < ids.length; i++) await trx.table("tokens").where("id", ids[i]).update({ ord: i });
@@ -186,4 +227,4 @@ const TokenModel = new TokenModelClass();
 //#endregion
 export { TokenModel };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token.model.js","names":[],"sources":["../../../src/application/token/token.model.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport {\n  api,\n  asArray,\n  BadRequestException,\n  BaseModelClass,\n  exhaustive,\n  type ListResult,\n  NotFoundException,\n} from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { type TokenSubsetKey, type TokenSubsetMapping } from \"../sonamu.generated\";\nimport { tokenLoaderQueries, tokenSubsetQueries } from \"../sonamu.generated.sso\";\nimport { type TokenListParams, type TokenSaveParams } from \"./token.types\";\n\nconst logger = getLogger([\"qgrid\", \"token\"]);\n\nconst DEFAULT_QUOTA_THRESHOLD = 80;\nconst DEFAULT_WEIGHT = 1;\n\nexport type TokenUpdateFields = {\n  name?: string;\n  quota_threshold?: number | null;\n  weight?: number;\n};\n\nfunction applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {\n  if (sp.id !== undefined) return sp;\n  return {\n    ...sp,\n    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),\n    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),\n  };\n}\n\nclass TokenModelClass extends BaseModelClass<\n  TokenSubsetKey,\n  TokenSubsetMapping,\n  typeof tokenSubsetQueries,\n  typeof tokenLoaderQueries\n> {\n  constructor() {\n    super(\"Token\", tokenSubsetQueries, tokenLoaderQueries);\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Token\" })\n  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {\n    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });\n    if (!rows[0]) {\n      throw new NotFoundException(SD(\"error.entityNotFound\")(\"Token\", id));\n    }\n    return rows[0];\n  }\n\n  async findOne<T extends TokenSubsetKey>(\n    subset: T,\n    listParams: TokenListParams,\n  ): Promise<TokenSubsetMapping[T] | null> {\n    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });\n    return rows[0] ?? null;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"], resourceName: \"Tokens\" })\n  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(\n    subset: T,\n    rawParams?: LP,\n  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {\n    const params = {\n      num: 24,\n      page: 1,\n      search: \"id\" as const,\n      orderBy: \"ord-asc\" as const,\n      ...rawParams,\n    } satisfies TokenListParams;\n\n    const { qb, onSubset: _ } = this.getSubsetQueries(subset);\n\n    if (params.id) {\n      qb.whereIn(\"tokens.id\", asArray(params.id));\n    }\n\n    if (params.search && params.keyword && params.keyword.length > 0) {\n      if (params.search === \"id\") {\n        qb.where(\"tokens.id\", Number(params.keyword));\n      } else if (params.search === \"name\") {\n        qb.where(\"tokens.name\", \"like\", `%${params.keyword}%`);\n      } else {\n        throw new BadRequestException(SD(\"error.unknownSearchField\")(params.search));\n      }\n    }\n\n    if (params.orderBy) {\n      if (params.orderBy === \"id-desc\") {\n        qb.orderBy(\"tokens.id\", \"desc\");\n      } else if (params.orderBy === \"ord-asc\") {\n        qb.orderBy(\"tokens.ord\", \"asc\");\n        qb.orderBy(\"tokens.id\", \"asc\");\n      } else {\n        exhaustive(params.orderBy);\n      }\n    }\n\n    const enhancers = this.createEnhancers({\n      A: (row) => ({ ...row }),\n    });\n\n    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });\n  }\n\n  async findByAccountIdentifier<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n    accountId: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.provider\", provider);\n    const jsonKey = provider === \"anthropic\" ? \"accountUuid\" : \"accountId\";\n    qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActiveByProvider<T extends TokenSubsetKey>(\n    subset: T,\n    provider: string,\n  ): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    qb.where(\"tokens.provider\", provider);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {\n    const { qb } = this.getSubsetQueries(subset);\n    qb.where(\"tokens.active\", true);\n    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });\n    const result = await this.executeSubsetQuery({\n      subset,\n      qb,\n      params: { num: 100, page: 1 },\n      enhancers,\n      debug: false,\n    });\n    return result.rows;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async save(spa: TokenSaveParams[]): Promise<number[]> {\n    const wdb = this.getPuri(\"w\");\n    spa.forEach((sp) => {\n      wdb.ubRegister(\"tokens\", applyCreateDefaults(sp));\n    });\n    return wdb.transaction(async (trx) => {\n      return trx.ubUpsert(\"tokens\");\n    });\n  }\n\n  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    return wdb.transaction((trx) => trx.table(\"tokens\").where(\"id\", id).update(fields));\n  }\n\n  /**\n   * 세션 만료 토큰을 라우팅에서 제외한다. `active=true` 조건부 갱신이므로 공유 DB 를 쓰는\n   * 여러 인스턴스가 동시에 같은 만료를 감지해도 true 를 받는 프로세스는 하나뿐이다\n   * (호출부의 알림 발송 게이트).\n   *\n   * 단, 대상이 해당 provider 의 마지막 활성 토큰이면 갱신하지 않고 false 를 반환한다.\n   * client_id 취소나 OAuth 계약 변경처럼 전 토큰이 동시에 실패하는 상황에서 풀이\n   * 통째로 비는 것을 막는 안전판이다.\n   */\n  /**\n   * 같은 계정의 기존 토큰을 지우고 새로 저장한다(로그인·재로그인 공통 경로).\n   *\n   * @returns 처음 들어온 계정인지 — 호출부의 신규 등록 알림 게이트. 재로그인은\n   *   기존 토큰을 대체하는 것이라 알릴 사건이 아니다.\n   *\n   *   provider 응답에 계정 식별자가 없으면 dedup 자체가 불가능하므로 경고만 남기고\n   *   중복 제거 없이 저장한다(죽은 row 가 남는다). 이때는 기존 토큰 유무를 알 수 없어\n   *   신규로 보지 않는다 — 재로그인을 신규로 잘못 알리는 편보다 조용한 편이 낫다.\n   */\n  async replaceByAccount(\n    provider: string,\n    accountId: string | undefined,\n    saveParams: TokenSaveParams,\n  ): Promise<{ isNew: boolean }> {\n    let isNew = false;\n    if (accountId) {\n      const oldEntries = await this.findByAccountIdentifier(\"A\", provider, accountId);\n      if (oldEntries.length > 0) {\n        await this.del(oldEntries.map((o) => o.id));\n      } else {\n        isNew = true;\n      }\n    } else {\n      logger.warn(\n        `${provider} login without account identifier: dedup skipped for ${saveParams.name ?? \"unnamed\"}`,\n      );\n    }\n\n    await this.save([saveParams]);\n    return { isNew };\n  }\n\n  async deactivateIfActive(id: number): Promise<boolean> {\n    const wdb = this.getPuri(\"w\");\n\n    // 활성 여부와 \"마지막 남은 토큰인가\"를 한 statement 안에서 판정한다. 두 조건을\n    // 따로 읽고 나중에 갱신하면 그 사이에 다른 인스턴스가 같은 provider 의 토큰을\n    // 비활성화해 풀이 통째로 빌 수 있다.\n    const updated = await wdb.knex.raw<{ rowCount: number }>(\n      `UPDATE tokens SET active = false\n       WHERE id = ? AND active = true\n         AND (SELECT count(*) FROM tokens peer\n              WHERE peer.provider = tokens.provider AND peer.active) > 1`,\n      [id],\n    );\n    if ((updated.rowCount ?? 0) > 0) return true;\n\n    // 갱신되지 않은 이유는 둘 중 하나다: 이미 비활성이거나(정상 경쟁 결과), 마지막\n    // 활성 토큰이거나. 후자는 systemic 실패 신호라 남겨야 하므로 이때만 한 번 더 읽는다.\n    const survivor = (\n      await wdb.knex.raw<{ rows: { provider: string }[] }>(\n        \"SELECT provider FROM tokens WHERE id = ? AND active = true\",\n        [id],\n      )\n    ).rows[0];\n    if (survivor) {\n      logger.error(\n        `refusing to auto-deactivate token ${id}: last active ${survivor.provider} token — ` +\n          `systemic refresh failure suspected, keeping the pool non-empty`,\n      );\n    }\n    return false;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async reorder(ids: number[]): Promise<{ done: boolean }> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      for (let i = 0; i < ids.length; i++) {\n        await trx.table(\"tokens\").where(\"id\", ids[i]!).update({ ord: i });\n      }\n    });\n    return { done: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async del(ids: number[]): Promise<number> {\n    const wdb = this.getPuri(\"w\");\n    await wdb.transaction(async (trx) => {\n      return trx.table(\"tokens\").whereIn(\"tokens.id\", ids).delete();\n    });\n    return ids.length;\n  }\n}\n\nexport const TokenModel = new TokenModelClass();\n"],"mappings":"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"}

package/bundle/dist/migrations/20260807133553_manual__backfill_request_log_cost.js

@@ -0,0 +1,49 @@
+import { calculateCostUsd } from "../utils/providers/common/model-cost.js";
+//#region src/migrations/20260807133553_manual__backfill_request_log_cost.ts
+const MICRO_USD = 1e6;
+const CHUNK_SIZE = 5e3;
+function isAnthropicRow(row) {
+	return row.token_name?.startsWith("anthropic/") === true || row.model_name?.startsWith("claude-") === true || row.model_name?.startsWith("anthropic/claude-") === true;
+}
+function backfilledCostMicroUsd(row) {
+	if (!row.model_name) return Math.max(row.cost_usd ?? 0, 0);
+	const inputTokens = isAnthropicRow(row) && row.input_tokens < row.cache_read_tokens + row.cache_creation_tokens ? row.input_tokens + row.cache_read_tokens + row.cache_creation_tokens : row.input_tokens;
+	const usd = calculateCostUsd(row.model_name.includes("/") ? row.model_name.split("/").pop() : row.model_name, {
+		inputTokens,
+		outputTokens: row.output_tokens,
+		cachedInputTokens: row.cache_read_tokens,
+		cacheCreationInputTokens: row.cache_creation_tokens,
+		...row.cache_creation_5m_tokens !== null ? { cacheCreationInputTokens5m: row.cache_creation_5m_tokens } : {},
+		...row.cache_creation_1h_tokens !== null ? { cacheCreationInputTokens1h: row.cache_creation_1h_tokens } : {}
+	});
+	return Math.max(Math.round(usd * MICRO_USD), 0);
+}
+async function up(knex) {
+	let lastId = 0;
+	let processed = 0;
+	for (;;) {
+		const { rows } = await knex.raw(`SELECT id, token_name, model_name, input_tokens, output_tokens,
+              cache_read_tokens, cache_creation_tokens,
+              cache_creation_5m_tokens, cache_creation_1h_tokens, cost_usd
+         FROM request_logs
+        WHERE (cost_source IS NULL OR cost_usd IS NULL) AND id > ?
+        ORDER BY id
+        LIMIT ?`, [lastId, CHUNK_SIZE]);
+		if (rows.length === 0) break;
+		const values = rows.map((row) => `(${row.id}, ${backfilledCostMicroUsd(row)})`).join(",");
+		await knex.raw(`UPDATE request_logs AS t
+          SET cost_usd = v.cost_usd, cost_source = 'backfilled'
+         FROM (VALUES ${values}) AS v(id, cost_usd)
+        WHERE t.id = v.id`);
+		lastId = rows[rows.length - 1].id;
+		processed += rows.length;
+	}
+	console.log(`[backfill] request_logs cost backfilled: ${processed} rows`);
+}
+async function down(knex) {
+	await knex.raw(`UPDATE request_logs SET cost_source = NULL WHERE cost_source = 'backfilled'`);
+}
+//#endregion
+export { down, up };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"20260807133553_manual__backfill_request_log_cost.js","names":[],"sources":["../../src/migrations/20260807133553_manual__backfill_request_log_cost.ts"],"sourcesContent":["/**\n * legacy request_logs 의 비용을 확정값으로 백필한다.\n *\n * 배경: `cost_source` 가 없는 row 는 조회할 때마다 앱이 현재 가격표로 재계산해 왔다\n * (`normalizeLegacyAnthropicRow`). 입력이 고정이라 결과도 항상 같은데, 96만 행 테이블에서\n * 23.6만 행을 매 요청 앱으로 끌어오는 비용만 남는다. 한 번 계산해 저장하면 총비용 집계가\n * 단일 SQL SUM 으로 끝난다.\n *\n * 계산식은 앱의 `normalizedUsageForCost` + `calculateCostUsd` 를 그대로 옮긴 것이다.\n * 두 로직이 갈라지면 백필된 값과 신규 저장값의 기준이 달라지므로, 가격표를 바꿀 때는\n * 이 마이그레이션이 아니라 앱 코드만 바꾸면 된다(이미 확정된 값은 유지되는 것이 계약).\n *\n * 되돌리기: down 은 `cost_source='backfilled'` 인 row 의 표식만 제거해 재계산 대상으로\n * 되돌린다. 원본 `cost_usd` 는 복원되지 않는다 — 되돌릴 수 없는 쓰기다. 덮이는 값은\n * NULL 이었거나, 음수였거나, 구버전 가격표로 계산된 값이고, 조회 경로는 이들을 그대로\n * 보여준 적이 없다(항상 현재 가격표로 재계산해 표시). 그래서 화면에 보이던 총액은\n * 백필 전후로 동일하며, 실질 손실은 없다.\n */\nimport { type Knex } from \"knex\";\n\n// 마이그레이션 러너는 tsconfig 의 bundler 해석을 쓰지 않는 순수 ESM 로더라 확장자가 필요하다.\nimport { calculateCostUsd } from \"../utils/providers/common/model-cost.js\";\n\nconst MICRO_USD = 1_000_000;\nconst CHUNK_SIZE = 5_000;\n\ntype LegacyRow = {\n  id: number;\n  token_name: string | null;\n  model_name: string | null;\n  input_tokens: number;\n  output_tokens: number;\n  cache_read_tokens: number;\n  cache_creation_tokens: number;\n  cache_creation_5m_tokens: number | null;\n  cache_creation_1h_tokens: number | null;\n  cost_usd: number | null;\n};\n\nfunction isAnthropicRow(row: LegacyRow): boolean {\n  return (\n    row.token_name?.startsWith(\"anthropic/\") === true ||\n    row.model_name?.startsWith(\"claude-\") === true ||\n    row.model_name?.startsWith(\"anthropic/claude-\") === true\n  );\n}\n\nfunction backfilledCostMicroUsd(row: LegacyRow): number {\n  if (!row.model_name) return Math.max(row.cost_usd ?? 0, 0);\n\n  // Anthropic 은 input/cache_read/cache_creation 을 상호 배타적으로 보고한다. 과거 저장 경로가\n  // 이를 합치지 않아 input_tokens 가 작게 남은 row 를 복원한다.\n  const splitInput =\n    isAnthropicRow(row) && row.input_tokens < row.cache_read_tokens + row.cache_creation_tokens;\n  const inputTokens = splitInput\n    ? row.input_tokens + row.cache_read_tokens + row.cache_creation_tokens\n    : row.input_tokens;\n\n  const model = row.model_name.includes(\"/\") ? row.model_name.split(\"/\").pop()! : row.model_name;\n  const usd = calculateCostUsd(model, {\n    inputTokens,\n    outputTokens: row.output_tokens,\n    cachedInputTokens: row.cache_read_tokens,\n    cacheCreationInputTokens: row.cache_creation_tokens,\n    ...(row.cache_creation_5m_tokens !== null\n      ? { cacheCreationInputTokens5m: row.cache_creation_5m_tokens }\n      : {}),\n    ...(row.cache_creation_1h_tokens !== null\n      ? { cacheCreationInputTokens1h: row.cache_creation_1h_tokens }\n      : {}),\n  });\n  return Math.max(Math.round(usd * MICRO_USD), 0);\n}\n\nexport async function up(knex: Knex): Promise<void> {\n  let lastId = 0;\n  let processed = 0;\n\n  for (;;) {\n    const { rows } = await knex.raw<{ rows: LegacyRow[] }>(\n      `SELECT id, token_name, model_name, input_tokens, output_tokens,\n              cache_read_tokens, cache_creation_tokens,\n              cache_creation_5m_tokens, cache_creation_1h_tokens, cost_usd\n         FROM request_logs\n        WHERE (cost_source IS NULL OR cost_usd IS NULL) AND id > ?\n        ORDER BY id\n        LIMIT ?`,\n      [lastId, CHUNK_SIZE],\n    );\n    if (rows.length === 0) break;\n\n    // chunk 당 한 번의 UPDATE ... FROM (VALUES ...) 로 왕복을 줄인다.\n    const values = rows.map((row) => `(${row.id}, ${backfilledCostMicroUsd(row)})`).join(\",\");\n    await knex.raw(\n      `UPDATE request_logs AS t\n          SET cost_usd = v.cost_usd, cost_source = 'backfilled'\n         FROM (VALUES ${values}) AS v(id, cost_usd)\n        WHERE t.id = v.id`,\n    );\n\n    lastId = rows[rows.length - 1]!.id;\n    processed += rows.length;\n  }\n\n  console.log(`[backfill] request_logs cost backfilled: ${processed} rows`);\n}\n\nexport async function down(knex: Knex): Promise<void> {\n  await knex.raw(`UPDATE request_logs SET cost_source = NULL WHERE cost_source = 'backfilled'`);\n}\n"],"mappings":";;AAuBA,MAAM,YAAY;AAClB,MAAM,aAAa;AAenB,SAAS,eAAe,KAAyB;CAC/C,OACE,IAAI,YAAY,WAAW,YAAY,MAAM,QAC7C,IAAI,YAAY,WAAW,SAAS,MAAM,QAC1C,IAAI,YAAY,WAAW,mBAAmB,MAAM;AAExD;AAEA,SAAS,uBAAuB,KAAwB;CACtD,IAAI,CAAC,IAAI,YAAY,OAAO,KAAK,IAAI,IAAI,YAAY,GAAG,CAAC;CAMzD,MAAM,cADJ,eAAe,GAAG,KAAK,IAAI,eAAe,IAAI,oBAAoB,IAAI,wBAEpE,IAAI,eAAe,IAAI,oBAAoB,IAAI,wBAC/C,IAAI;CAGR,MAAM,MAAM,iBADE,IAAI,WAAW,SAAS,GAAG,IAAI,IAAI,WAAW,MAAM,GAAG,CAAC,CAAC,IAAI,IAAK,IAAI,YAChD;EAClC;EACA,cAAc,IAAI;EAClB,mBAAmB,IAAI;EACvB,0BAA0B,IAAI;EAC9B,GAAI,IAAI,6BAA6B,OACjC,EAAE,4BAA4B,IAAI,yBAAyB,IAC3D,CAAC;EACL,GAAI,IAAI,6BAA6B,OACjC,EAAE,4BAA4B,IAAI,yBAAyB,IAC3D,CAAC;CACP,CAAC;CACD,OAAO,KAAK,IAAI,KAAK,MAAM,MAAM,SAAS,GAAG,CAAC;AAChD;AAEA,eAAsB,GAAG,MAA2B;CAClD,IAAI,SAAS;CACb,IAAI,YAAY;CAEhB,SAAS;EACP,MAAM,EAAE,SAAS,MAAM,KAAK,IAC1B;;;;;;kBAOA,CAAC,QAAQ,UAAU,CACrB;EACA,IAAI,KAAK,WAAW,GAAG;EAGvB,MAAM,SAAS,KAAK,KAAK,QAAQ,IAAI,IAAI,GAAG,IAAI,uBAAuB,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG;EACxF,MAAM,KAAK,IACT;;wBAEkB,OAAO;0BAE3B;EAEA,SAAS,KAAK,KAAK,SAAS,EAAE,CAAE;EAChC,aAAa,KAAK;CACpB;CAEA,QAAQ,IAAI,4CAA4C,UAAU,MAAM;AAC1E;AAEA,eAAsB,KAAK,MAA2B;CACpD,MAAM,KAAK,IAAI,6EAA6E;AAC9F"}

package/bundle/dist/migrations/20260807145144_alter_request_logs_alter1.js

@@ -0,0 +1,13 @@
+//#region src/migrations/20260807145144_alter_request_logs_alter1.ts
+async function up(knex) {
+	await knex.raw(`CREATE INDEX request_logs_project_name_cost_usd_index ON request_logs USING btree(project_name ASC NULLS LAST, cost_usd ASC NULLS LAST);`);
+}
+async function down(knex) {
+	await knex.schema.alterTable("request_logs", (table) => {
+		table.dropIndex(["project_name", "cost_usd"], "request_logs_project_name_cost_usd_index");
+	});
+}
+//#endregion
+export { down, up };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMjAyNjA4MDcxNDUxNDRfYWx0ZXJfcmVxdWVzdF9sb2dzX2FsdGVyMS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlncmF0aW9ucy8yMDI2MDgwNzE0NTE0NF9hbHRlcl9yZXF1ZXN0X2xvZ3NfYWx0ZXIxLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgS25leCB9IGZyb20gXCJrbmV4XCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB1cChrbmV4OiBLbmV4KTogUHJvbWlzZTx2b2lkPiB7XG4gIGF3YWl0IGtuZXgucmF3KFxuICAgIGBDUkVBVEUgSU5ERVggcmVxdWVzdF9sb2dzX3Byb2plY3RfbmFtZV9jb3N0X3VzZF9pbmRleCBPTiByZXF1ZXN0X2xvZ3MgVVNJTkcgYnRyZWUocHJvamVjdF9uYW1lIEFTQyBOVUxMUyBMQVNULCBjb3N0X3VzZCBBU0MgTlVMTFMgTEFTVCk7YCxcbiAgKTtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGRvd24oa25leDogS25leCk6IFByb21pc2U8dm9pZD4ge1xuICBhd2FpdCBrbmV4LnNjaGVtYS5hbHRlclRhYmxlKFwicmVxdWVzdF9sb2dzXCIsICh0YWJsZSkgPT4ge1xuICAgIHRhYmxlLmRyb3BJbmRleChbXCJwcm9qZWN0X25hbWVcIiwgXCJjb3N0X3VzZFwiXSwgXCJyZXF1ZXN0X2xvZ3NfcHJvamVjdF9uYW1lX2Nvc3RfdXNkX2luZGV4XCIpO1xuICB9KTtcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUVBLGVBQXNCLEdBQUcsTUFBMkI7Q0FDbEQsTUFBTSxLQUFLLElBQ1QsMElBQ0Y7QUFDRjtBQUVBLGVBQXNCLEtBQUssTUFBMkI7Q0FDcEQsTUFBTSxLQUFLLE9BQU8sV0FBVyxpQkFBaUIsVUFBVTtFQUN0RCxNQUFNLFVBQVUsQ0FBQyxnQkFBZ0IsVUFBVSxHQUFHLDBDQUEwQztDQUMxRixDQUFDO0FBQ0gifQ==

package/bundle/dist/utils/providers/openai/openai-refresh.js

@@ -1,4 +1,5 @@
 import { TokenModel } from "../../../application/token/token.model.js";
+import { deactivateAuthDeadToken } from "../../../application/qgrid/token-death.js";
 import { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from "./openai-constants.js";
 import { getLogger } from "@logtape/logtape";
 //#region src/utils/providers/openai/openai-refresh.ts
@@ -11,6 +12,11 @@ import { getLogger } from "@logtape/logtape";
 * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트
 */
 const logger = getLogger(["qgrid", "openai-refresh"]);
+const PERMANENT_FAILURE_CODES = /* @__PURE__ */ new Set([
+	"refresh_token_expired",
+	"refresh_token_reused",
+	"refresh_token_invalidated"
+]);
 const inflightRefresh = /* @__PURE__ */ new Map();
 const lastRefreshTime = /* @__PURE__ */ new Map();
 const REFRESH_MIN_INTERVAL_MS = 5e3;
@@ -67,6 +73,11 @@ async function doRefresh(tokenId) {
 			errorCode = JSON.parse(body).error;
 		} catch {}
 		logger.error(`OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} code=${errorCode ?? "?"} body=${body}`);
+		if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) await deactivateAuthDeadToken({
+			id: tokenId,
+			name: token.name,
+			provider: "openai"
+		}, creds.refreshToken, `openai:${errorCode}`);
 		throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);
 	}
 	const data = await resp.json();
@@ -101,4 +112,4 @@ async function doRefresh(tokenId) {
 //#endregion
 export { handleChatgptAuthTokensRefresh };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,SAAS,UAAU,CAAC,SAAS,gBAAgB,CAAC;AAKpD,MAAM,kCAAkB,IAAI,IAAoC;AAChE,MAAM,kCAAkB,IAAI,IAAoB;AAChD,MAAM,0BAA0B;AAQhC,eAAsB,+BAA+B,SAAyC;CAC5F,OAAO,KAAK,+BAA+B,QAAQ,QAAQ,QAAQ,IAAI,EAAE;CACzE,MAAM,WAAW,gBAAgB,IAAI,OAAO;CAC5C,IAAI,UAAU;EACZ,OAAO,KAAK,2BAA2B,SAAS;EAChD,OAAO;CACT;CAEA,MAAM,SAAS,gBAAgB,IAAI,OAAO,KAAK;CAC/C,IAAI,KAAK,IAAI,IAAI,SAAS,yBAAyB;EACjD,OAAO,KAAK,8BAA8B,QAAQ,gCAAgC;EAClF,OAAO,iBAAiB,OAAO;CACjC;CAEA,gBAAgB,IAAI,SAAS,KAAK,IAAI,CAAC;CACvC,MAAM,UAAU,UAAU,OAAO;CACjC,gBAAgB,IAAI,SAAS,OAAO;CAEpC,IAAI;EACF,OAAO,MAAM;CACf,UAAU;EACR,gBAAgB,OAAO,OAAO;CAChC;AACF;AAEA,eAAe,iBAAiB,SAAyC;CACvE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,QAAQ,CAAC;CAC3D,IAAI,CAAC,SAAS,MAAM,aAAa,UAAU,MAAM,IAAI,MAAM,SAAS,QAAQ,WAAW;CACvF,MAAM,QAAQ,MAAM;CACpB,OAAO;EACL,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;CACzB;AACF;AAEA,eAAe,UAAU,SAAyC;CAChE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,QAAQ,CAAC;CAC3D,IAAI,CAAC,SAAS,MAAM,aAAa,UAC/B,MAAM,IAAI,MAAM,SAAS,QAAQ,yBAAyB;CAG5D,MAAM,QAAQ,MAAM;CACpB,IAAI,CAAC,MAAM,cACT,MAAM,IAAI,MAAM,SAAS,QAAQ,qBAAqB;CAGxD,OAAO,KAAK,oBAAoB,MAAM,KAAK,OAAO,QAAQ,EAAE;CAE5D,MAAM,OAAO,MAAM,MAAM,kBAAkB;EACzC,QAAQ;EACR,SAAS,EAAE,gBAAgB,oCAAoC;EAC/D,MAAM,IAAI,gBAAgB;GACxB,YAAY;GACZ,WAAW;GACX,eAAe,MAAM;EACvB,CAAC;CACH,CAAC;CAED,IAAI,CAAC,KAAK,IAAI;EACZ,MAAM,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,YAAY,EAAE;EAM7C,IAAI;EACJ,IAAI;GACF,YAAa,KAAK,MAAM,IAAI,CAAC,CAAwB;EACvD,QAAQ,CAAC;EACT,OAAO,MACL,+BAA+B,MAAM,KAAK,MAAM,QAAQ,WAAW,KAAK,OAAO,QACrE,aAAa,IAAI,QAAQ,MACrC;EACA,MAAM,IAAI,MAAM,0BAA0B,KAAK,OAAO,GAAG,MAAM;CACjE;CAEA,MAAM,OAAQ,MAAM,KAAK,KAAK;CAO9B,MAAM,kBAAkB,KAAK,iBAAiB,MAAM;CACpD,MAAM,UACJ,KAAK,kBAAkB,QACvB,KAAK,kBAAkB,UACvB,KAAK,kBAAkB,MAAM;CAC/B,IAAI,SACF,OAAO,KAAK,mCAAmC,MAAM,MAAM;CAG7D,MAAM,eAAkC;EACtC,GAAG;EACH,aAAa,KAAK;EAClB,cAAc;EACd,sBAAsB,KAAK,aACvB,KAAK,IAAI,IAAI,KAAK,aAAa,MAC/B,MAAM;EACV,GAAI,KAAK,WAAW,EAAE,SAAS,KAAK,SAAS,IAAI,CAAC;CACpD;CAKA,IAAI;EACF,MAAM,WAAW,KAAK,CACpB;GACE,IAAI;GACJ,UAAU;GACV,aAAa;GACb,MAAM,MAAM;EACd,CACF,CAAC;CACH,SAAS,GAAG;EACV,OAAO,MACL,yDAAyD,QAAQ,UACtD,MAAM,KAAK,MAAM,QAAQ,kDAAkD,OAAO,CAAC,GAChG;EACA,MAAM;CACR;CAEA,OAAO,KAAK,SAAS,MAAM,KAAK,mCAAmC,QAAQ,EAAE;CAE7E,OAAO;EACL,aAAa,KAAK;EAClB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;CACzB;AACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { deactivateAuthDeadToken } from \"../../../application/qgrid/token-death\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.\nconst PERMANENT_FAILURE_CODES = new Set([\n  \"refresh_token_expired\",\n  \"refresh_token_reused\",\n  \"refresh_token_invalidated\",\n]);\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가\n    // 상태코드를 바꿀 때 판정이 조용히 멎는다.\n    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {\n      await deactivateAuthDeadToken(\n        { id: tokenId, name: token.name, provider: \"openai\" },\n        creds.refreshToken,\n        `openai:${errorCode}`,\n      );\n    }\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}

package/bundle/dist/utils/slack-notify.js

@@ -0,0 +1,65 @@
+import { getLogger } from "@logtape/logtape";
+//#region src/utils/slack-notify.ts
+/**
+* Slack 알림 (chat.postMessage).
+*
+* fail-open: env 미설정이면 조용히 no-op 이고, 전송 실패는 warn 로그로만 남긴다.
+* 알림 경로가 토큰 라우팅이나 오류 전파를 지연·차단해서는 안 된다.
+*/
+const logger = getLogger(["qgrid", "slack"]);
+const SLACK_POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage";
+const SLACK_TIMEOUT_MS = 5e3;
+/** 상태를 색으로 먼저 읽히게 하는 attachment 색상 바. */
+const SLACK_COLOR = {
+	good: "#2eb886",
+	bad: "#e01e5a"
+};
+async function notifySlack(notification) {
+	const botToken = process.env.SLACK_BOT_TOKEN;
+	const channel = process.env.SLACK_CHANNEL_ID;
+	const { title, subject, context, color } = notification;
+	if (!botToken || !channel) {
+		logger.debug(`slack not configured, skipping notification: ${title} ${subject ?? ""}`);
+		return;
+	}
+	const blocks = [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: subject ? `*${title}*  \`${subject}\`` : `*${title}*`
+		}
+	}];
+	if (context) blocks.push({
+		type: "context",
+		elements: [{
+			type: "mrkdwn",
+			text: context
+		}]
+	});
+	try {
+		const res = await fetch(SLACK_POST_MESSAGE_URL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json; charset=utf-8",
+				Authorization: `Bearer ${botToken}`
+			},
+			body: JSON.stringify({
+				channel,
+				text: subject ? `${title} — ${subject}` : title,
+				attachments: [{
+					...color ? { color } : {},
+					blocks
+				}]
+			}),
+			signal: AbortSignal.timeout(SLACK_TIMEOUT_MS)
+		});
+		const body = await res.json().catch(() => null);
+		if (!body?.ok) logger.warn(`slack notification rejected: ${body?.error ?? `http ${res.status}`}`);
+	} catch (e) {
+		logger.warn(`slack notification failed: ${e.message}`);
+	}
+}
+//#endregion
+export { SLACK_COLOR, notifySlack };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -117,6 +117,25 @@ export async function exchangeCodeForTokens(
   };
 }
 
+/**
+ * refresh 실패를 status 와 함께 전달한다. 호출부가 문자열 메시지를 파싱하지 않고
+ * 영구 실패(400/401)를 판별할 수 있어야 하기 때문이다.
+ */
+export class RefreshFailedError extends Error {
+  override readonly name = "RefreshFailedError";
+  constructor(
+    readonly status: number,
+    readonly body: string,
+  ) {
+    super(`Token refresh failed (${status}): ${body}`);
+  }
+
+  /** 재로그인 외 복구 불가한 인증 실패인지. 일시 오류(5xx·네트워크)는 제외된다. */
+  get isAuthDead(): boolean {
+    return this.status === 400 || this.status === 401;
+  }
+}
+
 export async function refreshAccessToken(refreshToken: string): Promise<OAuthTokens> {
   const res = await fetch(TOKEN_URL, {
     method: "POST",
@@ -130,7 +149,7 @@ export async function refreshAccessToken(refreshToken: string): Promise<OAuthTok
   });
   if (!res.ok) {
     const text = await res.text();
-    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+    throw new RefreshFailedError(res.status, text);
   }
   const data = (await res.json()) as {
     access_token: string;

package/bundle/src/application/qgrid/qgrid-oauth-redirect.test.ts

@@ -37,6 +37,21 @@ vi.mock("../token/token.model", () => ({
     save: tokenSaveMock,
     del: tokenDelMock,
     findByAccountIdentifier: findByAccountMock,
+    // 실제 구현과 같은 순서(dedup → save)로 동작시켜 저장 payload 검증이 유지되게 한다.
+    replaceByAccount: async (
+      _provider: string,
+      accountId: string | undefined,
+      saveParams: unknown,
+    ) => {
+      let isNew = false;
+      if (accountId) {
+        const olds = (await findByAccountMock()) as unknown as { id: number; active: boolean }[];
+        if (olds.length > 0) await tokenDelMock();
+        else isNew = true;
+      }
+      await (tokenSaveMock as unknown as (rows: unknown[]) => Promise<number[]>)([saveParams]);
+      return { isNew };
+    },
   },
 }));
 
@@ -106,7 +121,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
 
   it("exchanges a pasted code#state against the stored pending state and saves the token", async () => {
     mockHttpContext({ origin: "https://qgrid.example.com" });
-    const { authUrl } = await QgridFrame.oauthStart("haze-2");
+    const { authUrl } = await QgridFrame.oauthStart("test-token-2");
     const state = authUrlParam(authUrl, "state")!;
 
     exchangeMock.mockResolvedValueOnce({
@@ -119,7 +134,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
 
     await expect(QgridFrame.oauthComplete(`  the-code#${state} `)).resolves.toEqual({
       added: true,
-      name: "haze-2",
+      name: "test-token-2",
     });
 
     expect(exchangeMock).toHaveBeenCalledWith(
@@ -131,7 +146,7 @@ describe("QgridFrame.oauthComplete code flow", () => {
     expect(tokenSaveMock).toHaveBeenCalledWith([
       expect.objectContaining({
         provider: "anthropic",
-        name: "haze-2",
+        name: "test-token-2",
         credentials: expect.objectContaining({ accessToken: "at", accountUuid: "acc-1" }),
       }),
     ]);