@constructive-io/graphql-server 5.14.6 → 5.15.1

package/esm/agentic/router.js

@@ -0,0 +1,486 @@
+/**
+ * router — Express router for the agentic-server
+ *
+ * Provides REST endpoints for AI agent conversations:
+ *
+ *   POST /v1/threads                             → create thread
+ *   POST /v1/threads/:thread_id/messages         → send message + stream response
+ *   POST /v1/orgs/:entity_id/threads             → create thread (entity-scoped)
+ *   POST /v1/orgs/:entity_id/threads/:thread_id/messages → send message (entity-scoped)
+ *   POST /v1/embed                               → generate embedding
+ *
+ * All routes require `req.constructive` (from @constructive-io/express-context).
+ * Billing (check_quota + record_usage) and inference logging are automatic
+ * when the billing/inference_log modules are provisioned.
+ *
+ * LLM provider config is resolved per-database via `ctx.useLlm()` from the
+ * llm_module table, falling back to env vars (EMBEDDER_*, CHAT_*) when the
+ * module is not provisioned.
+ */
+import { OllamaAdapter } from '@agentic-kit/ollama';
+import { getEnvOptions as getLlmEnvOptions } from '@constructive-io/llm-env';
+import { Logger } from '@pgpmjs/logger';
+import express, { Router } from 'express';
+const log = new Logger('agentic-server');
+function resolveChatAdapter(llm) {
+    const provider = llm?.chatProvider ?? getLlmEnvOptions().chat.provider;
+    const model = llm?.chatModel ?? getLlmEnvOptions().chat.model;
+    const baseUrl = llm?.chatBaseUrl ?? getLlmEnvOptions().chat.baseUrl;
+    if (provider === 'ollama') {
+        return { adapter: new OllamaAdapter(baseUrl), model, baseUrl, provider };
+    }
+    return null;
+}
+function resolveEmbeddingAdapter(llm) {
+    const provider = llm?.embeddingProvider ?? getLlmEnvOptions().embedding.provider;
+    const model = llm?.embeddingModel ?? getLlmEnvOptions().embedding.model;
+    const baseUrl = llm?.embeddingBaseUrl ?? getLlmEnvOptions().embedding.baseUrl;
+    if (provider === 'ollama') {
+        return { adapter: new OllamaAdapter(baseUrl), model, provider };
+    }
+    return null;
+}
+// ─── Route Handlers ─────────────────────────────────────────────────────────
+async function handleCreateThread(req, res, entityId) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const agentChat = await ctx.useModule('agentChat');
+    if (!agentChat?.threadTableName) {
+        res.status(404).json({ error: 'Agent module not provisioned for this database' });
+        return;
+    }
+    const body = req.body || {};
+    const { schemaName, threadTableName } = agentChat;
+    const result = await ctx.withPgClient(async (client) => {
+        const { rows } = await client.query(`INSERT INTO "${schemaName}"."${threadTableName}"
+       (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,
+            ctx.userId,
+            body.mode ?? 'ask',
+            body.model ?? null,
+            body.system_prompt ?? null,
+            body.title ?? null
+        ]);
+        return rows[0];
+    });
+    res.status(201).json({
+        id: result.id,
+        mode: result.mode,
+        model: result.model,
+        system_prompt: result.system_prompt,
+        status: result.status,
+        created_at: result.created_at
+    });
+}
+async function handleSendMessage(req, res, entityId) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const agentChat = await ctx.useModule('agentChat');
+    if (!agentChat?.threadTableName || !agentChat?.messageTableName) {
+        res.status(404).json({ error: 'Agent module not provisioned for this database' });
+        return;
+    }
+    const body = req.body || {};
+    if (!body.messages?.length) {
+        res.status(400).json({ error: 'messages[] is required and must not be empty' });
+        return;
+    }
+    const { schemaName, threadTableName, messageTableName } = agentChat;
+    const threadId = req.params.thread_id;
+    const userId = ctx.userId;
+    // Verify thread exists (RLS enforced)
+    const threadRow = await ctx.withPgClient(async (client) => {
+        const { rows } = await client.query(`SELECT id, mode, model, system_prompt, status
+       FROM "${schemaName}"."${threadTableName}"
+       WHERE id = $1`, [threadId]);
+        return rows[0];
+    });
+    if (!threadRow) {
+        res.status(404).json({ error: 'Thread not found' });
+        return;
+    }
+    // Resolve shared billing client and LLM config (lazy, cached per request)
+    const [billing, llm] = await Promise.all([ctx.useBilling(), ctx.useLlm()]);
+    const chatAdapter = resolveChatAdapter(llm);
+    if (!chatAdapter) {
+        res.status(503).json({ error: 'No LLM provider configured' });
+        return;
+    }
+    const model = body.model ?? threadRow.model ?? chatAdapter.model;
+    const meterSlug = model;
+    // Quota check
+    if (billing) {
+        const allowed = await billing.checkQuota(meterSlug);
+        if (!allowed) {
+            res.status(429).json({
+                error: 'Token quota exceeded',
+                meter: meterSlug,
+                entity_id: entityId
+            });
+            return;
+        }
+    }
+    // Persist user messages
+    await ctx.withPgClient(async (client) => {
+        for (const msg of body.messages) {
+            if (msg.role === 'user') {
+                await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
+           (thread_id, owner_id, entity_id, author_role, parts)
+           VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4)`, [threadId, userId, 'user', JSON.stringify([{ type: 'text', text: msg.content }])]);
+            }
+        }
+    });
+    // Load full thread history
+    const history = await ctx.withPgClient(async (client) => {
+        const { rows } = await client.query(`SELECT author_role, parts, created_at
+       FROM "${schemaName}"."${messageTableName}"
+       WHERE thread_id = $1
+       ORDER BY created_at ASC`, [threadId]);
+        return rows;
+    });
+    const llmMessages = [];
+    if (threadRow.system_prompt) {
+        llmMessages.push({ role: 'system', content: threadRow.system_prompt });
+    }
+    for (const row of history) {
+        const parts = Array.isArray(row.parts) ? row.parts : [];
+        const textContent = parts
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text)
+            .join('');
+        if (textContent) {
+            llmMessages.push({
+                role: row.author_role === 'user' ? 'user' : 'assistant',
+                content: textContent
+            });
+        }
+    }
+    const startTime = Date.now();
+    const shouldStream = body.stream !== false;
+    if (shouldStream) {
+        await handleStreamingResponse(req, res, {
+            ctx, chatAdapter, model, llmMessages, body,
+            entityId, userId, threadId,
+            schemaName, threadTableName, messageTableName,
+            billing, startTime, meterSlug
+        });
+    }
+    else {
+        await handleBatchResponse(req, res, {
+            ctx, chatAdapter, model, llmMessages, body,
+            entityId, userId, threadId,
+            schemaName, threadTableName, messageTableName,
+            billing, startTime, meterSlug
+        });
+    }
+}
+async function handleStreamingResponse(_req, res, mc) {
+    const { ctx, chatAdapter, model, llmMessages, body, entityId, userId, threadId, schemaName, threadTableName, messageTableName, billing, startTime, meterSlug } = mc;
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no'
+    });
+    const messageId = `msg_${Date.now()}`;
+    try {
+        const systemMsg = llmMessages.find(m => m.role === 'system');
+        const nonSystem = llmMessages.filter(m => m.role !== 'system');
+        const modelDesc = chatAdapter.adapter.createModel(model, { maxOutputTokens: undefined });
+        const context = {
+            systemPrompt: systemMsg?.content,
+            messages: nonSystem.map((m) => ({
+                role: m.role,
+                content: m.content,
+                timestamp: Date.now()
+            }))
+        };
+        const stream = chatAdapter.adapter.stream(modelDesc, context, {
+            temperature: body.temperature
+        });
+        let streamedContent = '';
+        for await (const event of stream) {
+            if (event.type === 'text_delta') {
+                streamedContent += event.delta;
+                const sseEvent = {
+                    id: messageId,
+                    choices: [{
+                            index: 0,
+                            delta: { content: event.delta, role: 'assistant' },
+                            finish_reason: null
+                        }],
+                    model
+                };
+                res.write(`data: ${JSON.stringify(sseEvent)}\n\n`);
+            }
+        }
+        const result = await stream.result();
+        const content = streamedContent;
+        const latencyMs = Date.now() - startTime;
+        const usage = {
+            input: result.usage.input,
+            output: result.usage.output,
+            reasoning: result.usage.reasoning,
+            cacheRead: result.usage.cacheRead,
+            cacheWrite: result.usage.cacheWrite,
+            totalTokens: result.usage.totalTokens
+        };
+        res.write('data: [DONE]\n\n');
+        res.end();
+        // Persist assistant message (fire-and-forget)
+        if (content) {
+            ctx.withPgClient(async (client) => {
+                await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
+           (thread_id, owner_id, entity_id, author_role, parts, model)
+           VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4, $5)`, [threadId, userId, 'assistant', JSON.stringify([{ type: 'text', text: content }]), model]);
+            }).catch((err) => log.error('Failed to persist assistant message:', err));
+        }
+        // Record billing usage + inference log (fire-and-forget)
+        if (billing && usage.totalTokens > 0) {
+            billing.recordUsage(meterSlug, usage.totalTokens, {
+                input_tokens: usage.input,
+                output_tokens: usage.output,
+                cache_read_tokens: usage.cacheRead,
+                cache_write_tokens: usage.cacheWrite,
+                model,
+                latency_ms: latencyMs,
+                stream: true
+            }).catch(() => { });
+            billing.logInference({
+                entityId, actorId: userId, model, provider: chatAdapter.provider,
+                service: 'llm', operation: 'chat',
+                inputTokens: usage.input, outputTokens: usage.output,
+                totalTokens: usage.totalTokens, latencyMs, status: 'ok'
+            }).catch(() => { });
+        }
+    }
+    catch (streamErr) {
+        log.error('Streaming error:', streamErr);
+        const errorEvent = { error: { message: streamErr.message, type: 'stream_error' } };
+        res.write(`data: ${JSON.stringify(errorEvent)}\n\n`);
+        res.write('data: [DONE]\n\n');
+        res.end();
+    }
+}
+async function handleBatchResponse(_req, res, mc) {
+    const { ctx, chatAdapter, model, llmMessages, body, entityId, userId, threadId, schemaName, threadTableName, messageTableName, billing, startTime, meterSlug } = mc;
+    const systemMsg = llmMessages.find(m => m.role === 'system');
+    const nonSystem = llmMessages.filter(m => m.role !== 'system');
+    const modelDesc = chatAdapter.adapter.createModel(model, { maxOutputTokens: undefined });
+    const context = {
+        systemPrompt: systemMsg?.content,
+        messages: nonSystem.map((m) => ({
+            role: m.role,
+            content: m.content,
+            timestamp: Date.now()
+        }))
+    };
+    const stream = chatAdapter.adapter.stream(modelDesc, context, {
+        temperature: body.temperature
+    });
+    const result = await stream.result();
+    const content = result.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+    const latencyMs = Date.now() - startTime;
+    const usage = {
+        input: result.usage.input,
+        output: result.usage.output,
+        reasoning: result.usage.reasoning,
+        cacheRead: result.usage.cacheRead,
+        cacheWrite: result.usage.cacheWrite,
+        totalTokens: result.usage.totalTokens
+    };
+    // Persist assistant message
+    await ctx.withPgClient(async (client) => {
+        await client.query(`INSERT INTO "${schemaName}"."${messageTableName}"
+       (thread_id, owner_id, entity_id, author_role, parts, model)
+       VALUES ($1, $2, (SELECT entity_id FROM "${schemaName}"."${threadTableName}" WHERE id = $1), $3, $4, $5)`, [threadId, userId, 'assistant', JSON.stringify([{ type: 'text', text: content }]), model]);
+    });
+    // Record billing + inference log (fire-and-forget)
+    if (billing && usage.totalTokens > 0) {
+        billing.recordUsage(meterSlug, usage.totalTokens, {
+            input_tokens: usage.input,
+            output_tokens: usage.output,
+            cache_read_tokens: usage.cacheRead,
+            cache_write_tokens: usage.cacheWrite,
+            model,
+            latency_ms: latencyMs,
+            stream: false
+        }).catch(() => { });
+        billing.logInference({
+            entityId, actorId: userId, model, provider: chatAdapter.provider,
+            service: 'llm', operation: 'chat',
+            inputTokens: usage.input, outputTokens: usage.output,
+            totalTokens: usage.totalTokens, latencyMs, status: 'ok'
+        }).catch(() => { });
+    }
+    res.json({
+        id: `msg_${Date.now()}`,
+        choices: [{
+                index: 0,
+                message: { role: 'assistant', content },
+                finish_reason: 'stop'
+            }],
+        model,
+        usage: {
+            prompt_tokens: usage.input,
+            completion_tokens: usage.output,
+            total_tokens: usage.totalTokens
+        }
+    });
+}
+// ─── Embedding Handler ──────────────────────────────────────────────────────
+async function handleEmbed(req, res) {
+    const ctx = req.constructive;
+    if (!ctx?.userId) {
+        res.status(401).json({ error: 'Authentication required' });
+        return;
+    }
+    const body = req.body || {};
+    if (!body.input) {
+        res.status(400).json({ error: 'input is required' });
+        return;
+    }
+    const llm = await ctx.useLlm();
+    const embedAdapter = resolveEmbeddingAdapter(llm);
+    if (!embedAdapter) {
+        res.status(503).json({ error: 'No embedding provider configured' });
+        return;
+    }
+    const model = body.model ?? embedAdapter.model;
+    const inputs = Array.isArray(body.input) ? body.input : [body.input];
+    // Resolve shared billing client
+    const billing = await ctx.useBilling();
+    // Quota check
+    if (billing) {
+        const allowed = await billing.checkQuota(model);
+        if (!allowed) {
+            res.status(429).json({ error: 'Embedding quota exceeded', meter: model });
+            return;
+        }
+    }
+    const startTime = Date.now();
+    try {
+        const results = await Promise.all(inputs.map((text) => embedAdapter.adapter.embed(text, model)));
+        const latencyMs = Date.now() - startTime;
+        const totalTokens = results.reduce((sum, r) => sum + r.promptTokens, 0);
+        // Record usage + inference log (fire-and-forget)
+        if (billing && totalTokens > 0) {
+            billing.recordUsage(model, totalTokens, {
+                input_tokens: totalTokens,
+                model,
+                latency_ms: latencyMs,
+                batch_size: inputs.length
+            }).catch(() => { });
+            billing.logInference({
+                entityId: ctx.userId,
+                actorId: ctx.userId,
+                model,
+                provider: embedAdapter.provider,
+                service: 'embedding',
+                operation: 'embed',
+                inputTokens: totalTokens,
+                outputTokens: 0,
+                totalTokens,
+                latencyMs,
+                status: 'ok'
+            }).catch(() => { });
+        }
+        res.json({
+            object: 'list',
+            data: results.map((r, i) => ({
+                object: 'embedding',
+                index: i,
+                embedding: r.embedding
+            })),
+            model,
+            usage: {
+                prompt_tokens: totalTokens,
+                total_tokens: totalTokens
+            }
+        });
+    }
+    catch (err) {
+        log.error('Embedding error:', err);
+        res.status(500).json({ error: err.message ?? 'Embedding failed' });
+    }
+}
+// ─── Router Factory ─────────────────────────────────────────────────────────
+export function createAgenticRouter() {
+    const router = Router();
+    router.use(express.json());
+    // Entity-scoped routes
+    router.post('/v1/orgs/:entity_id/threads', async (req, res) => {
+        try {
+            await handleCreateThread(req, res, req.params.entity_id);
+        }
+        catch (err) {
+            log.error('Error creating thread:', err);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    router.post('/v1/orgs/:entity_id/threads/:thread_id/messages', async (req, res) => {
+        try {
+            await handleSendMessage(req, res, req.params.entity_id);
+        }
+        catch (err) {
+            log.error('Error in messages endpoint:', err);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    // Global routes (entity_id = user_id from JWT)
+    router.post('/v1/threads', async (req, res) => {
+        try {
+            const userId = req.constructive?.userId;
+            if (!userId) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            await handleCreateThread(req, res, userId);
+        }
+        catch (err) {
+            log.error('Error creating thread:', err);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    router.post('/v1/threads/:thread_id/messages', async (req, res) => {
+        try {
+            const userId = req.constructive?.userId;
+            if (!userId) {
+                res.status(401).json({ error: 'Authentication required' });
+                return;
+            }
+            await handleSendMessage(req, res, userId);
+        }
+        catch (err) {
+            log.error('Error in messages endpoint:', err);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    // Embedding endpoint
+    router.post('/v1/embed', async (req, res) => {
+        try {
+            await handleEmbed(req, res);
+        }
+        catch (err) {
+            log.error('Error in embed endpoint:', err);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    return router;
+}

package/esm/diagnostics/debug-db-snapshot.js

@@ -1,6 +1,6 @@
+import { Pool } from 'pg';
 import { buildConnectionString, getPgPool } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
-import { Pool } from 'pg';
 const ACTIVE_ACTIVITY_SQL = `
   select
     pid,

package/esm/diagnostics/debug-memory-snapshot.js

@@ -1,6 +1,6 @@
 import os from 'node:os';
 import v8 from 'node:v8';
-import { svcCache, SVC_CACHE_TTL_MS } from '@pgpmjs/server-utils';
+import { SVC_CACHE_TTL_MS, svcCache } from '@pgpmjs/server-utils';
 import { getCacheStats } from 'graphile-cache';
 import { getInFlightCount, getInFlightKeys } from '../middleware/graphile';
 import { getGraphileBuildStats } from '../middleware/observability/graphile-build-stats';

package/esm/index.js

@@ -1,7 +1,7 @@
 export * from './server';
 // Export middleware for use in testing packages
-export { createApiMiddleware, getSubdomain, getApiConfig } from './middleware/api';
+export { createApiMiddleware, getApiConfig, getSubdomain } from './middleware/api';
 export { createAuthenticateMiddleware } from './middleware/auth';
 export { cors } from './middleware/cors';
-export { graphile } from './middleware/graphile';
 export { flush, flushService } from './middleware/flush';
+export { graphile } from './middleware/graphile';

package/esm/middleware/auth.js

@@ -1,10 +1,10 @@
+import './types'; // for Request type
 import { errors } from '@constructive-io/errors';
 import { getNodeEnv } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
 import { getPgPool } from 'pg-cache';
 import pgQueryContext from 'pg-query-context';
 import { respondWithGraphQLError } from '../errors/graphql-response';
-import './types'; // for Request type
 const log = new Logger('auth');
 const isDev = () => getNodeEnv() === 'development';
 /** Default cookie name for session tokens. */

package/esm/middleware/captcha.js

@@ -1,7 +1,7 @@
+import './types'; // for Request type
 import { errors } from '@constructive-io/errors';
 import { Logger } from '@pgpmjs/logger';
 import { respondWithGraphQLError } from '../errors/graphql-response';
-import './types'; // for Request type
 const log = new Logger('captcha');
 /** Google reCAPTCHA verification endpoint */
 const RECAPTCHA_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify';

package/esm/middleware/cors.js

@@ -1,6 +1,6 @@
+import './types'; // for Request type
 import { parseUrl } from '@constructive-io/url-domains';
 import corsPlugin from 'cors';
-import './types'; // for Request type
 /**
  * Unified CORS middleware for Constructive API
  *

package/esm/middleware/error-handler.js

@@ -1,9 +1,9 @@
+import './types';
 import { getNodeEnv } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
-import { isApiError } from '../errors/api-errors';
-import errorPage404Message from '../errors/404-message';
 import errorPage50x from '../errors/50x';
-import './types';
+import errorPage404Message from '../errors/404-message';
+import { isApiError } from '../errors/api-errors';
 const log = new Logger('error-handler');
 const isDevelopment = () => getNodeEnv() === 'development';
 const wantsJson = (req) => {

package/esm/middleware/fn.js

@@ -17,9 +17,9 @@
  * request's pgSettings (role + jwt.claims.* incl. jwt.claims.api_id) in a
  * transaction — RLS is fully enforced; no superuser or bypass path is used.
  */
+import { QueryBuilder } from '@constructive-io/query-builder';
 import { Logger } from '@pgpmjs/logger';
 import { isUuid } from '@pgpmjs/server-utils';
-import { QueryBuilder } from '@constructive-io/query-builder';
 import express, { Router } from 'express';
 const log = new Logger('fn');
 const notFound = (res) => {

package/esm/middleware/observability/request-logger.js

@@ -1,5 +1,5 @@
-import { randomUUID } from 'crypto';
 import { Logger } from '@pgpmjs/logger';
+import { randomUUID } from 'crypto';
 const log = new Logger('server');
 const SAFE_REQUEST_ID = /^[a-zA-Z0-9\-_]{1,128}$/;
 export const createRequestLogger = ({ observabilityEnabled }) => {

package/esm/plugins/auth-cookie-plugin.js

@@ -1,6 +1,6 @@
-import { Logger } from '@pgpmjs/logger';
 import '../middleware/types';
-import { SESSION_COOKIE_NAME, DEVICE_TOKEN_COOKIE_NAME, getSessionCookieConfig, getDeviceTokenCookieConfig, } from '../middleware/cookie';
+import { Logger } from '@pgpmjs/logger';
+import { DEVICE_TOKEN_COOKIE_NAME, getDeviceTokenCookieConfig, getSessionCookieConfig, SESSION_COOKIE_NAME, } from '../middleware/cookie';
 const log = new Logger('auth-cookie');
 /**
  * Serialize a cookie to a Set-Cookie header value.

package/esm/server.js

@@ -4,13 +4,13 @@ import { getEnvOptions } from '@constructive-io/graphql-env';
 import { middleware as parseDomains } from '@constructive-io/url-domains';
 import { Logger } from '@pgpmjs/logger';
 import { healthz, poweredBy, svcCache, trustProxy } from '@pgpmjs/server-utils';
-import { createAgenticRouter } from 'agentic-server';
 import cookieParser from 'cookie-parser';
 import express from 'express';
 import { closeAllCaches, graphileCache } from 'graphile-cache';
 import graphqlUpload from 'graphql-upload';
 import { getPgPool } from 'pg-cache';
 import requestIp from 'request-ip';
+import { createAgenticRouter } from './agentic';
 import { closeDebugDatabasePools } from './diagnostics/debug-db-snapshot';
 import { startDebugSampler } from './diagnostics/debug-sampler';
 import { isDevelopmentObservabilityMode, isGraphqlObservabilityEnabled, isGraphqlObservabilityRequested, isLoopbackHost } from './diagnostics/observability';

package/index.d.ts

@@ -1,6 +1,6 @@
 export * from './server';
-export { createApiMiddleware, getSubdomain, getApiConfig } from './middleware/api';
+export { createApiMiddleware, getApiConfig, getSubdomain } from './middleware/api';
 export { createAuthenticateMiddleware } from './middleware/auth';
 export { cors } from './middleware/cors';
-export { graphile } from './middleware/graphile';
 export { flush, flushService } from './middleware/flush';
+export { graphile } from './middleware/graphile';

package/index.js

@@ -14,19 +14,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flushService = exports.flush = exports.graphile = exports.cors = exports.createAuthenticateMiddleware = exports.getApiConfig = exports.getSubdomain = exports.createApiMiddleware = void 0;
+exports.graphile = exports.flushService = exports.flush = exports.cors = exports.createAuthenticateMiddleware = exports.getSubdomain = exports.getApiConfig = exports.createApiMiddleware = void 0;
 __exportStar(require("./server"), exports);
 // Export middleware for use in testing packages
 var api_1 = require("./middleware/api");
 Object.defineProperty(exports, "createApiMiddleware", { enumerable: true, get: function () { return api_1.createApiMiddleware; } });
-Object.defineProperty(exports, "getSubdomain", { enumerable: true, get: function () { return api_1.getSubdomain; } });
 Object.defineProperty(exports, "getApiConfig", { enumerable: true, get: function () { return api_1.getApiConfig; } });
+Object.defineProperty(exports, "getSubdomain", { enumerable: true, get: function () { return api_1.getSubdomain; } });
 var auth_1 = require("./middleware/auth");
 Object.defineProperty(exports, "createAuthenticateMiddleware", { enumerable: true, get: function () { return auth_1.createAuthenticateMiddleware; } });
 var cors_1 = require("./middleware/cors");
 Object.defineProperty(exports, "cors", { enumerable: true, get: function () { return cors_1.cors; } });
-var graphile_1 = require("./middleware/graphile");
-Object.defineProperty(exports, "graphile", { enumerable: true, get: function () { return graphile_1.graphile; } });
 var flush_1 = require("./middleware/flush");
 Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return flush_1.flush; } });
 Object.defineProperty(exports, "flushService", { enumerable: true, get: function () { return flush_1.flushService; } });
+var graphile_1 = require("./middleware/graphile");
+Object.defineProperty(exports, "graphile", { enumerable: true, get: function () { return graphile_1.graphile; } });

package/middleware/auth.d.ts

@@ -1,4 +1,4 @@
+import './types';
 import { PgpmOptions } from '@pgpmjs/types';
 import { RequestHandler } from 'express';
-import './types';
 export declare const createAuthenticateMiddleware: (opts: PgpmOptions) => RequestHandler;

package/middleware/auth.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAuthenticateMiddleware = void 0;
+require("./types"); // for Request type
 const errors_1 = require("@constructive-io/errors");
 const env_1 = require("@pgpmjs/env");
 const logger_1 = require("@pgpmjs/logger");
 const pg_cache_1 = require("pg-cache");
 const pg_query_context_1 = __importDefault(require("pg-query-context"));
 const graphql_response_1 = require("../errors/graphql-response");
-require("./types"); // for Request type
 const log = new logger_1.Logger('auth');
 const isDev = () => (0, env_1.getNodeEnv)() === 'development';
 /** Default cookie name for session tokens. */