@memberjunction/server 6.2.0-edge.1 → 6.2.0-edge.3

package/src/resolvers/AdhocQueryResolver.ts

@@ -1,14 +1,14 @@
 import { Arg, Ctx, Query, Resolver, Field, Int, InputType } from 'type-graphql';
-import { DatabasePlatform, LogError } from '@memberjunction/core';
-import { SQLExpressionValidator } from '@memberjunction/global';
+import { LogError } from '@memberjunction/core';
+import type { DatabasePlatform, IMetadataProvider, RunQueryResult, UserInfo } from '@memberjunction/core';
 import { RenderPipeline } from '@memberjunction/generic-database-provider';
 import { AppContext } from '../types.js';
-import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
+import { configInfo } from '../config.js';
+import { GetReadOnlyProvider } from '../util.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { IsScopeLimitedPrincipal } from '../auth/scopeLimitedPrincipal.js';
 import { RunQueryResultType } from './QueryResolver.js';
-import { ExactTotalFromPage, ResolveAdhocTotalRowCount } from './adhoc-query-helpers.js';
-import sql from 'mssql';
+import { ClampAdhocTimeoutSeconds } from './adhocTimeout.js';
 
 /**
  * Input type for executing ad-hoc SQL queries directly.
@@ -32,10 +32,19 @@ class AdhocQueryInput {
 /**
  * Resolver for executing ad-hoc (unsaved) SQL queries.
  *
+ * The query runs through the read-only provider's own ad-hoc path (`RunQuery` with `SQL`), the
+ * same one in-process callers use, so it behaves identically on every database platform: the SQL
+ * is validated and rendered there, paged in the database with a count, run under the caller's
+ * timeout, and on PostgreSQL inside a read-only transaction that is rolled back.
+ *
  * Security:
- * - SQL validated via SQLExpressionValidator (full_query context) — blocks mutations, dangerous operations
- * - Executes on read-only connection pool only (no fallback to read-write)
- * - Configurable timeout (default 30s)
+ * - SQL validated by the provider (SQLExpressionValidator, single read query) — blocks mutations
+ * - Authorizes the RENDERED SQL: every table reference must be an entity base view the caller
+ *   reads unscoped (CanRead, no row-level filter, no denied fields). Entities with row/field
+ *   policy for this user are refused — raw SQL cannot apply that policy, so those reads belong
+ *   on RunView.
+ * - Read-only provider only (no fallback to read-write)
+ * - Configurable timeout (default 30s), enforced by the database
  * - Requires authenticated user (standard GraphQL auth, no @RequireSystemUser)
  * - Refuses scope-limited principals (see {@link IsScopeLimitedPrincipal}). Raw SQL bypasses
  *   RunView, entity permissions and row-level security, so the RLS scope tokens that confine a
@@ -52,201 +61,92 @@ export class AdhocQueryResolver extends ResolverBase {
         @Ctx() context: AppContext
     ): Promise<RunQueryResultType> {
         const startTime = Date.now();
-
+        // SECURITY: refuse principals whose read authority is narrower than their role grant.
+        // Ad-hoc SQL does not go through RunView, entity permissions or row-level security, so the
+        // RLS scope tokens that confine a magic-link session are never substituted. There is no
+        // filter to narrow, so the only correct answer for such a principal is no.
+        if (IsScopeLimitedPrincipal(context.userPayload?.userRecord)) {
+            return this.buildErrorResult('Ad-hoc SQL execution is not permitted for scope-limited sessions.');
+        }
+        const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: false });
+        if (!provider) {
+            return this.buildErrorResult('No read-only data source available for ad-hoc query execution');
+        }
+        const contextUser = context.userPayload?.userRecord;
+        const refusal = this.authorizeRenderedSQL(input.SQL, provider.PlatformKey, context, contextUser);
+        if (refusal) {
+            return this.buildErrorResult(refusal, Date.now() - startTime);
+        }
+        const timeoutSeconds = ClampAdhocTimeoutSeconds(input.TimeoutSeconds, configInfo.databaseSettings.requestTimeout);
+        // A negative offset must not reach paging, where it would turn paging off.
+        const startRow = Math.max(0, Number.isInteger(input.StartRow) ? input.StartRow! : 0);
         try {
-            // 1. SECURITY: refuse principals whose read authority is narrower than their role
-            // grant. This resolver runs a raw SELECT on the read-only pool — it does NOT go
-            // through RunView, entity permissions or row-level security, so the RLS scope tokens
-            // that confine a magic-link session are never substituted here. There is no filter
-            // to narrow, so the only correct answer for such a principal is no. Checked before
-            // the SQL is even validated: authorization gates the work, it does not race it.
-            if (IsScopeLimitedPrincipal(context.userPayload?.userRecord)) {
-                return this.buildErrorResult('Ad-hoc SQL execution is not permitted for scope-limited sessions.');
-            }
-
-            // 2. Security: validate SQL using SQLExpressionValidator
-            const validator = SQLExpressionValidator.Instance;
-            const validation = validator.validateFullQuery(input.SQL);
-            if (!validation.valid) {
-                return this.buildErrorResult(validation.error || 'SQL validation failed');
-            }
-
-            // 3. Get READ-ONLY data source (no fallback to read-write)
-            let readOnlyDS: sql.ConnectionPool;
-            try {
-                readOnlyDS = GetReadOnlyDataSource(context.dataSources, { allowFallbackToReadWrite: false });
-            } catch {
-                return this.buildErrorResult('No read-only data source available for ad-hoc query execution');
-            }
-
-            // 4. Resolve platform from the read-only provider for the render pipeline.
-            let platform: DatabasePlatform = 'sqlserver';
-            try {
-                const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: false });
-                if (provider?.PlatformKey) platform = provider.PlatformKey;
-            } catch {
-                // Provider not configured — keep the default platform.
-            }
-            const contextUser = context.userPayload?.userRecord;
-
-            // 5. Route the SQL through RenderPipeline so composition tokens
-            // resolve, comments and templates are processed, and the row cap
-            // is applied at the database (via TOP / LIMIT / OFFSET-FETCH).
-            //
-            // Page whenever a positive MaxRows is requested — INCLUDING the first
-            // page (StartRow 0). This yields OFFSET/FETCH data SQL *and* a
-            // COUNT(*) query so the response reports the true total row count
-            // rather than just the returned page size. It mirrors the saved-query
-            // path (GenericDatabaseProvider.InternalRunQuery → WrapWithPaging).
-            // (Previously paging was gated on StartRow > 0, so page 1 fell back to
-            // a TOP-N cap with TotalRowCount = page size — hiding the pager.)
-            // Clamp StartRow to a non-negative integer. A negative offset must not slip
-            // past the paging gate (which would then run the query with no row cap at all).
-            const startRow = Math.max(0, Number.isInteger(input.StartRow) ? input.StartRow! : 0);
-            const maxRows = input.MaxRows;
-            const usePaging = maxRows != null && Number.isInteger(maxRows) && maxRows > 0;
-
-            let dataSQL: string;
-            let countSQL: string | null = null;
-            try {
-                const rendered = RenderPipeline.Run(input.SQL, {
-                    Platform: platform,
-                    ContextUser: contextUser,
-                    ...(usePaging ? { Paging: { StartRow: startRow, MaxRows: maxRows! } } : {}),
-                });
-                dataSQL = rendered.FinalSQL;
-                countSQL = rendered.PagingResult?.CountSQL ?? null;
-            } catch (renderErr) {
-                const renderMsg = renderErr instanceof Error ? renderErr.message : String(renderErr);
-                return this.buildErrorResult(`Ad-hoc query rendering failed: ${renderMsg}`);
-            }
-
-            // 6. Execute the page (and, only when a full page needs it, the count) under
-            // a shared wall-clock deadline derived from the request's timeout budget.
-            const deadline = startTime + (input.TimeoutSeconds ?? 30) * 1000;
-            const { recordset, totalRowCount } = await this.executeDataAndCount(
-                readOnlyDS, dataSQL, countSQL, startRow, usePaging ? maxRows! : null, deadline
-            );
-            const executionTimeMs = Date.now() - startTime;
-
-            // 7. Return as RunQueryResultType
-            return {
-                QueryID: '',
-                QueryName: 'Ad-Hoc Query',
-                Success: true,
-                Results: JSON.stringify(recordset),
-                RowCount: recordset.length,
-                TotalRowCount: totalRowCount,
-                PageNumber: usePaging ? Math.floor(startRow / maxRows!) + 1 : undefined,
-                PageSize: usePaging ? maxRows! : undefined,
-                ExecutionTime: executionTimeMs,
-                ErrorMessage: ''
-            };
+            const result = await provider.RunQuery({
+                SQL: input.SQL,
+                MaxRows: input.MaxRows,
+                StartRow: startRow,
+                TimeoutSeconds: timeoutSeconds,
+            }, contextUser);
+            return this.toResultType(result, startRow, input.MaxRows, timeoutSeconds, Date.now() - startTime);
         } catch (err: unknown) {
-            const executionTimeMs = Date.now() - startTime;
             const errorMessage = err instanceof Error ? err.message : String(err);
-
-            // Handle timeout
-            if (errorMessage.includes('timeout') || errorMessage.includes('Timeout')) {
-                return {
-                    QueryID: '',
-                    QueryName: 'Ad-Hoc Query',
-                    Success: false,
-                    Results: '[]',
-                    RowCount: 0,
-                    TotalRowCount: 0,
-                    PageNumber: undefined,
-                    PageSize: undefined,
-                    ExecutionTime: executionTimeMs,
-                    ErrorMessage: `Query execution exceeded ${input.TimeoutSeconds ?? 30} second timeout`
-                };
-            }
-
             LogError(`Ad-hoc query execution failed: ${errorMessage}`);
-            return {
-                QueryID: '',
-                QueryName: 'Ad-Hoc Query',
-                Success: false,
-                Results: '[]',
-                RowCount: 0,
-                TotalRowCount: 0,
-                PageNumber: undefined,
-                PageSize: undefined,
-                ExecutionTime: executionTimeMs,
-                ErrorMessage: `Query execution failed: ${errorMessage}`
-            };
+            return this.buildErrorResult(`Query execution failed: ${errorMessage}`, Date.now() - startTime);
         }
     }
 
     /**
-     * Runs the page's data SQL, then — only when the page is FULL (so more rows may
-     * exist) — a COUNT(*) for the true total. A short (or unpaged) page needs no
-     * count: the exact total is `startRow + rowsReturned` (see {@link exactTotalFromPage}).
-     *
-     * The count is NON-FATAL: some queries page fine but cannot be counted — e.g.
-     * duplicate column names are legal in a result set but rejected inside the COUNT
-     * CTE wrap. A count failure must never sink the whole result, so we log it and
-     * report a lower-bound total (`startRow + rowsReturned`) and let the data render.
+     * SECURITY: authorizes the READ itself, against the SQL that will actually run. The provider
+     * validates that the SQL is a single read statement but places no restriction on WHAT is read.
+     * Rendering comes first because composition (`{{query:"..."}}`) and templates can introduce
+     * table references the raw input never named. Every table reference must be an entity base
+     * view the caller can read UNSCOPED — CanRead with no row-level filter and no denied fields —
+     * because raw SQL applies neither (see assertFullQueryUsesReadableEntityViews). The provider
+     * renders the same input the same way and only wraps it in server-built paging and a count,
+     * so the rendered SQL is the full set of reads. Returns the refusal message, or null.
      */
-    private async executeDataAndCount(
-        ds: sql.ConnectionPool,
-        dataSQL: string,
-        countSQL: string | null,
-        startRow: number,
-        maxRows: number | null,
-        deadline: number,
-    ): Promise<{ recordset: Record<string, unknown>[]; totalRowCount: number }> {
-        const dataResult = await this.runSqlWithDeadline<Record<string, unknown>>(ds, dataSQL, deadline);
-        const recordset = (dataResult.recordset ?? []) as Record<string, unknown>[];
-
-        // Total already known from the page alone (unpaged, or a short page)? Skip the count.
-        const exact = ExactTotalFromPage(startRow, recordset.length, maxRows);
-        if (exact != null || !countSQL) {
-            return { recordset, totalRowCount: exact ?? recordset.length };
-        }
-
-        // Full page — a COUNT(*) is required to know the true total.
-        const lowerBound = startRow + recordset.length;
+    private authorizeRenderedSQL(sqlText: string, platform: DatabasePlatform, context: AppContext, contextUser: UserInfo | undefined): string | null {
         try {
-            const countResult = await this.runSqlWithDeadline<{ TotalRowCount: number }>(ds, countSQL, deadline);
-            return { recordset, totalRowCount: ResolveAdhocTotalRowCount(countResult.recordset, lowerBound) };
-        } catch (countErr) {
-            const msg = countErr instanceof Error ? countErr.message : String(countErr);
-            LogError(`Ad-hoc query row-count failed; reporting a lower-bound total (${lowerBound}). ${msg}`);
-            return { recordset, totalRowCount: lowerBound };
+            const rendered = RenderPipeline.Run(sqlText, { Platform: platform, ContextUser: contextUser, RequireReadStatement: true });
+            const mdProvider: IMetadataProvider | undefined = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true }) ?? undefined;
+            this.assertFullQueryUsesReadableEntityViews(rendered.Trace.AfterTemplates, mdProvider, contextUser, 'ad-hoc SQL');
+            return null;
+        } catch (err) {
+            return err instanceof Error ? err.message : String(err);
         }
     }
 
-    /**
-     * Executes one SQL statement on the read-only pool, racing it against the shared
-     * wall-clock `deadline`. The timer is always cleared on completion so a settled
-     * query never leaves a dangling timeout armed.
-     */
-    private async runSqlWithDeadline<T>(
-        ds: sql.ConnectionPool,
-        sqlText: string,
-        deadline: number,
-    ): Promise<sql.IResult<T>> {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) {
-            throw new Error('Query timeout exceeded');
-        }
-        let timer: ReturnType<typeof setTimeout> | undefined;
-        try {
-            return await Promise.race([
-                new sql.Request(ds).query<T>(sqlText),
-                new Promise<never>((_, reject) => {
-                    timer = setTimeout(() => reject(new Error('Query timeout exceeded')), remaining);
-                }),
-            ]);
-        } finally {
-            if (timer) {
-                clearTimeout(timer);
-            }
+    /** Maps the provider's result to the GraphQL shape, naming a timeout plainly. */
+    private toResultType(
+        result: RunQueryResult,
+        startRow: number,
+        maxRows: number | undefined,
+        timeoutSeconds: number,
+        executionTimeMs: number,
+    ): RunQueryResultType {
+        if (!result.Success) {
+            const message = result.ErrorMessage ?? 'Ad-hoc query failed';
+            return this.buildErrorResult(
+                /timeout/i.test(message) ? `Query execution exceeded ${timeoutSeconds} second timeout` : message,
+                executionTimeMs,
+            );
         }
+        const paged = maxRows != null && Number.isInteger(maxRows) && maxRows > 0;
+        return {
+            QueryID: '',
+            QueryName: 'Ad-Hoc Query',
+            Success: true,
+            Results: JSON.stringify(result.Results),
+            RowCount: result.RowCount,
+            TotalRowCount: result.TotalRowCount,
+            PageNumber: paged ? Math.floor(startRow / maxRows!) + 1 : undefined,
+            PageSize: paged ? maxRows : undefined,
+            ExecutionTime: executionTimeMs,
+            ErrorMessage: ''
+        };
     }
 
-    private buildErrorResult(errorMessage: string): RunQueryResultType {
+    private buildErrorResult(errorMessage: string, executionTimeMs = 0): RunQueryResultType {
         return {
             QueryID: '',
             QueryName: 'Ad-Hoc Query',
@@ -256,7 +156,7 @@ export class AdhocQueryResolver extends ResolverBase {
             TotalRowCount: 0,
             PageNumber: undefined,
             PageSize: undefined,
-            ExecutionTime: 0,
+            ExecutionTime: executionTimeMs,
             ErrorMessage: errorMessage
         };
     }

package/src/resolvers/AgentRunStatusPublisher.ts

@@ -0,0 +1,175 @@
+/**
+ * Publishes one agent run's live status on the caller's session.
+ *
+ * `RunAIAgentResolver` uses this for every status it sends. A host whose
+ * `AgentTurnHandler` answers with an In-Progress reply uses the same publisher,
+ * on that caller's session, so the chat follows the turn: significant-step
+ * progress, streamed text, the partial result, and the completion. When the
+ * turn throws instead of returning a result, call `PublishFailure` with the
+ * reply row's id and the error.
+ */
+import type { PubSubEngine } from 'type-graphql';
+import type {
+    AgentExecutionProgressCallback,
+    AgentExecutionStreamingCallback,
+    ExecuteAgentResult,
+} from '@memberjunction/ai-core-plus';
+import type { UserPayload } from '../types.js';
+import { PublishStatusUpdate } from '../generic/PushStatusResolver.js';
+
+const SIGNIFICANT_STEPS = ['prompt_execution', 'action_execution', 'subagent_execution', 'decision_processing'];
+
+/** The run fields the published messages read. Entities and test fakes both satisfy this. */
+interface StatusRun {
+    ID?: string;
+    ConversationDetailID?: string;
+    ErrorMessage?: string;
+    Steps?: Array<{ StepName?: string }>;
+    GetAll?: () => unknown;
+}
+
+export class AgentRunStatusPublisher {
+    private run: StatusRun | null = null;
+
+    /**
+     * @param sessionId Session stamped on the message body. Defaults to the payload's session.
+     *   The push itself is always addressed to `userPayload.sessionId`, matching the resolver.
+     */
+    constructor(
+        private readonly pubSub: PubSubEngine,
+        private readonly userPayload: UserPayload,
+        private readonly sessionId: string = userPayload.sessionId,
+    ) {}
+
+    /** Latest run observed from a progress event, including steps that are not published. */
+    public get AgentRun(): StatusRun | null {
+        return this.run;
+    }
+
+    /** AgentRunner's progress callback. Noise steps are kept for {@link AgentRun} and not published. */
+    public get OnProgress(): AgentExecutionProgressCallback {
+        return (progress) => {
+            const fromEvent = progress.metadata?.agentRun as StatusRun | undefined;
+            if (fromEvent) {
+                this.run = fromEvent;
+            }
+            if (!SIGNIFICANT_STEPS.includes(progress.step)) {
+                return;
+            }
+            const agentRun = fromEvent || this.run;
+            if (!agentRun?.ID) {
+                // A host that streams before the first progress event otherwise sees nothing and no reason.
+                console.error('❌ No agent run available for progress callback');
+                return;
+            }
+            this.publish('ExecutionProgress', {
+                sessionId: this.sessionId,
+                agentRunId: agentRun.ID,
+                type: 'progress',
+                agentRun: agentRun.GetAll ? agentRun.GetAll() : agentRun,
+                progress: {
+                    currentStep: progress.step,
+                    percentage: progress.percentage,
+                    message: progress.message,
+                    agentName: progress.metadata?.agentName,
+                    agentType: progress.metadata?.agentType,
+                    stepCount: progress.metadata?.stepCount,
+                    hierarchicalStep: progress.metadata?.hierarchicalStep,
+                },
+                timestamp: new Date(),
+            });
+        };
+    }
+
+    /** AgentRunner's streaming callback. Publishes nothing until a progress event has carried the run. */
+    public get OnStreaming(): AgentExecutionStreamingCallback {
+        return (chunk) => {
+            const agentRun = this.run;
+            if (!agentRun?.ID) {
+                console.error('❌ No agent run available for streaming callback');
+                return;
+            }
+            this.publish('StreamingContent', {
+                sessionId: this.sessionId,
+                agentRunId: agentRun.ID,
+                type: 'streaming',
+                agentRun: agentRun.GetAll ? agentRun.GetAll() : agentRun,
+                streaming: {
+                    content: chunk.content,
+                    isPartial: !chunk.isComplete,
+                    stepName: chunk.stepType,
+                    agentName: chunk.modelName,
+                    kind: chunk.kind,
+                },
+                timestamp: new Date(),
+            });
+        };
+    }
+
+    /**
+     * The partial result, then the completion. `conversationDetailId` is the reply row the
+     * chat should update. When omitted, the completion uses the run's own detail id.
+     */
+    public PublishFinal(result: ExecuteAgentResult, conversationDetailId?: string, resultJson?: string): void {
+        const agentRun = result.agentRun as StatusRun | undefined;
+        if (agentRun?.ID) {
+            let lastStep = 'Completed';
+            const steps = agentRun.Steps;
+            if (steps && steps.length > 0) {
+                lastStep = steps[steps.length - 1]?.StepName || 'Completed';
+            }
+            this.publish('StreamingContent', {
+                sessionId: this.sessionId,
+                agentRunId: agentRun.ID,
+                type: 'partial_result',
+                partialResult: {
+                    currentStep: lastStep,
+                    partialOutput: result.payload || undefined,
+                },
+                timestamp: new Date(),
+            });
+        }
+        this.publish('StreamingContent', {
+            sessionId: this.sessionId,
+            agentRunId: agentRun?.ID || 'unknown',
+            type: 'complete',
+            timestamp: new Date(),
+            conversationDetailId: conversationDetailId || agentRun?.ConversationDetailID,
+            success: result.success,
+            errorMessage: agentRun?.ErrorMessage || undefined,
+            result: resultJson || undefined,
+        });
+    }
+
+    /**
+     * Completion for a failure that has no run. The fire-and-forget path uses this when
+     * `executeAIAgent` rejects. A host uses it the same way: when the turn throws
+     * instead of returning a result, call `PublishFailure` with the reply row's id
+     * and the error. That completion is what tells the chat the reply finished.
+     */
+    public PublishFailure(conversationDetailId: string | undefined, errorMessage: string): void {
+        this.publish('StreamingContent', {
+            sessionId: this.sessionId,
+            agentRunId: 'unknown',
+            type: 'complete',
+            timestamp: new Date(),
+            conversationDetailId,
+            success: false,
+            errorMessage,
+            result: JSON.stringify({ success: false, errorMessage }),
+        });
+    }
+
+    private publish(type: 'ExecutionProgress' | 'StreamingContent', data: unknown): void {
+        PublishStatusUpdate(this.pubSub, {
+            sessionId: this.userPayload.sessionId,
+            ownerUserId: this.userPayload?.userRecord?.ID ?? '',
+            message: JSON.stringify({
+                resolver: 'RunAIAgentResolver',
+                type,
+                status: 'ok',
+                data,
+            }),
+        });
+    }
+}