@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.8

package/src/resolvers/MCPResolver.ts

@@ -23,6 +23,19 @@ import { PublishStatusUpdate } from '../generic/PushStatusResolver.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { configInfo } from '../config.js';
 
+const UUID_SHAPE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+/**
+ * Validates that a caller-supplied record id is a UUID before it is interpolated into a SQL
+ * filter, and returns it unchanged. A validated UUID cannot carry SQL.
+ */
+function sqlUuid(value: string, argName: string): string {
+    if (typeof value !== 'string' || !UUID_SHAPE.test(value)) {
+        throw new Error(`${argName} must be a UUID`);
+    }
+    return value;
+}
+
 /**
  * Input type for syncing MCP tools
  */
@@ -1289,7 +1302,7 @@ export class MCPResolver extends ResolverBase {
             // First get connection to get server ID
             const connResult = await rv.RunView<{ MCPServerID: string }>({
                 EntityName: 'MJ: MCP Server Connections',
-                ExtraFilter: `ID='${connectionId}'`,
+                ExtraFilter: `ID='${sqlUuid(connectionId, 'connectionId')}'`,
                 Fields: ['MCPServerID'],
                 ResultType: 'simple'
             }, contextUser);
@@ -1310,7 +1323,7 @@ export class MCPResolver extends ResolverBase {
                 OAuthRequirePKCE: boolean | null;
             }>({
                 EntityName: 'MJ: MCP Servers',
-                ExtraFilter: `ID='${serverId}'`,
+                ExtraFilter: `ID='${sqlUuid(serverId, 'serverId')}'`,
                 Fields: [
                     'OAuthIssuerURL',
                     'OAuthScopes',

package/src/resolvers/QuerySystemUserResolver.ts

@@ -6,7 +6,7 @@ import { MJQueryResolver, MJQuery_, MJQueryField_, MJQueryParameter_, MJQueryEnt
 import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 import { MJQueryEntityServer } from '@memberjunction/core-entities-server';
-import { EscapeSQLString } from '@memberjunction/global';
+import { EscapeSQLString, UUIDsEqual } from '@memberjunction/global';
 
 /**
  * Minimal shape of a query row returned by RunView lookups (plain object, not entity instance).
@@ -243,6 +243,14 @@ export class DeleteQueryResultType {
     Status?: string;
 }
 
+/** A query's child rows, read from the database. */
+interface StoredQueryChildren {
+    readonly Fields: MJQueryFieldEntity[];
+    readonly Parameters: MJQueryParameterEntity[];
+    readonly Entities: MJQueryEntityEntity[];
+    readonly Permissions: MJQueryPermissionEntity[];
+}
+
 @Resolver()
 export class MJQueryResolverExtended extends MJQueryResolver {
     /**
@@ -269,6 +277,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             }
 
             // Check for existing query with same name in the same category
+            const requestedName = input.Name;
             const existingQuery = await this.findExistingQuery(provider, input.Name, finalCategoryID, context.userPayload.userRecord);
 
             if (existingQuery) {
@@ -285,84 +294,119 @@ export class MJQueryResolverExtended extends MJQueryResolver {
                 }
             }
 
-            // Use MJQueryEntityServer which handles AI processing
-            const record = await provider.GetEntityObject<MJQueryEntityServer>("MJ: Queries", context.userPayload.userRecord);
-            
-            // Destructure out non-database fields, keep only fields to persist
-            const { Permissions: _permissions, CategoryPath: _categoryPath, ParameterHints: _parameterHints, AutoResolveCollision: _autoResolve, ...fieldsToSet } = {
-                ...input,
-                CategoryID: finalCategoryID || input.CategoryID,
-                Status: input.Status || 'Approved',
-                QualityRank: input.QualityRank || 0,
-                UsesTemplate: input.UsesTemplate || false,
-                AuditQueryRuns: input.AuditQueryRuns || false,
-                CacheEnabled: input.CacheEnabled || false,
-                CacheTTLMinutes: input.CacheTTLMinutes || null,
-                CacheMaxSize: input.CacheMaxSize || null
+            return await this.createQueryAsync(provider, input, requestedName, finalCategoryID, context, pubSub);
+        } 
+        catch (err) {
+            LogError(err);
+            return {
+                Success: false,
+                ErrorMessage: `MJQueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
             };
+        }
+    }
 
-            // Field-level security: refuse a key the caller may not read, or that names no field
-            AssertClientInputWritableForUser(record.EntityInfo, fieldsToSet, context.userPayload.userRecord);
-            record.SetMany(fieldsToSet, true);
+    /** The most times a create with `AutoResolveCollision` picks a new name after losing a same-name race. */
+    private static readonly maxCollisionRetries = 25;
 
-            // Pass caller-provided parameter sample values to override LLM guesses
-            if (input.ParameterHints && input.ParameterHints.length > 0) {
-                record.ParameterHints = new Map(input.ParameterHints.map(h => [h.Name, h.Value]));
+    /**
+     * Creates the query, handling a same-name race (#6007): when the insert fails and a query with
+     * the name now exists (another request created it in between), `AutoResolveCollision` picks a
+     * new unique name and tries again, a bounded number of times, and never returns the other
+     * request's query. Without it, the query that now exists is returned (create-or-get). Any other
+     * failure, including a save-time refusal of the SQL, returns the save's message.
+     *
+     * @param requestedName - The name the caller asked for; each retry's unique name is built from it.
+     */
+    private async createQueryAsync(
+        provider: DatabaseProviderBase,
+        input: CreateQuerySystemUserInput,
+        requestedName: string,
+        categoryID: string | null | undefined,
+        context: AppContext,
+        pubSub: PubSubEngine
+    ): Promise<QueryMutationResultType> {
+        const user = context.userPayload.userRecord;
+        for (let attempt = 0; ; attempt++) {
+            const record = await this.newQueryRecordAsync(provider, input, categoryID, context, pubSub);
+            if (await record.Save()) {
+                return this.completeCreateAsync(provider, input, record, user);
             }
+            const existing = await this.findExistingQuery(provider, input.Name, categoryID ?? null, user);
+            if (!existing) {
+                return { Success: false, ErrorMessage: `Failed to create query: ${record.LatestResult?.CompleteMessage || record.LatestResult?.Message || 'the save reported no reason'}` };
+            }
+            if (!input.AutoResolveCollision) {
+                return this.existingQueryResultAsync(provider, existing, input.Name, user);
+            }
+            if (attempt >= MJQueryResolverExtended.maxCollisionRetries) {
+                return { Success: false, ErrorMessage: `Failed to create query '${input.Name}': another request took each unique name tried, ${attempt + 1} times.` };
+            }
+            const lost = input.Name;
+            input.Name = await this.findUniqueName(provider, requestedName, categoryID ?? null, user);
+            LogStatus(`[CreateQuery] Lost a name race for "${lost}"; retrying as "${input.Name}"`);
+        }
+    }
 
-            this.ListenForEntityMessages(record, pubSub, context.userPayload.userRecord);
-
-            // Attempt to save the query
-            const saveResult = await record.Save();
-
-            if (saveResult) {
-                // Save succeeded - fire the AfterCreate event and return all the data
-                await this.AfterCreate(provider, input); // fire event
-                const queryID = record.ID;
-
-                if (input.Permissions && input.Permissions.length > 0) {
-                    await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
-
-                }
-
+    /** A new, unsaved query record holding the input's values. */
+    private async newQueryRecordAsync(
+        provider: DatabaseProviderBase,
+        input: CreateQuerySystemUserInput,
+        categoryID: string | null | undefined,
+        context: AppContext,
+        pubSub: PubSubEngine
+    ): Promise<MJQueryEntityServer> {
+        const record = await provider.GetEntityObject<MJQueryEntityServer>("MJ: Queries", context.userPayload.userRecord);
+        // Destructure out non-database fields, keep only fields to persist
+        const { Permissions: _permissions, CategoryPath: _categoryPath, ParameterHints: _parameterHints, AutoResolveCollision: _autoResolve, ...fieldsToSet } = {
+            ...input,
+            CategoryID: categoryID || input.CategoryID,
+            Status: input.Status || 'Approved',
+            QualityRank: input.QualityRank || 0,
+            UsesTemplate: input.UsesTemplate || false,
+            AuditQueryRuns: input.AuditQueryRuns || false,
+            CacheEnabled: input.CacheEnabled || false,
+            CacheTTLMinutes: input.CacheTTLMinutes || null,
+            CacheMaxSize: input.CacheMaxSize || null
+        };
+        // Field-level security: refuse a key the caller may not read, or that names no field
+        AssertClientInputWritableForUser(record.EntityInfo, fieldsToSet, context.userPayload.userRecord);
+        record.SetMany(fieldsToSet, true);
+        // Pass caller-provided parameter sample values (used for new parameters and the described renders)
+        if (input.ParameterHints && input.ParameterHints.length > 0) {
+            record.ParameterHints = new Map(input.ParameterHints.map(h => [h.Name, h.Value]));
+        }
+        this.ListenForEntityMessages(record, pubSub, context.userPayload);
+        return record;
+    }
 
-                return await this.buildSuccessResult(record, context.userPayload.userRecord, provider);
+    /** After a successful create: the AfterCreate event, the permissions, and the result. */
+    private async completeCreateAsync(provider: DatabaseProviderBase, input: CreateQuerySystemUserInput, record: MJQueryEntityServer, user: UserInfo): Promise<QueryMutationResultType> {
+        await this.AfterCreate(provider, input); // fire event
+        let createdPermissions: MJQueryPermissionEntity[] | undefined;
+        if (input.Permissions && input.Permissions.length > 0) {
+            try {
+                createdPermissions = await this.createPermissions(provider, input.Permissions, record.ID, user);
+            } catch (e) {
+                return { Success: false, ErrorMessage: `Query '${record.Name}' (ID ${record.ID}) was created, but its permissions were not: ${e instanceof Error ? e.message : String(e)}` };
             }
-            else {
-                // Save failed - check if another request created the same query (race condition)
-                // Always recheck regardless of error type to handle all duplicate scenarios
-                const existingQuery = await this.findExistingQuery(provider, input.Name, finalCategoryID, context.userPayload.userRecord);
-
-                if (existingQuery) {
-                    // Found the query that was created by another request — load it as a full entity
-                    // so that related metadata (Fields, Parameters, Entities, Permissions) is populated
-                    LogStatus(`[CreateQuery] Unique constraint detected for query '${input.Name}'. Using existing query (ID: ${existingQuery.ID}) created by concurrent request.`);
-                    const existingEntity = await provider.GetEntityObject<MJQueryEntityServer>('MJ: Queries', context.userPayload.userRecord);
-                    if (await existingEntity.Load(existingQuery.ID)) {
-                        return await this.buildSuccessResult(existingEntity, context.userPayload.userRecord, provider);
-                    }
-                    // Entity load failed after confirming the row exists — extremely rare
-                    return {
-                        Success: false,
-                        ErrorMessage: `Found query '${input.Name}' created by concurrent request (ID: ${existingQuery.ID}) but failed to load it as entity`
-                    };
-                }
+        }
+        return this.buildSuccessResult(record, user, provider, undefined, createdPermissions);
+    }
 
-                // Genuine failure - couldn't find an existing query with the same name
-                const errorMessage = record.LatestResult?.Message || '';
-                return {
-                    Success: false,
-                    ErrorMessage: `Failed to create query: ${errorMessage || 'Unknown error'}`
-                };
-            }
-        } 
-        catch (err) {
-            LogError(err);
-            return {
-                Success: false,
-                ErrorMessage: `MJQueryResolverExtended::CreateQuerySystemUser --- Error creating query: ${err instanceof Error ? err.message : String(err)}`
-            };
+    /** The create-or-get result: the query another request created with this name. */
+    private async existingQueryResultAsync(provider: DatabaseProviderBase, existing: QueryViewRow, name: string, user: UserInfo): Promise<QueryMutationResultType> {
+        LogStatus(`[CreateQuery] Unique constraint detected for query '${name}'. Using existing query (ID: ${existing.ID}) created by concurrent request.`);
+        const existingEntity = await provider.GetEntityObject<MJQueryEntityServer>('MJ: Queries', user);
+        if (await existingEntity.Load(existing.ID)) {
+            // The other request may have run on another server, or its rows may not have reached this
+            // process's query cache yet, so the child rows are read from the database.
+            const children = await this.readStoredChildrenAsync(provider, existing.ID, user);
+            return this.buildSuccessResult(existingEntity, user, provider, children);
         }
+        return {
+            Success: false,
+            ErrorMessage: `Found query '${name}' created by concurrent request (ID: ${existing.ID}) but failed to load it as entity`
+        };
     }
 
     /**
@@ -372,17 +416,46 @@ export class MJQueryResolverExtended extends MJQueryResolver {
      *
      * @param contextUser The caller the result is for. Field security projects the record for them.
      */
-    private async buildSuccessResult(entity: MJQueryEntityServer, contextUser: UserInfo, provider: DatabaseProviderBase): Promise<QueryMutationResultType> {
+    private async buildSuccessResult(
+        entity: MJQueryEntityServer,
+        contextUser: UserInfo,
+        provider: DatabaseProviderBase,
+        children?: StoredQueryChildren,
+        createdPermissions?: MJQueryPermissionEntity[]
+    ): Promise<QueryMutationResultType> {
+        const permissionsToMap = children?.Permissions ?? createdPermissions ?? entity.QueryPermissions;
         return {
             Success: true,
             // Mapped for the caller, so the field-security projection applies: the record was just
             // saved, and a save re-reads the whole row.
             // fls-guard: projected for contextUser by MapFieldNamesToCodeNames
             Query: await this.MapFieldNamesToCodeNames('MJ: Queries', entity.GetAll(), contextUser, provider) as MJQuery_,
-            Fields: this.mapFields(entity.QueryFields),
-            Parameters: this.mapParameters(entity.QueryParameters),
-            Entities: this.mapEntities(entity.QueryEntities),
-            Permissions: this.mapPermissions(entity.QueryPermissions),
+            Fields: this.mapFields(children?.Fields ?? entity.QueryFields),
+            Parameters: this.mapParameters(children?.Parameters ?? entity.QueryParameters),
+            Entities: this.mapEntities(children?.Entities ?? entity.QueryEntities),
+            Permissions: this.mapPermissions(permissionsToMap),
+        };
+    }
+
+    /**
+     * A query's child rows read from the database with every cache bypassed. A collection whose
+     * read fails comes back empty, as the cache would have given it.
+     */
+    private async readStoredChildrenAsync(provider: DatabaseProviderBase, queryID: string, user: UserInfo): Promise<StoredQueryChildren> {
+        const filter = `QueryID='${EscapeSQLString(queryID)}'`;
+        const view = (entityName: string, orderBy?: string) => ({ EntityName: entityName, ExtraFilter: filter, OrderBy: orderBy, ResultType: 'entity_object' as const, BypassCache: true, IgnoreMaxRows: true });
+        const [fields, parameters, entities, permissions] = await provider.RunViews([
+            view('MJ: Query Fields', 'Sequence'),
+            view('MJ: Query Parameters', 'Name'),
+            view('MJ: Query Entities'),
+            view('MJ: Query Permissions'),
+        ], user);
+        const rows = <T>(result: { Success: boolean; Results: T[] } | undefined): T[] => (result?.Success ? result.Results : []);
+        return {
+            Fields: rows<MJQueryFieldEntity>(fields),
+            Parameters: rows<MJQueryParameterEntity>(parameters),
+            Entities: rows<MJQueryEntityEntity>(entities),
+            Permissions: rows<MJQueryPermissionEntity>(permissions),
         };
     }
 
@@ -398,6 +471,10 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             SourceEntityID: f.SourceEntityID,
             SourceEntity: f.SourceEntity,
             SourceFieldName: f.SourceFieldName,
+            SourceEntityFieldID: f.SourceEntityFieldID,
+            SourceEntityField: f.SourceEntityField,
+            SourceObjectName: f.SourceObjectName,
+            IsNullable: f.IsNullable,
             IsComputed: f.IsComputed,
             ComputationDescription: f.ComputationDescription,
             IsSummary: f.IsSummary,
@@ -421,6 +498,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             DefaultValue: p.DefaultValue,
             SampleValue: p.SampleValue,
             ValidationFilters: p.ValidationFilters,
+            IsServerSet: p.IsServerSet,
             _mj__CreatedAt: p.__mj_CreatedAt,
             _mj__UpdatedAt: p.__mj_UpdatedAt,
             DetectionMethod: p.DetectionMethod,
@@ -435,6 +513,8 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             QueryID: e.QueryID,
             EntityID: e.EntityID,
             Entity: e.Entity,
+            AlternateBaseViewID: e.AlternateBaseViewID,
+            AlternateBaseView: e.AlternateBaseView,
             _mj__CreatedAt: e.__mj_CreatedAt,
             _mj__UpdatedAt: e.__mj_UpdatedAt,
             DetectionMethod: e.DetectionMethod,
@@ -455,15 +535,44 @@ export class MJQueryResolverExtended extends MJQueryResolver {
         }) as MJQueryPermission_);
     }
 
-    protected async createPermissions(p: DatabaseProviderBase, permissions: QueryPermissionInputType[], queryID: string, contextUser: UserInfo): Promise<void> {
+    /**
+     * Saves one `MJ: Query Permissions` row per input role for the query.
+     *
+     * @throws Error naming the role and the save's own message when a row is not saved
+     */
+    protected async createPermissions(p: DatabaseProviderBase, permissions: QueryPermissionInputType[], queryID: string, contextUser: UserInfo): Promise<MJQueryPermissionEntity[]> {
+        const created: MJQueryPermissionEntity[] = [];
         for (const perm of permissions) {
             const permissionEntity = await p.GetEntityObject<MJQueryPermissionEntity>('MJ: Query Permissions', contextUser);
             if (permissionEntity) {
                 permissionEntity.QueryID = queryID;
                 permissionEntity.RoleID = perm.RoleID;
-                await permissionEntity.Save();
+                if (!await permissionEntity.Save()) {
+                    throw new Error(MJQueryResolverExtended.permissionWriteError('save', perm.RoleID, permissionEntity));
+                }
+                created.push(permissionEntity);
             }
         }
+        return created;
+    }
+
+    /**
+     * Deletes every `MJ: Query Permissions` row of the query.
+     *
+     * @throws Error naming the role and the delete's own message when a row is not deleted
+     */
+    protected async deletePermissions(queryID: string): Promise<void> {
+        for (const perm of QueryEngine.Instance.GetQueryPermissions(queryID)) {
+            if (!await perm.Delete()) {
+                throw new Error(MJQueryResolverExtended.permissionWriteError('delete', perm.RoleID, perm));
+            }
+        }
+    }
+
+    /** The message for a permission row that was not saved or deleted, with the entity's own reason. */
+    private static permissionWriteError(action: 'save' | 'delete', roleID: string, entity: MJQueryPermissionEntity): string {
+        const reason = entity.LatestResult?.CompleteMessage || entity.LatestResult?.Message || `the ${action} reported no reason`;
+        return `Failed to ${action} the query permission for role ${roleID}: ${reason}`;
     }
 
     /**
@@ -498,16 +607,14 @@ export class MJQueryResolverExtended extends MJQueryResolver {
                 finalCategoryID = await this.findOrCreateCategoryPath(input.CategoryPath, provider, context.userPayload.userRecord);
             }
 
-            // now make sure there is NO existing query by the same name in the specified category
-            const existingQueryResult = await provider.RunView({
-                EntityName: 'MJ: Queries',
-                ExtraFilter: `Name='${EscapeSQLString(input.Name)}' AND CategoryID='${EscapeSQLString(finalCategoryID)}'`
-            }, context.userPayload.userRecord);
-            if (existingQueryResult.Success && existingQueryResult.Results?.length > 0) {
-                // we have a match! Let's return an error
+            // A rename, or a move to another category, must not collide with another query's name
+            const targetName = input.Name ?? queryEntity.Name;
+            const targetCategoryID = finalCategoryID !== undefined ? finalCategoryID : queryEntity.CategoryID;
+            const sameName = await this.findExistingQuery(provider, targetName, targetCategoryID ?? null, context.userPayload.userRecord);
+            if (sameName && !UUIDsEqual(sameName.ID, queryEntity.ID)) {
                 return {
                     Success: false,
-                    ErrorMessage: `Query with name '${input.Name}' already exists in the specified ${input.CategoryID ? 'category' : 'categoryPath'}`
+                    ErrorMessage: `Query with name '${targetName}' already exists in the specified ${input.CategoryID ? 'category' : 'categoryPath'}`
                 };
             }
 
@@ -545,25 +652,25 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             if (!saveResult) {
                 return {
                     Success: false,
-                    ErrorMessage: `Failed to update query: ${queryEntity.LatestResult?.Message || 'Unknown error'}`
+                    ErrorMessage: `Failed to update query: ${queryEntity.LatestResult?.CompleteMessage || queryEntity.LatestResult?.Message || 'the save reported no reason'}`
                 };
             }
 
             const queryID = queryEntity.ID;
 
             // Handle permissions update if provided
+            let createdPermissions: MJQueryPermissionEntity[] | undefined;
             if (input.Permissions !== undefined) {
-                // Delete existing permissions (read from QueryEngine cache)
-                const existingPermissions = QueryEngine.Instance.GetQueryPermissions(queryID);
-                for (const perm of existingPermissions) {
-                    await perm.Delete();
+                // Replace the existing permissions (read from the QueryEngine cache); a failed write stops the update with its reason
+                try {
+                    await this.deletePermissions(queryID);
+                    createdPermissions = await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
+                } catch (e) {
+                    return { Success: false, ErrorMessage: `Failed to update query permissions: ${e instanceof Error ? e.message : String(e)}` };
                 }
-
-                // Create new permissions
-                await this.createPermissions(provider, input.Permissions, queryID, context.userPayload.userRecord);
             }
 
-            return await this.buildSuccessResult(queryEntity, context.userPayload.userRecord, provider);
+            return await this.buildSuccessResult(queryEntity, context.userPayload.userRecord, provider, undefined, createdPermissions);
 
         } catch (err) {
             LogError(err);
@@ -740,12 +847,13 @@ export class MJQueryResolverExtended extends MJQueryResolver {
     ): Promise<QueryViewRow | null> {
         try {
             // Query database directly to avoid cache staleness issues
-            const categoryFilter = categoryID ? `CategoryID='${categoryID}'` : 'CategoryID IS NULL';
-            const nameFilter = `LOWER(Name) = LOWER('${queryName.replace(/'/g, "''")}')`;
+            const categoryFilter = categoryID ? `CategoryID='${EscapeSQLString(categoryID)}'` : 'CategoryID IS NULL';
+            const nameFilter = `LOWER(Name) = LOWER('${EscapeSQLString(queryName)}')`;
 
             const result = await provider.RunView<QueryViewRow>({
                 EntityName: 'MJ: Queries',
-                ExtraFilter: `${nameFilter} AND ${categoryFilter}`
+                ExtraFilter: `${nameFilter} AND ${categoryFilter}`,
+                BypassCache: true
             }, contextUser);
 
             if (result.Success && result.Results && result.Results.length > 0) {
@@ -797,13 +905,16 @@ export class MJQueryResolverExtended extends MJQueryResolver {
     private async findCategoryByNameAndParent(provider: DatabaseProviderBase, categoryName: string, parentID: string | null, contextUser: UserInfo): Promise<MJQueryCategoryEntity | null> {
         try {
             // Query database directly to avoid cache staleness issues
-            const parentFilter = parentID ? `ParentID='${parentID}'` : 'ParentID IS NULL';
-            const nameFilter = `LOWER(Name) = LOWER('${categoryName.replace(/'/g, "''")}')`; // Escape single quotes
+            const parentFilter = parentID ? `ParentID='${EscapeSQLString(parentID)}'` : 'ParentID IS NULL';
+            const nameFilter = `LOWER(Name) = LOWER('${EscapeSQLString(categoryName)}')`;
 
+            // Uncached: after losing a race to create the category, the re-check must see the row the
+            // other request just wrote.
             const result = await provider.RunView<MJQueryCategoryEntity>({
                 EntityName: 'MJ: Query Categories',
                 ExtraFilter: `${nameFilter} AND ${parentFilter}`,
-                ResultType: 'entity_object'
+                ResultType: 'entity_object',
+                BypassCache: true
             }, contextUser);
 
             if (result.Success && result.Results && result.Results.length > 0) {

package/src/resolvers/RealtimeBridgeResolver.ts

@@ -701,6 +701,7 @@ export class RealtimeBridgeResolver extends ResolverBase {
               Fields: ['ExternalID'],
               OrderBy: '__mj_CreatedAt DESC',
               MaxRows: 1,
+              SkipTotalRowCount: true,
               ResultType: 'simple',
             },
             user,

package/src/resolvers/RealtimeClientSessionResolver.ts

@@ -34,7 +34,7 @@
 import { Resolver, Mutation, Arg, Ctx, Int, Float, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { AuthorizationEvaluator, UserInfo, IMetadataProvider, DatabaseProviderBase, LogError, LogErrorEx, LogStatus, RunView, BaseEntity } from '@memberjunction/core';
-import { UUIDsEqual, IsValidUUID } from '@memberjunction/global';
+import { EscapeSQLString, UUIDsEqual, IsValidUUID } from '@memberjunction/global';
 import {
     MJAIAgentEntity,
     MJAIAgentSessionEntity,
@@ -106,6 +106,14 @@ const SIGNIFICANT_PROGRESS_STEPS = ['prompt_execution', 'action_execution', 'sub
  */
 const MAX_USAGE_DETAILS_JSON_LENGTH = 4096;
 
+/**
+ * Sessions already logged as having no co-agent prompt run. Usage, transcript and tool-turn relays all read
+ * the id, many times per call, so the gap is logged once per session instead of once per relay. Bounded:
+ * past {@link MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS} entries the oldest is dropped (a Set keeps insertion order).
+ */
+const sessionsLoggedWithoutPromptRun = new Set<string>();
+const MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS = 5000;
+
 /** Entity name — centralised so the `MJ:`-prefix convention is applied in exactly one place. */
 const CO_AGENT_ENTITY = 'MJ: AI Agent Co Agents';
 const CONVERSATION_DETAIL_ENTITY = 'MJ: Conversation Details';
@@ -1330,10 +1338,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
             return null;
         }
         if (!config.promptRunID) {
-            LogStatus(
-                `RelayRealtimeUsage: session ${session.ID} has no co-agent promptRunID (observability run ` +
-                    'creation was skipped or failed) — usage delta dropped.',
-            );
+            this.logMissingPromptRunOnce(session.ID);
             return null;
         }
         const verified = await this.runIDVerifier.Verify(
@@ -1349,6 +1354,29 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         return verified.PromptRunID;
     }
 
+    /**
+     * Logs, once per session, that the session has no co-agent prompt run, so its usage, cost, transcript and
+     * tool turns are not recorded on one. The reason (no active co-agent prompt, or a failed run save) was
+     * logged when the session was prepared.
+     */
+    private logMissingPromptRunOnce(sessionID: string): void {
+        if (sessionsLoggedWithoutPromptRun.has(sessionID)) {
+            return;
+        }
+        sessionsLoggedWithoutPromptRun.add(sessionID);
+        if (sessionsLoggedWithoutPromptRun.size > MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS) {
+            const oldest = sessionsLoggedWithoutPromptRun.values().next().value;
+            if (oldest !== undefined) {
+                sessionsLoggedWithoutPromptRun.delete(oldest);
+            }
+        }
+        LogError(
+            `RealtimeClientSessionResolver: session ${sessionID} has no co-agent promptRunID, so its usage, cost, ` +
+                'transcript and tool turns are not recorded on a prompt run (the reason was logged when the session ' +
+                'was prepared). Logged once per session.',
+        );
+    }
+
     /**
      * Persist an interactive channel's state of record (e.g. the live whiteboard's serialized
      * scene) onto the session's `MJ: AI Agent Session Channels` row.
@@ -2032,9 +2060,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         const existing = await rv.RunView<MJAIAgentSessionChannelEntity>(
             {
                 EntityName: SESSION_CHANNEL_ENTITY,
-                ExtraFilter: `AgentSessionID='${agentSessionID}' AND ChannelID='${channelID}'`,
+                ExtraFilter: `AgentSessionID='${EscapeSQLString(agentSessionID)}' AND ChannelID='${EscapeSQLString(channelID)}'`,
                 ResultType: 'entity_object',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
             },
             contextUser,
         );
@@ -2423,6 +2452,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                 Fields: ['ID', 'IsEnabled'],
                 ResultType: 'simple',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
             },
             contextUser,
         );
@@ -2585,6 +2615,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                 OrderBy: '__mj_CreatedAt DESC',
                 ResultType: 'simple',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
             },
             contextUser,
         );
@@ -2673,9 +2704,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
             const existing = await rv.RunView<MJAIAgentSessionChannelEntity>(
                 {
                     EntityName: SESSION_CHANNEL_ENTITY,
-                    ExtraFilter: `AgentSessionID='${agentSessionID}' AND ChannelID='${channelID}'`,
+                    ExtraFilter: `AgentSessionID='${EscapeSQLString(agentSessionID)}' AND ChannelID='${EscapeSQLString(channelID)}'`,
                     ResultType: 'entity_object',
                     MaxRows: 1,
+                    SkipTotalRowCount: true,
                 },
                 contextUser,
             );
@@ -3014,6 +3046,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                 ExtraFilter: `AgentSessionID='${session.ID}' AND Role='${mappedRole}'`,
                 OrderBy: '__mj_CreatedAt DESC',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
                 ResultType: 'entity_object',
             },
             writeUser,