@constructive-io/graphql-server 4.33.0 → 4.34.0

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

package/middleware/llm-api.d.ts

@@ -19,6 +19,9 @@
  *
  * 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 { Router } from 'express';
 export declare function createLlmApiRouter(): Router;

package/middleware/llm-api.js

@@ -20,6 +20,9 @@
  *
  * 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.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -58,45 +61,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLlmApiRouter = createLlmApiRouter;
 const express_1 = __importStar(require("express"));
 const logger_1 = require("@pgpmjs/logger");
-const pg_cache_1 = require("pg-cache");
 const ollama_1 = require("@agentic-kit/ollama");
 const graphile_cache_1 = require("graphile-cache");
 const graphile_llm_1 = require("graphile-llm");
 const log = new logger_1.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 } = (0, graphile_llm_1.getLlmEnvOptions)();
     if (chat.provider === 'ollama') {
@@ -109,9 +78,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;
@@ -123,9 +92,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)]);
         });
@@ -135,11 +104,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 (0, graphile_llm_1.getLlmBillingConfig)(client, databaseId);
+        await ctx.withPgClient(async (client) => {
+            const entry = await (0, graphile_llm_1.getLlmBillingConfig)(client, ctx.databaseId);
             billing = entry.billing;
         });
         return billing;
@@ -178,9 +149,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)`, [
@@ -205,31 +176,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 = (0, pg_cache_1.getPgPool)({ database: dbname });
-    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(pool, dbname);
+    const discovery = await (0, graphile_llm_1.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,
@@ -247,17 +216,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 = (0, pg_cache_1.getPgPool)({ database: dbname });
-    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(pool, dbname);
+    const discovery = await (0, graphile_llm_1.getAgentDiscovery)(ctx.pool, ctx.api.dbname);
     if (!discovery?.thread || !discovery?.message) {
         res.status(404).json({ error: 'Agent module not provisioned for this database' });
         return;
@@ -268,12 +236,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]);
@@ -284,10 +250,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' });
@@ -296,7 +260,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',
@@ -307,7 +271,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}"
@@ -322,7 +286,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
@@ -408,7 +372,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)`, [
@@ -424,7 +388,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,
@@ -436,7 +400,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,
@@ -492,7 +456,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)`, [
@@ -505,7 +469,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,
@@ -517,7 +481,7 @@ async function handleSendMessage(req, res, entityId) {
         }
         // Inference log
         if (inferenceLog) {
-            logInference(pool, pgSettings, inferenceLog, {
+            logInference(ctx, inferenceLog, {
                 entityId,
                 actorId: userId,
                 model,
@@ -577,7 +541,7 @@ 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;
@@ -593,7 +557,7 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-server",
-  "version": "4.33.0",
+  "version": "4.34.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive GraphQL Server",
   "main": "index.js",
@@ -43,16 +43,17 @@
   "dependencies": {
     "@agentic-kit/ollama": "^2.0.0",
     "@constructive-io/csrf": "^0.14.0",
-    "@constructive-io/graphql-env": "^3.11.1",
-    "@constructive-io/graphql-types": "^3.10.1",
+    "@constructive-io/express-context": "^0.2.0",
+    "@constructive-io/graphql-env": "^3.12.0",
+    "@constructive-io/graphql-types": "^3.11.0",
     "@constructive-io/s3-utils": "^2.17.1",
     "@constructive-io/upload-names": "^2.16.0",
     "@constructive-io/url-domains": "^2.16.0",
     "@graphile-contrib/pg-many-to-many": "2.0.0-rc.2",
-    "@pgpmjs/env": "^2.23.0",
+    "@pgpmjs/env": "^2.24.0",
     "@pgpmjs/logger": "^2.11.0",
-    "@pgpmjs/server-utils": "^3.11.0",
-    "@pgpmjs/types": "^2.27.0",
+    "@pgpmjs/server-utils": "^3.12.0",
+    "@pgpmjs/types": "^2.28.0",
     "@pgsql/quotes": "^17.1.0",
     "cors": "^2.8.6",
     "deepmerge": "^4.3.1",
@@ -62,19 +63,19 @@
     "grafserv": "1.0.0",
     "graphile-build": "5.0.2",
     "graphile-build-pg": "5.0.2",
-    "graphile-cache": "^3.11.2",
+    "graphile-cache": "^3.12.0",
     "graphile-config": "1.0.1",
-    "graphile-llm": "^0.9.0",
-    "graphile-settings": "^5.2.4",
+    "graphile-llm": "^0.10.0",
+    "graphile-settings": "^5.3.0",
     "graphile-utils": "5.0.1",
     "graphql": "16.13.0",
     "graphql-upload": "^13.0.0",
     "lru-cache": "^11.2.7",
     "multer": "^2.1.1",
     "pg": "^8.21.0",
-    "pg-cache": "^3.10.1",
-    "pg-env": "^1.14.0",
-    "pg-query-context": "^2.15.1",
+    "pg-cache": "^3.11.0",
+    "pg-env": "^1.15.0",
+    "pg-query-context": "^2.16.0",
     "pg-sql2": "5.0.1",
     "postgraphile": "5.0.3",
     "request-ip": "^3.3.0"
@@ -89,10 +90,10 @@
     "@types/pg": "^8.20.0",
     "@types/request-ip": "^0.0.41",
     "cookie-parser": "^1.4.7",
-    "graphile-test": "4.15.3",
+    "graphile-test": "4.16.0",
     "makage": "^0.3.0",
     "nodemon": "^3.1.14",
     "ts-node": "^10.9.2"
   },
-  "gitHead": "f3ea414974306e3c0d1d68edc93b4cdd8fa6e806"
+  "gitHead": "c0d04574f7719d92e67becb58d60791ae978c5f5"
 }

package/server.js

@@ -34,6 +34,7 @@ const captcha_1 = require("./middleware/captcha");
 const cookie_1 = require("./middleware/cookie");
 const upload_1 = require("./middleware/upload");
 const llm_api_1 = require("./middleware/llm-api");
+const express_context_1 = require("@constructive-io/express-context");
 const debug_sampler_1 = require("./diagnostics/debug-sampler");
 const log = new logger_1.Logger('server');
 /**
@@ -142,10 +143,12 @@ class Server {
         app.use('/graphql', multipart_bridge_1.multipartBridge);
         app.use((0, url_domains_1.middleware)());
         app.use(request_ip_1.default.mw());
+        app.use((0, express_context_1.requestIdMiddleware)());
         app.use(requestLogger);
         app.use(api);
         app.post('/upload', uploadAuthenticate, ...upload_1.uploadRoute);
         app.use(authenticate);
+        app.use((0, express_context_1.createContextMiddleware)({ pg: effectiveOpts.pg }));
         app.use((0, captcha_1.createCaptchaMiddleware)());
         // CSRF protection for cookie-authenticated requests
         // Skip CSRF for Bearer token auth (not vulnerable to CSRF) and anonymous requests