@memberjunction/server 5.51.2 → 5.51.4

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,7 +1,8 @@
 import { Metadata, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
-import { AppContext } from '../types.js';
+import { AppContext, UserPayload } from '../types.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadOnlyProvider } from '../util.js';
 
 @InputType()
@@ -31,8 +32,17 @@ export class EntityRecordNameResult {
   RecordName?: string;
 }
 
+/**
+ * Resolves a record's display NAME from its primary key — the lookup behind every foreign-key
+ * link, breadcrumb and picker label in the UI.
+ *
+ * Row-level security is applied by the provider's lookup, for the acting user passed to it: it
+ * reads only rows the user's read row filter allows, binds the key values as parameters, and
+ * refuses a key that does not name the entity's primary key fields. Without an acting user there
+ * is no lookup.
+ */
 @Resolver(EntityRecordNameResult)
-export class EntityRecordNameResolver {
+export class EntityRecordNameResolver extends ResolverBase {
   @Query(() => EntityRecordNameResult)
   async GetEntityRecordName(
     @Arg('EntityName', () => String) EntityName: string,
@@ -41,27 +51,34 @@ export class EntityRecordNameResolver {
   ): Promise<EntityRecordNameResult> {
     const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
 
-    return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
+    return await this.InnerGetEntityRecordName(md, EntityName, primaryKey, userPayload);
   }
 
   @Query(() => [EntityRecordNameResult])
   async GetEntityRecordNames(
     @Arg('info', () => [EntityRecordNameInput]) info: EntityRecordNameInput[],
-    @Ctx() {providers}: AppContext
+    @Ctx() {providers, userPayload}: AppContext
   ): Promise<EntityRecordNameResult[]> {
     const result: EntityRecordNameResult[] = [];
     const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     for (const i of info) {
-      result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.CompositeKey));
+      result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.CompositeKey, userPayload));
     }
     return result;
   }
 
-  async InnerGetEntityRecordName(md: DatabaseProviderBase, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
+  async InnerGetEntityRecordName(
+    md: DatabaseProviderBase,
+    EntityName: string,
+    primaryKey: CompositeKeyInputType,
+    userPayload?: UserPayload
+  ): Promise<EntityRecordNameResult> {
     const pk = new CompositeKey(primaryKey.KeyValuePairs);
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {
-      const recordName = await md.GetEntityRecordName(e.Name, pk);
+      const contextUser = userPayload ? this.GetUserFromPayload(userPayload) : undefined;
+      // The acting user is what row-level security is applied for.
+      const recordName = contextUser ? await md.GetEntityRecordName(e.Name, pk, contextUser) : '';
       if (recordName) return { Success: true, Status: 'OK', CompositeKey: pk, RecordName: recordName, EntityName };
       else
         return {

package/src/resolvers/GetDataContextDataResolver.ts

@@ -1,9 +1,13 @@
 import { Arg, Ctx, Field, ObjectType, Query, Resolver } from "type-graphql";
+import type { DatabaseProviderBase, UserInfo } from "@memberjunction/core";
+import { IsValidUUID, UUIDsEqual } from "@memberjunction/global";
+import { DataContext, DataContextItem } from "@memberjunction/data-context";
+import { MJDataContextEntity, MJDataContextItemEntity } from "@memberjunction/core-entities";
+import { RenderPipeline } from "@memberjunction/generic-database-provider";
 import { AppContext } from "../types.js";
-import { DataContext } from "@memberjunction/data-context";
-import { GetReadOnlyDataSource, GetReadOnlyProvider } from "../util.js";
-import { MJDataContextItemEntity } from "@memberjunction/core-entities";
+import { GetReadOnlyProvider } from "../util.js";
 import { ResolverBase } from "../generic/ResolverBase.js";
+import { IsScopeLimitedPrincipal } from "../auth/scopeLimitedPrincipal.js";
 
 @ObjectType()
 export class GetDataContextItemDataOutputType {
@@ -39,6 +43,28 @@ export class GetDataContextDataOutputType {
 }
 
 
+/** The outcome of loading one data context item: its data as JSON, or why it has none. */
+interface ItemOutcome {
+    Result: string | null;
+    Error: string | null;
+}
+
+/** Which `sql` items of a data context may run: the read-only provider, and each refused item's reason. */
+interface SQLItemGate {
+    Provider: DatabaseProviderBase | null;
+    Refusals: Map<DataContextItem, string>;
+}
+
+/**
+ * Loads the data of data contexts and their items.
+ *
+ * Items of type `sql` hold raw SQL, which is held to the rules ExecuteAdhocQuery applies to
+ * caller-supplied SQL. It runs only for the data context's owner or an administrator (Owner-type
+ * user), never for a scope-limited session, only on the read-only provider, and only as a single read
+ * statement over entity base views the caller may read in full. A SQL item that may not run is
+ * refused on its own, and the other items still load. Items of the other types load through entity
+ * permissions for the calling user.
+ */
 @Resolver()
 export class GetDataContextDataResolver extends ResolverBase {
     /**
@@ -52,30 +78,25 @@ export class GetDataContextDataResolver extends ResolverBase {
     ) {
         // Check API key scope authorization for data context read
         await this.CheckAPIKeyScopeAuthorization('datacontext:read', DataContextItemID, appCtx.userPayload);
+        if (!IsValidUUID(DataContextItemID)) {
+            return { Success: false, ErrorMessage: 'DataContextItemID must be a UUID', Result: null };
+        }
 
         try {
-            const ds = GetReadOnlyDataSource(appCtx.dataSources, {
-                allowFallbackToReadWrite: true,
-            })
+            const user: UserInfo = appCtx.userPayload.userRecord;
             const md = GetReadOnlyProvider(appCtx.providers, {allowFallbackToReadWrite: true});
-            const dciData = await md.GetEntityObject<MJDataContextItemEntity>("MJ: Data Context Items", appCtx.userPayload.userRecord);
+            const dciData = await md.GetEntityObject<MJDataContextItemEntity>("MJ: Data Context Items", user);
             if (await dciData.Load(DataContextItemID)) {
                 const dci = DataContext.CreateDataContextItem(); // use class factory to get whatever lowest level sub-class is registered
-                await dci.LoadMetadataFromEntityRecord(dciData, md, appCtx.userPayload.userRecord);
+                await dci.LoadMetadataFromEntityRecord(dciData, md, user);
+                const ownerID = dci.Type === 'sql' ? await this.loadDataContextOwnerID(dciData.DataContextID, md, user) : null;
+                const gate = this.authorizeSQLItems([dci], ownerID, appCtx);
                 // now the metadata is loaded so we can call the regular load function
-                if (await dci.LoadData(ds)) {
-                    return {
-                        Success: true,
-                        ErrorMessage: null,
-                        Result: JSON.stringify(dci.Data),
-                    }
-                }
-                else {
-                    return {
-                        Success: false,
-                        ErrorMessage: 'Error loading data context item data',
-                        Result: null,
-                    }
+                const outcome = await this.loadItem(dci, gate, user, false);
+                return {
+                    Success: outcome.Error === null,
+                    ErrorMessage: outcome.Error,
+                    Result: outcome.Result,
                 }
             }
             else {
@@ -89,14 +110,15 @@ export class GetDataContextDataResolver extends ResolverBase {
         catch (e) {
             return {
                 Success: false,
-                ErrorMessage: e,
+                ErrorMessage: e instanceof Error ? e.message : String(e),
                 Result: null,
             }
         }
     }
 
     /**
-     * Returns data for a given data context.
+     * Returns data for a given data context. `Results` and `ErrorMessages` hold one entry per item, in
+     * item order. `Success` is true, and `ErrorMessages` null, only when every item loaded.
      * @param DataContextID
      */
     @Query(() => GetDataContextDataOutputType)
@@ -106,38 +128,114 @@ export class GetDataContextDataResolver extends ResolverBase {
     ) {
         // Check API key scope authorization for data context read
         await this.CheckAPIKeyScopeAuthorization('datacontext:read', DataContextID, appCtx.userPayload);
+        // DataContext.LoadMetadata places this ID in the item filter, so it must be a plain UUID.
+        if (!IsValidUUID(DataContextID)) {
+            return { Success: false, ErrorMessages: ['DataContextID must be a UUID'], Results: null };
+        }
 
         try {
             // our job here is to load the entire data context, so we do that with the Data Context object
+            const user: UserInfo = appCtx.userPayload.userRecord;
+            const md = GetReadOnlyProvider(appCtx.providers, { allowFallbackToReadWrite: true });
             const dc = new DataContext();
-            const ds = GetReadOnlyDataSource(appCtx.dataSources, {
-                allowFallbackToReadWrite: true,
-            })
-            const success = await dc.Load(DataContextID, ds, true, false, 0, appCtx.userPayload.userRecord);
-            if (success) {
-                const retVal =   {
-                    Success: true,
-                    ErrorMessages: null,
-                    Results: dc.Items.map((item) => {
-                        return JSON.stringify(item.Data);
-                    }),
-                }
-                return retVal;
-            }
-            else {
+            if (!(await dc.LoadMetadata(DataContextID, user, md))) {
                 return {
                     Success: false,
                     ErrorMessages: ['Error loading data context'],
-                    Results: null,    
+                    Results: null,
                 }
             }
+            const gate = this.authorizeSQLItems(dc.Items, dc.MJDataContextEntity.UserID, appCtx);
+            const outcomes = await Promise.all(dc.Items.map((item) => this.loadItem(item, gate, user, true)));
+            const allLoaded = outcomes.every((outcome) => outcome.Error === null);
+            return {
+                Success: allLoaded,
+                ErrorMessages: allLoaded ? null : outcomes.map((outcome) => outcome.Error),
+                Results: outcomes.map((outcome) => outcome.Result),
+            }
         }
         catch (e) {
             return {
                 Success: false,
-                ErrorMessages: [e],
+                ErrorMessages: [e instanceof Error ? e.message : String(e)],
                 Results: null,
             }
         }
     }
-}
+
+    /**
+     * Decides which `sql` items among `items` may run. Returns the read-only provider they run on, and
+     * the reason for each SQL item that may not run.
+     */
+    private authorizeSQLItems(items: DataContextItem[], ownerID: string | null, appCtx: AppContext): SQLItemGate {
+        const refusals = new Map<DataContextItem, string>();
+        const sqlItems = items.filter((item) => item.Type === 'sql');
+        if (sqlItems.length === 0) {
+            return { Provider: null, Refusals: refusals };
+        }
+        const user: UserInfo | undefined = appCtx.userPayload?.userRecord;
+        const provider = GetReadOnlyProvider(appCtx.providers, { allowFallbackToReadWrite: false });
+        for (const item of sqlItems) {
+            const refusal = this.sqlItemRefusal(item, ownerID, user, provider);
+            if (refusal !== null) {
+                refusals.set(item, refusal);
+            }
+        }
+        return { Provider: provider, Refusals: refusals };
+    }
+
+    /** Returns why `item` may not run for `user`, or null when it may. */
+    private sqlItemRefusal(item: DataContextItem, ownerID: string | null, user: UserInfo | undefined, provider: DatabaseProviderBase | null): string | null {
+        if (!user || IsScopeLimitedPrincipal(user)) {
+            return 'SQL data context items cannot be run by a scope-limited or unidentified session.';
+        }
+        if (!this.mayRunDataContextSQL(ownerID, user)) {
+            return 'Only the owner of this data context, or an administrator, may run its SQL items.';
+        }
+        if (!provider) {
+            return 'No read-only data source is configured, so SQL data context items cannot run.';
+        }
+        return this.screenItemSQL(item.SQL ?? '', provider, user);
+    }
+
+    /** True when `user` owns the data context or is an administrator (Owner-type user). */
+    private mayRunDataContextSQL(ownerID: string | null, user: UserInfo): boolean {
+        const isOwner = !!ownerID && UUIDsEqual(ownerID, user.ID);
+        return isOwner || user.Type?.trim().toLowerCase() === 'owner';
+    }
+
+    /**
+     * Returns why `sqlText` may not run, or null when it is a single read statement whose every table
+     * reference is an entity base view `user` may read without row-level or field-level narrowing. It is
+     * the check ExecuteAdhocQuery makes on the rendered SQL.
+     */
+    private screenItemSQL(sqlText: string, provider: DatabaseProviderBase, user: UserInfo): string | null {
+        try {
+            const rendered = RenderPipeline.Run(sqlText, { Platform: provider.PlatformKey, ContextUser: user, RequireReadStatement: true });
+            this.assertFullQueryUsesReadableEntityViews(rendered.Trace.AfterTemplates, provider, user, 'data context SQL');
+            return null;
+        }
+        catch (e) {
+            const reason = e instanceof Error ? e.message : String(e);
+            return reason || 'The SQL of this item did not pass the read-only check.';
+        }
+    }
+
+    /** Loads one item's data unless `gate` refused it. Returns the data as JSON, or why there is none. */
+    private async loadItem(item: DataContextItem, gate: SQLItemGate, user: UserInfo, forceRefresh: boolean): Promise<ItemOutcome> {
+        const refusal = gate.Refusals.get(item);
+        if (refusal !== undefined) {
+            return { Result: null, Error: refusal };
+        }
+        if (await item.LoadData(gate.Provider, forceRefresh, false, 0, user)) {
+            return { Result: JSON.stringify(item.Data), Error: null };
+        }
+        return { Result: null, Error: item.DataLoadingError || 'Error loading data context item data' };
+    }
+
+    /** Returns the owner (`UserID`) of a data context, or null when the caller cannot load it. */
+    private async loadDataContextOwnerID(dataContextID: string, provider: DatabaseProviderBase, user: UserInfo): Promise<string | null> {
+        const dataContext = await provider.GetEntityObject<MJDataContextEntity>('MJ: Data Contexts', user);
+        return (await dataContext.Load(dataContextID)) ? dataContext.UserID : null;
+    }
+}

package/src/resolvers/GetDataResolver.ts

@@ -1,4 +1,5 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query } from 'type-graphql';
+import { SQLExpressionValidator } from '@memberjunction/global';
 import { AppContext } from '../types.js';
 import { LogError, LogStatus, LogStatusEx, Metadata } from '@memberjunction/core';
 import { QueryCompositionEngine } from '@memberjunction/generic-database-provider';
@@ -154,8 +155,20 @@ export class GetDataResolver {
                             resolvedSQL = compositionResult.ResolvedSQL;
                         }
 
+                        // Defense-in-depth: even system-token holders get SELECT-only SQL here.
+                        // The read-only pool is the primary control, but if it is ever
+                        // misconfigured to a read-write login this validator still refuses DML/DDL
+                        // (mirrors AdhocQueryResolver). The validator reads exactly the text that
+                        // runs: it is trimmed here as validate() trims it, and literal \n sequences
+                        // are not rewritten as ValidateFullQuery would.
+                        const sqlToRun = resolvedSQL.trim();
+                        const validation = SQLExpressionValidator.Instance.validate(sqlToRun, { context: 'full_query', Dialect: platform });
+                        if (!validation.valid) {
+                            return { result: null, error: validation.error || 'SQL validation failed' };
+                        }
+
                         const request = new sql.Request(readOnlyDataSource);
-                        const result = await request.query(resolvedSQL);
+                        const result = await request.query(sqlToRun);
                         return { result: result.recordset, error: null };
                     } catch (err) {
                         // Extract clean SQL error message

package/src/resolvers/MCPResolver.ts

@@ -19,7 +19,7 @@ import {
 } from '@memberjunction/ai-mcp-client';
 import { AppContext } from '../types.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
+import { publishStatusUpdate } from '../generic/PushStatusResolver.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { configInfo } from '../config.js';
 
@@ -583,7 +583,7 @@ export class MCPResolver extends ResolverBase {
             await manager.initialize(user, { publicUrl });
 
             // Publish initial progress
-            this.publishProgress(pubSub, sessionId, ConnectionID, 'connecting', 'Connecting to MCP server...');
+            this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'connecting', 'Connecting to MCP server...');
 
             // Connect if not already connected
             const isConnected = manager.isConnected(ConnectionID);
@@ -595,18 +595,18 @@ export class MCPResolver extends ResolverBase {
                     // Check for OAuth authorization required
                     if (connectError instanceof OAuthAuthorizationRequiredError) {
                         const authError = connectError as OAuthAuthorizationRequiredError;
-                        this.publishProgress(pubSub, sessionId, ConnectionID, 'error',
+                        this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'error',
                             `OAuth authorization required. Please authorize at: ${authError.authorizationUrl}`);
                         return this.createOAuthRequiredResult(authError.authorizationUrl, authError.stateParameter);
                     }
                     if (connectError instanceof OAuthReauthorizationRequiredError) {
                         const reAuthError = connectError as OAuthReauthorizationRequiredError;
-                        this.publishProgress(pubSub, sessionId, ConnectionID, 'error',
+                        this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'error',
                             `OAuth re-authorization required: ${reAuthError.reason}`);
                         return this.createOAuthReauthorizationResult(reAuthError.reason, reAuthError.authorizationUrl, reAuthError.stateParameter);
                     }
                     const connectErrorMsg = connectError instanceof Error ? connectError.message : String(connectError);
-                    this.publishProgress(pubSub, sessionId, ConnectionID, 'error', `Connection failed: ${connectErrorMsg}`);
+                    this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'error', `Connection failed: ${connectErrorMsg}`);
                     return this.createErrorResult(`Failed to connect to MCP server: ${connectErrorMsg}`);
                 }
             }
@@ -617,7 +617,7 @@ export class MCPResolver extends ResolverBase {
             const connectionName = connectionInfo?.connectionName || 'Unknown Connection';
 
             // Publish listing progress
-            this.publishProgress(pubSub, sessionId, ConnectionID, 'listing', 'Discovering tools from MCP server...');
+            this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'listing', 'Discovering tools from MCP server...');
 
             // Perform the sync with event listening for granular progress
             LogStatus(`MCPResolver: Starting tool sync for connection ${ConnectionID}`);
@@ -626,7 +626,7 @@ export class MCPResolver extends ResolverBase {
             const eventHandler = (event: { type: string; data?: Record<string, unknown> }) => {
                 if (event.type === 'toolsSynced') {
                     const data = event.data as { added: number; updated: number; deprecated: number; total: number } | undefined;
-                    this.publishProgress(pubSub, sessionId, ConnectionID, 'complete', 'Tool sync complete', {
+                    this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'complete', 'Tool sync complete', {
                         added: data?.added || 0,
                         updated: data?.updated || 0,
                         deprecated: data?.deprecated || 0,
@@ -637,7 +637,7 @@ export class MCPResolver extends ResolverBase {
             manager.addEventListener('toolsSynced', eventHandler);
 
             // Publish syncing progress
-            this.publishProgress(pubSub, sessionId, ConnectionID, 'syncing', 'Synchronizing tools to database...');
+            this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'syncing', 'Synchronizing tools to database...');
 
             // Perform the sync
             const syncResult: MCPSyncToolsResult = await manager.syncTools(ConnectionID, { contextUser: user });
@@ -646,12 +646,12 @@ export class MCPResolver extends ResolverBase {
             manager.removeEventListener('toolsSynced', eventHandler);
 
             if (!syncResult.success) {
-                this.publishProgress(pubSub, sessionId, ConnectionID, 'error', `Sync failed: ${syncResult.error}`);
+                this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'error', `Sync failed: ${syncResult.error}`);
                 return this.createErrorResult(syncResult.error || 'Tool sync failed');
             }
 
             // Publish final completion
-            this.publishProgress(pubSub, sessionId, ConnectionID, 'complete',
+            this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'complete',
                 `Sync complete: ${syncResult.added} added, ${syncResult.updated} updated, ${syncResult.deprecated} deprecated`,
                 {
                     added: syncResult.added,
@@ -675,7 +675,7 @@ export class MCPResolver extends ResolverBase {
         } catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
             LogError(`MCPResolver: Error syncing tools for ${ConnectionID}: ${errorMsg}`);
-            this.publishProgress(pubSub, sessionId, ConnectionID, 'error', `Error: ${errorMsg}`);
+            this.publishProgress(pubSub, sessionId, user.ID, ConnectionID, 'error', `Error: ${errorMsg}`);
             return this.createErrorResult(errorMsg);
         }
     }
@@ -1345,6 +1345,7 @@ export class MCPResolver extends ResolverBase {
     private publishProgress(
         pubSub: PubSubEngine,
         sessionId: string,
+        ownerUserId: string,
         connectionId: string,
         phase: SyncProgressMessage['phase'],
         message: string,
@@ -1360,10 +1361,7 @@ export class MCPResolver extends ResolverBase {
             result
         };
 
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify(progressMessage),
-            sessionId
-        });
+        publishStatusUpdate(pubSub, { sessionId, ownerUserId, message: JSON.stringify(progressMessage) });
     }
 
     /**