@memberjunction/server 5.36.0 → 5.37.0

package/src/agents/skip-sdk.ts

@@ -24,7 +24,8 @@ import {
     SkipAPIArtifactType
 } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
-import { IMetadataProvider, UserInfo, LogStatus, LogError, Metadata, RunQuery, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
+import { IMetadataProvider, UserInfo, LogStatus, LogError, Metadata, RunQuery, RunView, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
+import { MJConversationDetailEntity } from '@memberjunction/core-entities';
 import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { gzip as gzipCompress, createGunzip } from 'zlib';
@@ -682,6 +683,16 @@ export class SkipSDK {
                 versions: entry.versions
             }));
 
+            // Also include INPUT artifacts (e.g., user-captured Data Snapshots
+            // attached to messages via the Analyze button or
+            // client:capture-data-snapshot actionable command). The query above
+            // only returns Direction='Output' artifacts produced BY Skip — but
+            // Skip also needs to see artifacts the user gave it as input.
+            const inputArtifacts = await this.buildInputArtifacts(contextUser, conversationId, artifactMap);
+            if (inputArtifacts.length > 0) {
+                artifacts.push(...inputArtifacts);
+            }
+
             return artifacts;
         } catch (error) {
             LogError(`Failed to build artifacts for conversation ${conversationId}: ${error}`);
@@ -689,6 +700,142 @@ export class SkipSDK {
         }
     }
 
+    /**
+     * Fetch INPUT artifacts attached to user messages in this conversation
+     * (Direction='Input' on ConversationDetailArtifact). Skip should see these
+     * so it can use captured Data Snapshots, user-uploaded files, etc., in
+     * its analysis.
+     *
+     * Deduplicates against `alreadyLoaded` (the Output artifacts) so the same
+     * artifact ID doesn't appear twice if it was both produced and re-attached.
+     */
+    private async buildInputArtifacts(
+        contextUser: UserInfo,
+        conversationId: string,
+        alreadyLoaded: Map<string, { artifact: any; artifactType: SkipAPIArtifactType; versions: SkipAPIArtifactVersion[] }>
+    ): Promise<SkipAPIArtifact[]> {
+        try {
+            const rv = new RunView();
+            // Pull conversation detail IDs in this conversation
+            const detailsResult = await rv.RunView<MJConversationDetailEntity>({
+                EntityName: 'MJ: Conversation Details',
+                ExtraFilter: `ConversationID='${conversationId}'`,
+                Fields: ['ID'],
+                ResultType: 'simple',
+            }, contextUser);
+            const detailIds = detailsResult.Success && detailsResult.Results
+                ? (detailsResult.Results as { ID: string }[]).map(r => r.ID)
+                : [];
+            if (detailIds.length === 0) return [];
+
+            // Junction rows where Direction='Input' for those details
+            const junctionResult = await rv.RunView({
+                EntityName: 'MJ: Conversation Detail Artifacts',
+                ExtraFilter: `ConversationDetailID IN ('${detailIds.join("','")}') AND Direction='Input'`,
+                Fields: ['ArtifactVersionID', 'ConversationDetailID'],
+                ResultType: 'simple',
+            }, contextUser);
+            const junctions = junctionResult.Success && junctionResult.Results
+                ? (junctionResult.Results as { ArtifactVersionID: string; ConversationDetailID: string }[])
+                : [];
+            if (junctions.length === 0) return [];
+
+            // Load each ArtifactVersion + its parent Artifact + ArtifactType
+            const versionIds = [...new Set(junctions.map(j => j.ArtifactVersionID))];
+            const versionsResult = await rv.RunView({
+                EntityName: 'MJ: Artifact Versions',
+                ExtraFilter: `ID IN ('${versionIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const versions = versionsResult.Success && versionsResult.Results
+                ? (versionsResult.Results as Record<string, any>[])
+                : [];
+            if (versions.length === 0) return [];
+
+            const artifactIds = [...new Set(versions.map(v => v.ArtifactID as string))];
+            const artifactsResult = await rv.RunView({
+                EntityName: 'MJ: Artifacts',
+                ExtraFilter: `ID IN ('${artifactIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const artifactRows = artifactsResult.Success && artifactsResult.Results
+                ? (artifactsResult.Results as Record<string, any>[])
+                : [];
+
+            const typeIds = [...new Set(artifactRows.map(a => a.TypeID as string))];
+            const typesResult = await rv.RunView({
+                EntityName: 'MJ: Artifact Types',
+                ExtraFilter: `ID IN ('${typeIds.join("','")}')`,
+                ResultType: 'simple',
+            }, contextUser);
+            const typeRows = typesResult.Success && typesResult.Results
+                ? (typesResult.Results as Record<string, any>[])
+                : [];
+            const typeMap = new Map<string, Record<string, any>>(typeRows.map(t => [t.ID as string, t]));
+
+            // Build a junction lookup: artifactVersionId -> conversationDetailId
+            const versionToDetail = new Map(junctions.map(j => [j.ArtifactVersionID, j.ConversationDetailID]));
+
+            // Build SkipAPIArtifact entries
+            const inputArtifactMap = new Map<string, { artifact: any; artifactType: SkipAPIArtifactType; versions: SkipAPIArtifactVersion[] }>();
+            for (const v of versions) {
+                const aRow = artifactRows.find(a => UUIDsEqual(a.ID, v.ArtifactID));
+                if (!aRow) continue;
+                if (alreadyLoaded.has(aRow.ID as string)) continue; // dedup
+
+                const typeRow = typeMap.get(aRow.TypeID as string);
+                if (!typeRow) continue;
+
+                let entry = inputArtifactMap.get(aRow.ID as string);
+                if (!entry) {
+                    entry = {
+                        artifact: {
+                            id: aRow.ID,
+                            conversationId,
+                            name: aRow.Name,
+                            description: aRow.Description || '',
+                            sharingScope: 'None',
+                            comments: aRow.Comments || '',
+                            createdAt: new Date(aRow.__mj_CreatedAt),
+                            updatedAt: new Date(aRow.__mj_UpdatedAt),
+                        },
+                        artifactType: {
+                            id: typeRow.ID,
+                            name: typeRow.Name,
+                            description: typeRow.Description,
+                            contentType: typeRow.ContentType,
+                            enabled: true,
+                            createdAt: new Date(typeRow.__mj_CreatedAt),
+                            updatedAt: new Date(typeRow.__mj_UpdatedAt),
+                        },
+                        versions: [],
+                    };
+                    inputArtifactMap.set(aRow.ID as string, entry);
+                }
+                entry.versions.push({
+                    id: v.ID,
+                    artifactId: v.ArtifactID,
+                    conversationDetailID: versionToDetail.get(v.ID) ?? '',
+                    version: v.VersionNumber,
+                    configuration: v.Configuration || '',
+                    content: v.Content || '',
+                    comments: v.Comments || '',
+                    createdAt: new Date(v.__mj_CreatedAt),
+                    updatedAt: new Date(v.__mj_UpdatedAt),
+                });
+            }
+
+            return Array.from(inputArtifactMap.values()).map(entry => ({
+                ...entry.artifact,
+                artifactType: entry.artifactType,
+                versions: entry.versions,
+            }));
+        } catch (error) {
+            LogError(`Failed to load input artifacts for conversation ${conversationId}: ${error}`);
+            return [];
+        }
+    }
+
     /**
      * Build API keys for AI services
      */

package/src/resolvers/AdhocQueryResolver.ts

@@ -1,8 +1,9 @@
 import { Arg, Ctx, Query, Resolver, Field, Int, InputType } from 'type-graphql';
-import { LogError } from '@memberjunction/core';
+import { DatabasePlatform, LogError } from '@memberjunction/core';
 import { SQLExpressionValidator } from '@memberjunction/global';
+import { RenderPipeline } from '@memberjunction/generic-database-provider';
 import { AppContext } from '../types.js';
-import { GetReadOnlyDataSource } from '../util.js';
+import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { RunQueryResultType } from './QueryResolver.js';
 import sql from 'mssql';
@@ -19,10 +20,10 @@ class AdhocQueryInput {
     @Field(() => Int, { nullable: true, description: 'Query timeout in seconds. Defaults to 30.' })
     TimeoutSeconds?: number;
 
-    @Field(() => Int, { nullable: true, description: 'Maximum number of rows to return. Applied in-memory after SQL execution; SQL still runs unbounded server-side.' })
+    @Field(() => Int, { nullable: true, description: 'Maximum number of rows to return; applied at the database via the render pipeline.' })
     MaxRows?: number;
 
-    @Field(() => Int, { nullable: true, description: 'Zero-based offset for pagination. Used in conjunction with MaxRows.' })
+    @Field(() => Int, { nullable: true, description: 'Zero-based offset for pagination. When > 0, the row cap switches to OFFSET/FETCH pagination.' })
     StartRow?: number;
 }
 
@@ -62,25 +63,45 @@ export class AdhocQueryResolver extends ResolverBase {
                 return this.buildErrorResult('No read-only data source available for ad-hoc query execution');
             }
 
-            // 3. Build executable SQL. When MaxRows is provided, wrap in a derived table
-            // with outer TOP so the engine can short-circuit at the source instead of
-            // scanning the full result. Skipped for SQL that begins with WITH/CTE — those
-            // can't be nested in a derived table on SQL Server and fall through to the
-            // in-memory slice below.
+            // 3. 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;
+
+            // 4. 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).
             const startRow = input.StartRow ?? 0;
             const maxRows = input.MaxRows;
-            const canWrap =
+            const usePaging =
                 maxRows != null &&
                 Number.isInteger(maxRows) &&
                 maxRows > 0 &&
                 Number.isInteger(startRow) &&
-                startRow >= 0 &&
-                !/^\s*WITH\b/i.test(input.SQL);
-            const executableSql = canWrap
-                ? `SELECT TOP ${startRow + maxRows} * FROM (\n${input.SQL}\n) AS _adhoc_capped`
-                : input.SQL;
+                startRow > 0;
+            let executableSql: string;
+            try {
+                const rendered = RenderPipeline.Run(input.SQL, {
+                    Platform: platform,
+                    ContextUser: contextUser,
+                    ...(usePaging
+                        ? { Paging: { StartRow: startRow, MaxRows: maxRows! } }
+                        : maxRows != null && maxRows > 0
+                            ? { MaxRows: maxRows }
+                            : {}),
+                });
+                executableSql = rendered.FinalSQL;
+            } catch (renderErr) {
+                const renderMsg = renderErr instanceof Error ? renderErr.message : String(renderErr);
+                return this.buildErrorResult(`Ad-hoc query rendering failed: ${renderMsg}`);
+            }
 
-            // 4. Execute with timeout
+            // 5. Execute with timeout
             const timeoutMs = (input.TimeoutSeconds ?? 30) * 1000;
             const request = new sql.Request(readOnlyDS);
 
@@ -92,23 +113,16 @@ export class AdhocQueryResolver extends ResolverBase {
             ]);
             const executionTimeMs = Date.now() - startTime;
 
-            // 5. Apply in-memory pagination. With the wrap applied this is a no-op for
-            // first-page reads; for StartRow > 0 (or CTE-headed SQL where the wrap was
-            // skipped) it carves out the requested page.
-            const fullRecordset = result.recordset ?? [];
-            const totalRowCount = fullRecordset.length;
-            let paginated = fullRecordset;
-            if (startRow > 0) paginated = paginated.slice(startRow);
-            if (maxRows != null && maxRows > 0) paginated = paginated.slice(0, maxRows);
-
             // 6. Return as RunQueryResultType
+            const recordset = result.recordset ?? [];
+
             return {
                 QueryID: '',
                 QueryName: 'Ad-Hoc Query',
                 Success: true,
-                Results: JSON.stringify(paginated),
-                RowCount: paginated.length,
-                TotalRowCount: totalRowCount,
+                Results: JSON.stringify(recordset),
+                RowCount: recordset.length,
+                TotalRowCount: recordset.length,
                 PageNumber: maxRows != null && maxRows > 0 ? Math.floor(startRow / maxRows) + 1 : undefined,
                 PageSize: maxRows ?? undefined,
                 ExecutionTime: executionTimeMs,