@constructive-io/graphql-server 4.33.0 → 4.34.1

package/esm/middleware/llm-api.js

@@ -19,48 +19,17 @@
  *
  * Auth: JWT from the auth middleware (req.token) → pg SET LOCAL context for RLS
  * Metering: check_billing_quota → LLM call → record_usage with real token counts
+ *
+ * Context: Uses `req.constructive` from @constructive-io/express-context
+ * for tenant-scoped database access, pgSettings, and withPgClient.
  */
 import express, { Router } from 'express';
 import { Logger } from '@pgpmjs/logger';
-import { getPgPool } from 'pg-cache';
 import { OllamaAdapter } from '@agentic-kit/ollama';
 import { ModuleConfigCache } from 'graphile-cache';
 import { getLlmEnvOptions, getAgentDiscovery, getLlmBillingConfig, } from 'graphile-llm';
 const log = new Logger('llm-api');
 // ─── Helpers ────────────────────────────────────────────────────────────────
-function getPgSettings(req) {
-    const settings = {};
-    if (req.token?.user_id) {
-        settings['jwt.claims.user_id'] = req.token.user_id;
-        settings['role'] = 'authenticated';
-    }
-    if (req.databaseId) {
-        settings['jwt.claims.database_id'] = req.databaseId;
-    }
-    if (req.requestId) {
-        settings['request.id'] = req.requestId;
-    }
-    return settings;
-}
-async function withRlsClient(pool, pgSettings, fn) {
-    const client = await pool.connect();
-    try {
-        await client.query('BEGIN');
-        for (const [key, value] of Object.entries(pgSettings)) {
-            await client.query('SELECT set_config($1, $2, true)', [key, value]);
-        }
-        const result = await fn(client);
-        await client.query('COMMIT');
-        return result;
-    }
-    catch (err) {
-        await client.query('ROLLBACK').catch(() => { });
-        throw err;
-    }
-    finally {
-        client.release();
-    }
-}
 function resolveOllamaAdapter() {
     const { chat } = getLlmEnvOptions();
     if (chat.provider === 'ollama') {
@@ -73,9 +42,9 @@ function resolveOllamaAdapter() {
     return null;
 }
 // ─── Billing Helpers ────────────────────────────────────────────────────────
-async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
+async function checkQuota(ctx, billing, entityId, meterSlug) {
     try {
-        return await withRlsClient(pool, pgSettings, async (client) => {
+        return await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.checkBillingQuotaFunction}"($1, $2::uuid, $3) AS allowed`;
             const result = await client.query(sql, [meterSlug, entityId, 1]);
             return result.rows[0]?.allowed !== false;
@@ -87,9 +56,9 @@ async function checkQuota(pool, pgSettings, billing, entityId, meterSlug) {
         return true;
     }
 }
-async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amount, metadata) {
+async function recordUsage(ctx, billing, entityId, meterSlug, amount, metadata) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             const sql = `SELECT "${billing.privateSchema}"."${billing.recordUsageFunction}"($1, $2::uuid, $3, $4::jsonb)`;
             await client.query(sql, [meterSlug, entityId, amount, JSON.stringify(metadata)]);
         });
@@ -99,11 +68,13 @@ async function recordUsage(pool, pgSettings, billing, entityId, meterSlug, amoun
         log.warn(`[llm-api] record_usage failed (non-fatal): ${message}`);
     }
 }
-async function resolveBilling(pool, pgSettings, databaseId) {
+async function resolveBilling(ctx) {
+    if (!ctx.databaseId)
+        return null;
     try {
         let billing = null;
-        await withRlsClient(pool, pgSettings, async (client) => {
-            const entry = await getLlmBillingConfig(client, databaseId);
+        await ctx.withPgClient(async (client) => {
+            const entry = await getLlmBillingConfig(client, ctx.databaseId);
             billing = entry.billing;
         });
         return billing;
@@ -142,9 +113,9 @@ async function getInferenceLogInfo(pool, dbname) {
     inferenceLogCache.set(dbname, info);
     return info;
 }
-async function logInference(pool, pgSettings, logInfo, data) {
+async function logInference(ctx, logInfo, data) {
     try {
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${logInfo.schemaName}"."${logInfo.tableName}"
          (entity_id, actor_id, model, provider, service, operation, input_tokens, output_tokens, total_tokens, latency_ms, status)
          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
@@ -169,31 +140,29 @@ async function logInference(pool, pgSettings, logInfo, data) {
 }
 // ─── Route Handlers ─────────────────────────────────────────────────────────
 async function handleCreateThread(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = getPgPool({ database: dbname });
-    const discovery = await getAgentDiscovery(pool, dbname);
+    const discovery = await getAgentDiscovery(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
     }
     const body = req.body || {};
     const { thread } = discovery;
-    const pgSettings = getPgSettings(req);
-    const result = await withRlsClient(pool, pgSettings, async (client) => {
+    const result = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`INSERT INTO "${thread.schemaName}"."${thread.tableName}"
        (entity_id, owner_id, mode, model, system_prompt, title)
        VALUES ($1, $2, $3, $4, $5, $6)
        RETURNING id, mode, model, system_prompt, status, created_at`, [
             entityId,
-            req.token.user_id,
+            ctx.userId,
             body.mode ?? 'ask',
             body.model ?? null,
             body.system_prompt ?? null,
@@ -211,17 +180,16 @@ async function handleCreateThread(req, res, entityId) {
     });
 }
 async function handleSendMessage(req, res, entityId) {
-    if (!req.token?.user_id) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
-    const dbname = req.api?.dbname;
-    if (!dbname) {
+    if (!ctx.api.dbname) {
         res.status(400).json({ error: 'Database not resolved' });
         return;
     }
-    const pool = getPgPool({ database: dbname });
-    const discovery = await getAgentDiscovery(pool, dbname);
+    const discovery = await getAgentDiscovery(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread || !discovery?.message) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
@@ -232,12 +200,10 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     const { thread, message: msgTable } = discovery;
-    const pgSettings = getPgSettings(req);
     const threadId = req.params.thread_id;
-    const userId = req.token.user_id;
-    const databaseId = req.databaseId;
+    const userId = ctx.userId;
     // 1. Verify thread exists and user owns it (RLS enforced)
-    const threadRow = await withRlsClient(pool, pgSettings, async (client) => {
+    const threadRow = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT id, mode, model, system_prompt, status
        FROM "${thread.schemaName}"."${thread.tableName}"
        WHERE id = $1`, [threadId]);
@@ -248,10 +214,8 @@ async function handleSendMessage(req, res, entityId) {
         return;
     }
     // 2. Resolve billing config + inference log discovery
-    const billing = databaseId
-        ? await resolveBilling(pool, pgSettings, databaseId)
-        : null;
-    const inferenceLog = await getInferenceLogInfo(pool, dbname);
+    const billing = await resolveBilling(ctx);
+    const inferenceLog = await getInferenceLogInfo(ctx.pool, ctx.api.dbname);
     const ollama = resolveOllamaAdapter();
     if (!ollama) {
         res.status(503).json({ error: 'No LLM provider configured' });
@@ -260,7 +224,7 @@ async function handleSendMessage(req, res, entityId) {
     const model = body.model ?? threadRow.model ?? ollama.model;
     const meterSlug = model;
     if (billing) {
-        const allowed = await checkQuota(pool, pgSettings, billing, entityId, meterSlug);
+        const allowed = await checkQuota(ctx, billing, entityId, meterSlug);
         if (!allowed) {
             res.status(429).json({
                 error: 'Token quota exceeded',
@@ -271,7 +235,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     }
     // 3. Persist user message(s)
-    await withRlsClient(pool, pgSettings, async (client) => {
+    await ctx.withPgClient(async (client) => {
         for (const msg of body.messages) {
             if (msg.role === 'user') {
                 await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
@@ -286,7 +250,7 @@ async function handleSendMessage(req, res, entityId) {
         }
     });
     // 4. Load full thread history for context
-    const history = await withRlsClient(pool, pgSettings, async (client) => {
+    const history = await ctx.withPgClient(async (client) => {
         const { rows } = await client.query(`SELECT author_role, parts, created_at
        FROM "${msgTable.schemaName}"."${msgTable.tableName}"
        WHERE thread_id = $1
@@ -372,7 +336,7 @@ async function handleSendMessage(req, res, entityId) {
             res.end();
             // 6. Persist assistant message with model (fire-and-forget)
             if (content) {
-                withRlsClient(pool, pgSettings, async (client) => {
+                ctx.withPgClient(async (client) => {
                     await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
              (thread_id, owner_id, entity_id, author_role, parts, model)
              VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
@@ -388,7 +352,7 @@ async function handleSendMessage(req, res, entityId) {
             }
             // 7. Record billing usage (fire-and-forget)
             if (billing && usage.totalTokens > 0) {
-                recordUsage(pool, pgSettings, billing, entityId, meterSlug, usage.totalTokens, {
+                recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
                     input_tokens: usage.input,
                     output_tokens: usage.output,
                     cache_read_tokens: usage.cacheRead,
@@ -400,7 +364,7 @@ async function handleSendMessage(req, res, entityId) {
             }
             // 8. Inference log (fire-and-forget)
             if (inferenceLog) {
-                logInference(pool, pgSettings, inferenceLog, {
+                logInference(ctx, inferenceLog, {
                     entityId,
                     actorId: userId,
                     model,
@@ -456,7 +420,7 @@ async function handleSendMessage(req, res, entityId) {
             totalTokens: result.usage.totalTokens,
         };
         // Persist assistant message with model
-        await withRlsClient(pool, pgSettings, async (client) => {
+        await ctx.withPgClient(async (client) => {
             await client.query(`INSERT INTO "${msgTable.schemaName}"."${msgTable.tableName}"
          (thread_id, owner_id, entity_id, author_role, parts, model)
          VALUES ($1, $2, (SELECT entity_id FROM "${thread.schemaName}"."${thread.tableName}" WHERE id = $1), $3, $4, $5)`, [
@@ -469,7 +433,7 @@ async function handleSendMessage(req, res, entityId) {
         });
         // Record billing usage
         if (billing && usage.totalTokens > 0) {
-            recordUsage(pool, pgSettings, billing, entityId, meterSlug, usage.totalTokens, {
+            recordUsage(ctx, billing, entityId, meterSlug, usage.totalTokens, {
                 input_tokens: usage.input,
                 output_tokens: usage.output,
                 cache_read_tokens: usage.cacheRead,
@@ -481,7 +445,7 @@ async function handleSendMessage(req, res, entityId) {
         }
         // Inference log
         if (inferenceLog) {
-            logInference(pool, pgSettings, inferenceLog, {
+            logInference(ctx, inferenceLog, {
                 entityId,
                 actorId: userId,
                 model,
@@ -541,7 +505,7 @@ export function createLlmApiRouter() {
     // ── Global routes (no entity_id — bills to actor_id from JWT) ────────────
     router.post('/v1/threads', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;
@@ -557,7 +521,7 @@ export function createLlmApiRouter() {
     });
     router.post('/v1/threads/:thread_id/messages', async (req, res) => {
         try {
-            const userId = req.token?.user_id;
+            const userId = req.constructive?.userId;
             if (!userId) {
                 res.status(401).json({ error: 'Authentication required' });
                 return;

package/esm/server.js

@@ -28,6 +28,7 @@ import { createCaptchaMiddleware } from './middleware/captcha';
 import { parseCookieValue, SESSION_COOKIE_NAME } from './middleware/cookie';
 import { createUploadAuthenticateMiddleware, uploadRoute } from './middleware/upload';
 import { createLlmApiRouter } from './middleware/llm-api';
+import { createContextMiddleware, requestIdMiddleware } from '@constructive-io/express-context';
 import { startDebugSampler } from './diagnostics/debug-sampler';
 const log = new Logger('server');
 /**
@@ -135,10 +136,12 @@ class Server {
         app.use('/graphql', multipartBridge);
         app.use(parseDomains());
         app.use(requestIp.mw());
+        app.use(requestIdMiddleware());
         app.use(requestLogger);
         app.use(api);
         app.post('/upload', uploadAuthenticate, ...uploadRoute);
         app.use(authenticate);
+        app.use(createContextMiddleware({ pg: effectiveOpts.pg }));
         app.use(createCaptchaMiddleware());
         // CSRF protection for cookie-authenticated requests
         // Skip CSRF for Bearer token auth (not vulnerable to CSRF) and anonymous requests