@memberjunction/server 5.51.0 → 6.1.0-edge.0

package/src/generated/generated.ts

@@ -1000,7 +1000,7 @@ export class MJActionExecutionLog_ {
     @Field({nullable: true, description: `Timestamp when the action execution ended (timezone-aware)`}) 
     EndedAt?: Date;
         
-    @Field({nullable: true, description: `JSON-formatted input parameters passed to the action during execution, storing the exact values used for this specific run.`}) 
+    @Field({nullable: true, description: `JSON-formatted input parameters AS THE ACTION WAS CALLED, captured once when execution starts and never overwritten. Custom and Generated actions mutate their parameter array in place, so this is the only durable record of the values actually passed in; the final state lives in ResultParams. Parameter values may be redacted per ActionParam.LogValue / EntityActionParam.LogValue, and whole-record value types are never written - see the parameter's own documentation.`}) 
     Params?: string;
         
     @Field({nullable: true, description: `The outcome code returned by the action execution, indicating success, failure, or specific error conditions as defined in Action Result Codes.`}) 
@@ -1020,9 +1020,28 @@ export class MJActionExecutionLog_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
-    @Field({nullable: true, description: `JSON-formatted output data or response from the action execution`}) 
+    @Field({nullable: true, description: `Human-readable summary message returned by the action - the reason for a refusal, or a short description of what was done. Not the action's output data: parameter values live in Params and ResultParams, and the outcome code in ResultCode.`}) 
     Message?: string;
         
+    @Field({nullable: true, description: `Optional. The Entity Action binding that caused this run. NULL when the action was invoked directly - from a resolver, a script, an agent step or a scheduled action.`}) 
+    @MaxLength(36)
+    EntityActionID?: string;
+        
+    @Field({nullable: true, description: `Optional. Which lifecycle event fired the binding - AfterUpdate, Validate, List and so on. Recorded separately from EntityActionID because one binding may be attached to several invocation types, and telling a Validate refusal apart from an AfterUpdate side effect is the first question anyone asks of this log.`}) 
+    @MaxLength(36)
+    EntityActionInvocationTypeID?: string;
+        
+    @Field({nullable: true, description: `Optional. The entity of the record this run operated on. Deliberately denormalized rather than joined through EntityActionID: it survives the binding being deleted or retargeted, and it lets the log be queried by record with no join. Kept generic because every invoker has a subject - not only Entity Actions.`}) 
+    @MaxLength(36)
+    TargetEntityID?: string;
+        
+    @Field({nullable: true, description: `Optional. The primary key of the record this run operated on, as text, paired with TargetEntityID. For multi-record invocation types (List, View) one log row is written per record, so this is always a single record.`}) 
+    @MaxLength(450)
+    TargetRecordID?: string;
+        
+    @Field({nullable: true, description: `JSON-formatted FINAL parameter set captured when the action finished - the inputs as the action left them, plus any output parameters it produced. Written on FAILURE exactly as on success, under the same redaction rules: a failed run's partially-mutated inputs are usually the most diagnostic thing available, and an audit trail that records only successes is not an audit trail. Distinct from Params, which holds the values the action was called with and is never overwritten. NULL means one thing only - the run never finished (process died, host killed) - so it is a signal rather than an absence, and must not be backfilled.`}) 
+    ResultParams?: string;
+        
     @Field() 
     @MaxLength(425)
     Action: string;
@@ -1031,6 +1050,18 @@ export class MJActionExecutionLog_ {
     @MaxLength(100)
     User: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(425)
+    EntityAction?: string;
+        
+    @Field({nullable: true}) 
+    @MaxLength(255)
+    EntityActionInvocationType?: string;
+        
+    @Field({nullable: true}) 
+    @MaxLength(255)
+    TargetEntity?: string;
+        
     @Field(() => [MJProcessRunDetail_])
     MJProcessRunDetails_ActionExecutionLogIDArray: MJProcessRunDetail_[]; // Link to MJProcessRunDetails
     
@@ -1071,6 +1102,21 @@ export class CreateMJActionExecutionLogInput {
     @Field({ nullable: true })
     Message: string | null;
 
+    @Field({ nullable: true })
+    EntityActionID: string | null;
+
+    @Field({ nullable: true })
+    EntityActionInvocationTypeID: string | null;
+
+    @Field({ nullable: true })
+    TargetEntityID: string | null;
+
+    @Field({ nullable: true })
+    TargetRecordID: string | null;
+
+    @Field({ nullable: true })
+    ResultParams: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -1108,6 +1154,21 @@ export class UpdateMJActionExecutionLogInput {
     @Field({ nullable: true })
     Message?: string | null;
 
+    @Field({ nullable: true })
+    EntityActionID?: string | null;
+
+    @Field({ nullable: true })
+    EntityActionInvocationTypeID?: string | null;
+
+    @Field({ nullable: true })
+    TargetEntityID?: string | null;
+
+    @Field({ nullable: true })
+    TargetRecordID?: string | null;
+
+    @Field({ nullable: true })
+    ResultParams?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -1616,6 +1677,9 @@ export class MJActionParam_ {
     @MaxLength(20)
     MediaModality?: string;
         
+    @Field(() => Boolean, {description: `Whether this parameter's VALUE may be written to ActionExecutionLog.Params. Default 1. Set to 0 for parameters that carry records, credentials or personal data - for example the Data payload of Execute Agent. Independent of the hard rule that Entity Action params of ValueType 'Entity Object' or 'Entity Object Data' are never logged regardless of this flag. When logging is suppressed the log records the parameter name, its type and a redaction marker, never the value.`}) 
+    LogValue: boolean;
+        
     @Field() 
     @MaxLength(425)
     Action: string;
@@ -1663,6 +1727,9 @@ export class CreateMJActionParamInput {
     @Field({ nullable: true })
     MediaModality: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    LogValue?: boolean;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -1703,6 +1770,9 @@ export class UpdateMJActionParamInput {
     @Field({ nullable: true })
     MediaModality?: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    LogValue?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -22278,6 +22348,10 @@ export class MJAPIApplicationScope_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field({nullable: true, description: `Optional row-level filter acting as a CEILING for every API key operating under this application — a restriction keys inherit and cannot widen. Composes with the per-key filter (APIKeyScope.RowFilterID) and with role-based RLS using AND, never OR, so no layer can broaden another. References the same RowLevelSecurityFilter catalog used by role-based RLS. NULL (the default) means the application imposes no row ceiling. The same authoring constraints as APIKeyScope.RowFilterID apply: exact single-entity resource pattern, all referenced columns must exist on that entity, and all referrers of the filter record must resolve to the same entity.`}) 
+    @MaxLength(36)
+    RowFilterID?: string;
+        
     @Field() 
     @MaxLength(100)
     Application: string;
@@ -22286,6 +22360,10 @@ export class MJAPIApplicationScope_ {
     @MaxLength(100)
     Scope: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(100)
+    RowFilter?: string;
+        
 }
 
 //****************************************************************************
@@ -22314,6 +22392,9 @@ export class CreateMJAPIApplicationScopeInput {
     @Field(() => Int, { nullable: true })
     Priority?: number;
 
+    @Field({ nullable: true })
+    RowFilterID: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -22345,6 +22426,9 @@ export class UpdateMJAPIApplicationScopeInput {
     @Field(() => Int, { nullable: true })
     Priority?: number;
 
+    @Field({ nullable: true })
+    RowFilterID?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -22833,6 +22917,10 @@ export class MJAPIKeyScope_ {
     @Field(() => Int, {description: `Rule evaluation order. Higher priority rules are evaluated first. Within same priority, deny rules are evaluated before allow rules.`}) 
     Priority: number;
         
+    @Field({nullable: true, description: `Optional row-level filter narrowing WHICH RECORDS this scope grant applies to, in addition to the resource pattern that governs which entities. References the same RowLevelSecurityFilter catalog used by role-based RLS, so the filter text flows through the standard {{Token}} substitution engine and every existing RLS enforcement point (RunView, Load by primary key, save, delete, search). NULL (the default) means no row restriction — behavior identical to before this column existed. When set, the rule's ResourcePattern must name a single exact entity (no wildcards, no comma-separated lists), every column the filter references must resolve to a real non-virtual field on that entity, and every other referrer of the same filter record must resolve to that same entity. Critically, this filter is evaluated INDEPENDENTLY of the role-RLS exemption: a user exempt from role RLS is still bound by their key's filter, because narrowing a principal below what their roles allow is the entire purpose of a key ceiling.`}) 
+    @MaxLength(36)
+    RowFilterID?: string;
+        
     @Field() 
     @MaxLength(255)
     APIKey: string;
@@ -22841,6 +22929,10 @@ export class MJAPIKeyScope_ {
     @MaxLength(100)
     Scope: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(100)
+    RowFilter?: string;
+        
 }
 
 //****************************************************************************
@@ -22869,6 +22961,9 @@ export class CreateMJAPIKeyScopeInput {
     @Field(() => Int, { nullable: true })
     Priority?: number;
 
+    @Field({ nullable: true })
+    RowFilterID: string | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -22900,6 +22995,9 @@ export class UpdateMJAPIKeyScopeInput {
     @Field(() => Int, { nullable: true })
     Priority?: number;
 
+    @Field({ nullable: true })
+    RowFilterID?: string | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -34383,6 +34481,10 @@ export class MJContentItemChunk_ {
     @MaxLength(250)
     ContentItem?: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(500)
+    ParentChunk?: string;
+        
     @Field({nullable: true}) 
     @MaxLength(36)
     RootParentChunkID?: string;
@@ -46499,6 +46601,19 @@ export class MJEntity_ {
     @MaxLength(255)
     ExternalObjectName?: string;
         
+    @Field({nullable: true, description: `When set, CodeGen generates the entity's full base view under THIS name instead of BaseView, and the application owns BaseView — which is expected to wrap it (SELECT g.*, <extras> FROM <GeneratedBaseViewName> g). This gives an entity a custom base view WITHOUT inheriting the generated SQL: related-entity display joins, geo columns and recursive root-ID columns keep regenerating underneath, so a foreign key added later still appears. NULL (the default, and every pre-existing row) means the previous all-or-nothing behaviour: BaseViewGenerated alone decides whether CodeGen writes BaseView, and there is no second view. BaseView remains the public surface — entity field discovery, permissions and the generated CRUD procedures all target it. SQL SERVER ONLY: layering relies on sp_refreshview to re-resolve the application-owned outer view's SELECT * against a regenerated inner view. PostgreSQL freezes a view's column list at creation and has no refresh equivalent, so CodeGen rejects this column on PostgreSQL rather than let the outer view go silently stale.`}) 
+    @MaxLength(255)
+    GeneratedBaseViewName?: string;
+        
+    @Field(() => Boolean, {description: `When 1, this entity may be populated by INSERT statements that do not go through BaseEntity.Save() — bulk loads, ETL/integration sync, or rows created as a side effect of a stored procedure. Default 0, meaning every insert is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct insert produces neither an audit row nor a cache-invalidation event.`}) 
+    AllowDirectSQLInsert: boolean;
+        
+    @Field(() => Boolean, {description: `When 1, this entity may be modified by UPDATE statements that do not go through BaseEntity.Save() — bulk backfills, integration sync, or maintenance routines. Default 0, meaning every update is expected to flow through BaseEntity so that record-change tracking, entity actions, validation and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, because a direct update produces neither an audit row nor a cache-invalidation event.`}) 
+    AllowDirectSQLUpdate: boolean;
+        
+    @Field(() => Boolean, {description: `When 1, this entity may have rows removed by DELETE statements that do not go through BaseEntity.Delete() — purge and retention routines, or integration sync reconciling a remote source. Default 0, meaning every delete is expected to flow through BaseEntity so that record-change tracking, entity actions, cascade handling and cache invalidation all run. This column DECLARES intent for the code paths and tooling that consult it; it does not and cannot prevent anyone from executing SQL. Requires TrackRecordChanges = 0 and TrustServerCacheCompletely = 0, and additionally requires DeleteType = 'Hard' — a direct DELETE removes the row outright rather than setting DeletedAt, which would defeat soft delete.`}) 
+    AllowDirectSQLDelete: boolean;
+        
     @Field({nullable: true, description: `Schema-based programmatic code name derived from the entity Name. Uses GetClassNameSchemaPrefix(SchemaName) as the prefix, then strips EntityNamePrefix from the Name and removes spaces. For "__mj" schema with entity "MJ: AI Models", this produces "MJAIModels". For entities in other schemas, the sanitized schema name is prepended. Used in GraphQL type generation and internal code references.`}) 
     CodeName?: string;
         
@@ -46737,6 +46852,12 @@ export class MJEntity_ {
     @Field(() => [MJScopedPromptConfig_])
     MJScopedPromptConfigs_PrimaryScopeEntityIDArray: MJScopedPromptConfig_[]; // Link to MJScopedPromptConfigs
     
+    @Field(() => [MJActionExecutionLog_])
+    MJActionExecutionLogs_TargetEntityIDArray: MJActionExecutionLog_[]; // Link to MJActionExecutionLogs
+    
+    @Field(() => [MJEntityAction_])
+    MJEntityActions_ScopeEntityIDArray: MJEntityAction_[]; // Link to MJEntityActions
+    
 }
 
 //****************************************************************************
@@ -46933,6 +47054,18 @@ export class CreateMJEntityInput {
     @Field({ nullable: true })
     ExternalObjectName: string | null;
 
+    @Field({ nullable: true })
+    GeneratedBaseViewName: string | null;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLInsert?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLUpdate?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLDelete?: boolean;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -47132,6 +47265,18 @@ export class UpdateMJEntityInput {
     @Field({ nullable: true })
     ExternalObjectName?: string | null;
 
+    @Field({ nullable: true })
+    GeneratedBaseViewName?: string | null;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLInsert?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLUpdate?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowDirectSQLDelete?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -47916,6 +48061,26 @@ export class MJEntityResolverBase extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJActionExecutionLog_])
+    async MJActionExecutionLogs_TargetEntityIDArray(@Root() mjentity_: MJEntity_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Action Execution Logs', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwActionExecutionLogs')} WHERE ${provider.QuoteIdentifier('TargetEntityID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Action Execution Logs', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjentity_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Action Execution Logs', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
+    @FieldResolver(() => [MJEntityAction_])
+    async MJEntityActions_ScopeEntityIDArray(@Root() mjentity_: MJEntity_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Entity Actions', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwEntityActions')} WHERE ${provider.QuoteIdentifier('ScopeEntityID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Entity Actions', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjentity_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Entity Actions', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJEntity_)
     async CreateMJEntity(
         @Arg('input', () => CreateMJEntityInput) input: CreateMJEntityInput,
@@ -48150,6 +48315,9 @@ export class MJEntityActionInvocationType_ {
     @Field(() => [MJEntityActionInvocation_])
     MJEntityActionInvocations_InvocationTypeIDArray: MJEntityActionInvocation_[]; // Link to MJEntityActionInvocations
     
+    @Field(() => [MJActionExecutionLog_])
+    MJActionExecutionLogs_EntityActionInvocationTypeIDArray: MJActionExecutionLog_[]; // Link to MJActionExecutionLogs
+    
 }
 
 //****************************************************************************
@@ -48265,6 +48433,16 @@ export class MJEntityActionInvocationTypeResolver extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJActionExecutionLog_])
+    async MJActionExecutionLogs_EntityActionInvocationTypeIDArray(@Root() mjentityactioninvocationtype_: MJEntityActionInvocationType_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Action Execution Logs', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwActionExecutionLogs')} WHERE ${provider.QuoteIdentifier('EntityActionInvocationTypeID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Action Execution Logs', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjentityactioninvocationtype_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Action Execution Logs', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJEntityActionInvocationType_)
     async CreateMJEntityActionInvocationType(
         @Arg('input', () => CreateMJEntityActionInvocationTypeInput) input: CreateMJEntityActionInvocationTypeInput,
@@ -48490,7 +48668,7 @@ export class MJEntityActionParam_ {
     @MaxLength(36)
     ActionParamID: string;
         
-    @Field({description: `Type of the value, which can be Static, Entity Object, or Script.`}) 
+    @Field({description: `How the parameter value is produced at invocation time. Static = the literal Value (parsed as JSON when it parses). Entity Object = the live BaseEntity instance, for actions that call entity methods. Entity Object Data = entity.GetAll(), a plain object - use this for any action that SERIALIZES the value, such as the Data payload of Execute Agent, because a BaseEntity serializes to {} (its fields are getters, not enumerable own properties). Entity Field = the named field's value. Script = evaluated expression with the entity in scope.`}) 
     @MaxLength(20)
     ValueType: string;
         
@@ -48506,6 +48684,9 @@ export class MJEntityActionParam_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field(() => Boolean, {nullable: true, description: `Optional per-binding override of ActionParam.LogValue. NULL (the default) inherits the parameter definition. Set to 0 when this particular binding passes something sensitive through a parameter that is ordinarily safe to log - a message body through a generic Text parameter, for instance. Cannot re-enable logging for a value type the hard rule suppresses.`}) 
+    LogValue?: boolean;
+        
     @Field() 
     @MaxLength(425)
     EntityAction: string;
@@ -48539,6 +48720,9 @@ export class CreateMJEntityActionParamInput {
     @Field({ nullable: true })
     Comments: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    LogValue: boolean | null;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -48567,6 +48751,9 @@ export class UpdateMJEntityActionParamInput {
     @Field({ nullable: true })
     Comments?: string | null;
 
+    @Field(() => Boolean, { nullable: true })
+    LogValue?: boolean | null;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -48687,6 +48874,21 @@ export class MJEntityAction_ {
     @MaxLength(36)
     ID: string;
         
+    @Field(() => Int, {description: `Execution order when multiple Entity Actions are bound to the same entity and invocation type. Lower runs first; ties fall back to creation order. Defaults to 0 so existing rows are unaffected.`}) 
+    Sequence: number;
+        
+    @Field({nullable: true, description: `Optional. Together with ScopeRecordID, narrows this Entity Action to records related to ONE specific record - for example a single Deal Type, Contract Type, Pipeline or Company - rather than every record of EntityID. NULL (the default) means the action applies to all records, which is the pre-existing behaviour. How a scope record relates to the subject record is resolved by the app that owns the scope entity; the framework only stores and filters on the pair.`}) 
+    @MaxLength(36)
+    ScopeEntityID?: string;
+        
+    @Field({nullable: true, description: `Optional. The primary key of the scope record, as text, paired with ScopeEntityID. Both columns are NULL or both are set (CK_EntityAction_Scope). Lets a configuration record such as a Deal Type surface "the workflows bound to me" as a real relationship rather than something buried in filter code.`}) 
+    @MaxLength(450)
+    ScopeRecordID?: string;
+        
+    @Field({description: `How much of this binding's activity reaches ActionExecutionLog. All (default) writes a row per invocation. FailuresOnly writes only runs that did not succeed - the right setting for a high-frequency binding on a busy entity, where the successful runs are noise. None disables logging for the binding entirely and should be rare, because it also removes the failure record.`}) 
+    @MaxLength(20)
+    LoggingMode: string;
+        
     @Field() 
     @MaxLength(255)
     Entity: string;
@@ -48695,6 +48897,10 @@ export class MJEntityAction_ {
     @MaxLength(425)
     Action: string;
         
+    @Field({nullable: true}) 
+    @MaxLength(255)
+    ScopeEntity?: string;
+        
     @Field(() => [MJEntityActionFilter_])
     MJEntityActionFilters_EntityActionIDArray: MJEntityActionFilter_[]; // Link to MJEntityActionFilters
     
@@ -48704,6 +48910,9 @@ export class MJEntityAction_ {
     @Field(() => [MJEntityActionParam_])
     MJEntityActionParams_EntityActionIDArray: MJEntityActionParam_[]; // Link to MJEntityActionParams
     
+    @Field(() => [MJActionExecutionLog_])
+    MJActionExecutionLogs_EntityActionIDArray: MJActionExecutionLog_[]; // Link to MJActionExecutionLogs
+    
 }
 
 //****************************************************************************
@@ -48723,6 +48932,18 @@ export class CreateMJEntityActionInput {
     @Field({ nullable: true })
     ID?: string;
 
+    @Field(() => Int, { nullable: true })
+    Sequence?: number;
+
+    @Field({ nullable: true })
+    ScopeEntityID: string | null;
+
+    @Field({ nullable: true })
+    ScopeRecordID: string | null;
+
+    @Field({ nullable: true })
+    LoggingMode?: string;
+
     @Field(() => RestoreContextInput, { nullable: true })
     RestoreContext___?: RestoreContextInput;
 }
@@ -48745,6 +48966,18 @@ export class UpdateMJEntityActionInput {
     @Field()
     ID: string;
 
+    @Field(() => Int, { nullable: true })
+    Sequence?: number;
+
+    @Field({ nullable: true })
+    ScopeEntityID?: string | null;
+
+    @Field({ nullable: true })
+    ScopeRecordID?: string | null;
+
+    @Field({ nullable: true })
+    LoggingMode?: string;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 
@@ -48839,6 +49072,16 @@ export class MJEntityActionResolver extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJActionExecutionLog_])
+    async MJActionExecutionLogs_EntityActionIDArray(@Root() mjentityaction_: MJEntityAction_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: Action Execution Logs', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwActionExecutionLogs')} WHERE ${provider.QuoteIdentifier('EntityActionID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: Action Execution Logs', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjentityaction_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: Action Execution Logs', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJEntityAction_)
     async CreateMJEntityAction(
         @Arg('input', () => CreateMJEntityActionInput) input: CreateMJEntityActionInput,
@@ -77389,6 +77632,12 @@ export class MJRowLevelSecurityFilter_ {
     @Field(() => [MJEntityPermission_])
     MJEntityPermissions_UpdateRLSFilterIDArray: MJEntityPermission_[]; // Link to MJEntityPermissions
     
+    @Field(() => [MJAPIKeyScope_])
+    MJAPIKeyScopes_RowFilterIDArray: MJAPIKeyScope_[]; // Link to MJAPIKeyScopes
+    
+    @Field(() => [MJAPIApplicationScope_])
+    MJAPIApplicationScopes_RowFilterIDArray: MJAPIApplicationScope_[]; // Link to MJAPIApplicationScopes
+    
 }
 
 //****************************************************************************
@@ -77544,6 +77793,26 @@ export class MJRowLevelSecurityFilterResolver extends ResolverBase {
         return result;
     }
         
+    @FieldResolver(() => [MJAPIKeyScope_])
+    async MJAPIKeyScopes_RowFilterIDArray(@Root() mjrowlevelsecurityfilter_: MJRowLevelSecurityFilter_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: API Key Scopes', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwAPIKeyScopes')} WHERE ${provider.QuoteIdentifier('RowFilterID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: API Key Scopes', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjrowlevelsecurityfilter_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: API Key Scopes', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
+    @FieldResolver(() => [MJAPIApplicationScope_])
+    async MJAPIApplicationScopes_RowFilterIDArray(@Root() mjrowlevelsecurityfilter_: MJRowLevelSecurityFilter_, @Ctx() { userPayload, providers }: AppContext, @PubSub() pubSub: PubSubEngine) {
+        this.CheckUserReadPermissions('MJ: API Application Scopes', userPayload);
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        const sSQL = `SELECT * FROM ${provider.QuoteSchemaAndView(Metadata.Provider.ConfigData.MJCoreSchemaName, 'vwAPIApplicationScopes')} WHERE ${provider.QuoteIdentifier('RowFilterID')}=${provider.BuildParameterPlaceholder(0)} ` + this.getRowLevelSecurityWhereClause(provider, 'MJ: API Application Scopes', userPayload, EntityPermissionType.Read, 'AND');
+        const rows = await provider.ExecuteSQL(sSQL, [mjrowlevelsecurityfilter_.ID], undefined, this.GetUserFromPayload(userPayload));
+        const result = await this.ArrayMapFieldNamesToCodeNames('MJ: API Application Scopes', rows, this.GetUserFromPayload(userPayload));
+        return result;
+    }
+        
     @Mutation(() => MJRowLevelSecurityFilter_)
     async CreateMJRowLevelSecurityFilter(
         @Arg('input', () => CreateMJRowLevelSecurityFilterInput) input: CreateMJRowLevelSecurityFilterInput,
@@ -93056,6 +93325,10 @@ export class MJUserViewRunDetail_ {
     @Field() 
     _mj__UpdatedAt: Date;
         
+    @Field() 
+    @MaxLength(100)
+    UserViewRun: string;
+        
     @Field() 
     @MaxLength(36)
     UserViewID: string;

package/src/generic/FireAndForgetHeartbeat.ts

@@ -1,6 +1,6 @@
 import { PubSubEngine } from 'type-graphql';
 import { LogError } from '@memberjunction/core';
-import { PUSH_STATUS_UPDATES_TOPIC } from './PushStatusResolver.js';
+import { publishStatusUpdate } from './PushStatusResolver.js';
 
 /** Default cadence for fire-and-forget liveness pulses (5 minutes). */
 export const DEFAULT_PULSE_INTERVAL_MS = 5 * 60 * 1000;
@@ -32,6 +32,11 @@ export interface LivenessPulseOptions {
     pubSub: PubSubEngine;
     /** Session the client is subscribed on (used by the subscription filter). */
     sessionId: string;
+    /**
+     * Authenticated user the operation belongs to (B49). Stamped on every pulse so the
+     * subscription filter binds delivery to identity, not just the client-chosen sessionId.
+     */
+    ownerUserId: string;
     /** Resolver label echoed in the message envelope (e.g. 'RunAIAgentResolver'). */
     resolver: string;
     /** Pulse cadence in ms. Defaults to {@link DEFAULT_PULSE_INTERVAL_MS}. */
@@ -56,7 +61,7 @@ export interface LivenessPulseOptions {
  * so the client receives it through the same subscription with no special parsing.
  */
 export function startLivenessPulse(options: LivenessPulseOptions): LivenessPulseHandle {
-    const { pubSub, sessionId, resolver, readStatus } = options;
+    const { pubSub, sessionId, ownerUserId, resolver, readStatus } = options;
     const intervalMs = options.intervalMs ?? DEFAULT_PULSE_INTERVAL_MS;
 
     const timer = setInterval(() => {
@@ -68,14 +73,15 @@ export function startLivenessPulse(options: LivenessPulseOptions): LivenessPulse
             LogError(`[LivenessPulse:${resolver}] readStatus failed: ${(e as Error).message}`);
         }
 
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+        publishStatusUpdate(pubSub, {
+            sessionId,
+            ownerUserId,
             message: JSON.stringify({
                 resolver,
                 type: HEARTBEAT_MESSAGE_TYPE,
                 status: 'ok',
                 data: data ?? {},
             }),
-            sessionId,
         });
     }, intervalMs);