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

package/src/resolvers/RunTestResolver.ts

@@ -15,7 +15,7 @@ import { AppContext, UserPayload } from '../types.js';
 import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { TestEngine } from '@memberjunction/testing-engine';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
+import { StartLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult } from '@memberjunction/testing-engine-base';
 
 // ===== GraphQL Types =====
@@ -23,73 +23,73 @@ import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult
 @ObjectType()
 export class TestRunResult {
     @Field()
-    success: boolean;
+    success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    errorMessage?: string;
+    errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    executionTimeMs?: number;
+    executionTimeMs?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    result: string; // JSON serialized TestRunResult
+    result: string; // JSON serialized TestRunResult — case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TestSuiteRunResult {
     @Field()
-    success: boolean;
+    success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    errorMessage?: string;
+    errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    executionTimeMs?: number;
+    executionTimeMs?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    result: string; // JSON serialized TestSuiteRunResult
+    result: string; // JSON serialized TestSuiteRunResult — case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TestExecutionProgress {
     @Field()
-    currentStep: string;
+    currentStep: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    percentage: number;
+    percentage: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    message: string;
+    message: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    testName?: string;
+    testName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    driverType?: string;
+    driverType?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    oracleEvaluation?: string;
+    oracleEvaluation?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TestExecutionStreamMessage {
     @Field(() => ID)
-    sessionId: string;
+    sessionId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => ID)
-    testRunId: string;
+    testRunId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    type: 'progress' | 'oracle_eval' | 'complete' | 'error';
+    type: 'progress' | 'oracle_eval' | 'complete' | 'error';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    progress?: TestExecutionProgress;
+    progress?: TestExecutionProgress;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    timestamp: Date;
+    timestamp: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     // Not a GraphQL field - used internally
-    testRun?: Record<string, unknown>;
+    testRun?: Record<string, unknown>;  // case-violation-ok-legacy-back-compat: an accessor cannot be optional, so a stub would turn this into a required member
 }
 
 // ===== Resolver =====
@@ -256,7 +256,7 @@ export class RunTestResolver extends ResolverBase {
     ): void {
         // Keep-alive pulse so a long-running test never trips the client idle timeout.
         // The client captures the testRunId from progress events for reconciliation.
-        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
+        const pulse = StartLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
 
         this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user)
             .catch((error: unknown) => {
@@ -264,7 +264,7 @@ export class RunTestResolver extends ResolverBase {
                 LogError(`🔥 Fire-and-forget test execution failed: ${errorMessage}`, undefined, error);
                 this.publishFireAndForgetError(pubSub, userPayload, testId, errorMessage);
             })
-            .finally(() => pulse.stop());
+            .finally(() => pulse.Stop());
     }
 
     /**
@@ -352,7 +352,7 @@ export class RunTestResolver extends ResolverBase {
         // (Suite reconciliation isn't wired: suite progress carries the per-test run id, not the
         // Test Suite Run id, so the client has no handle to reconcile against — the pulse is the
         // protection here.)
-        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
+        const pulse = StartLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
 
         this.executeSuite(
             suiteId, verbose, environment, parallel, tags, variables,
@@ -361,7 +361,7 @@ export class RunTestResolver extends ResolverBase {
             const errorMessage = (error instanceof Error) ? error.message : 'Unknown background suite execution error';
             LogError(`🔥 Fire-and-forget suite execution failed: ${errorMessage}`, undefined, error);
             this.publishFireAndForgetSuiteError(pubSub, userPayload, suiteId, errorMessage);
-        }).finally(() => pulse.stop());
+        }).finally(() => pulse.Stop());
     }
 
     // ===== Result Building =====

package/src/resolvers/SqlLoggingConfigResolver.ts

@@ -5,7 +5,7 @@ import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 import { v4 as uuidv4 } from 'uuid';
 import * as path from 'path';
 import * as fs from 'fs/promises';
-import { loadConfig } from '../config.js';
+import { LoadConfig } from '../config.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadOnlyProvider } from '../util.js';
 import { UserCache, SqlLoggingOptions as ProviderSqlLoggingOptions } from '@memberjunction/generic-database-provider';
@@ -18,187 +18,187 @@ import { UserCache, SqlLoggingOptions as ProviderSqlLoggingOptions } from '@memb
 export class SqlLoggingOptions {
   /** Whether to format SQL output as a database migration file with proper headers */
   @Field(() => Boolean, { nullable: true })
-  formatAsMigration?: boolean;
+  formatAsMigration?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Optional description or notes for this logging configuration */
   @Field(() => String, { nullable: true })
-  description?: string;
+  description?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Types of SQL statements to capture: 'queries', 'mutations', or 'both' */
   @Field(() => String, { nullable: true })
-  statementTypes?: 'queries' | 'mutations' | 'both';
+  statementTypes?: 'queries' | 'mutations' | 'both';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** String separator to use between SQL statements (e.g., 'GO' for SQL Server) */
   @Field(() => String, { nullable: true })
-  batchSeparator?: string;
+  batchSeparator?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to format SQL with proper indentation and line breaks */
   @Field(() => Boolean, { nullable: true })
-  prettyPrint?: boolean;
+  prettyPrint?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to include metadata about record changes in the log output */
   @Field(() => Boolean, { nullable: true })
-  logRecordChangeMetadata?: boolean;
+  logRecordChangeMetadata?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to keep log files even if they contain no SQL statements */
   @Field(() => Boolean, { nullable: true })
-  retainEmptyLogFiles?: boolean;
+  retainEmptyLogFiles?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Email address to filter SQL statements by user (when filtering is enabled) */
   @Field(() => String, { nullable: true })
-  filterByUserId?: string;
+  filterByUserId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Array of regex/wildcard patterns to filter SQL statements */
   @Field(() => [String], { nullable: true })
-  filterPatterns?: string[];
+  filterPatterns?: string[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** How to apply patterns: 'include' or 'exclude' (default: exclude) */
   @Field(() => String, { nullable: true })
-  filterType?: 'include' | 'exclude';
+  filterType?: 'include' | 'exclude';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to output verbose debug information to console */
   @Field(() => Boolean, { nullable: true })
-  verboseOutput?: boolean;
+  verboseOutput?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Default schema name for Flyway migration placeholder replacement */
   @Field(() => String, { nullable: true })
-  defaultSchemaName?: string;
+  defaultSchemaName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Human-readable name for the logging session */
   @Field(() => String, { nullable: true })
-  sessionName?: string;
+  sessionName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class SqlLoggingSession {
   /** Unique identifier for this logging session */
   @Field(() => String)
-  id: string;
+  id: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Absolute file path where SQL statements are being logged */
   @Field(() => String)
-  filePath: string;
+  filePath: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Timestamp when this logging session was started */
   @Field(() => Date)
-  startTime: Date;
+  startTime: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Number of SQL statements captured so far in this session */
   @Field(() => Int)
-  statementCount: number;
+  statementCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Configuration options applied to this logging session */
   @Field(() => SqlLoggingOptions)
-  options: SqlLoggingOptions;
+  options: SqlLoggingOptions;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Human-readable name for this logging session */
   @Field(() => String, { nullable: true })
-  sessionName?: string;
+  sessionName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Email address of user whose SQL is being filtered (if filtering enabled) */
   @Field(() => String, { nullable: true })
-  filterByUserId?: string;
+  filterByUserId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
 export class SqlLoggingOptionsInput {
   /** Whether to format SQL output as a database migration file with proper headers */
   @Field(() => Boolean, { nullable: true })
-  formatAsMigration?: boolean;
+  formatAsMigration?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Optional description or notes for this logging configuration */
   @Field(() => String, { nullable: true })
-  description?: string;
+  description?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Types of SQL statements to capture: 'queries', 'mutations', or 'both' */
   @Field(() => String, { nullable: true })
-  statementTypes?: 'queries' | 'mutations' | 'both';
+  statementTypes?: 'queries' | 'mutations' | 'both';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** String separator to use between SQL statements (e.g., 'GO' for SQL Server) */
   @Field(() => String, { nullable: true })
-  batchSeparator?: string;
+  batchSeparator?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to format SQL with proper indentation and line breaks */
   @Field(() => Boolean, { nullable: true })
-  prettyPrint?: boolean;
+  prettyPrint?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to include metadata about record changes in the log output */
   @Field(() => Boolean, { nullable: true })
-  logRecordChangeMetadata?: boolean;
+  logRecordChangeMetadata?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to keep log files even if they contain no SQL statements */
   @Field(() => Boolean, { nullable: true })
-  retainEmptyLogFiles?: boolean;
+  retainEmptyLogFiles?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Email address to filter SQL statements by user (when filtering is enabled) */
   @Field(() => String, { nullable: true })
-  filterByUserId?: string;
+  filterByUserId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Array of regex/wildcard patterns to filter SQL statements */
   @Field(() => [String], { nullable: true })
-  filterPatterns?: string[];
+  filterPatterns?: string[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** How to apply patterns: 'include' or 'exclude' (default: exclude) */
   @Field(() => String, { nullable: true })
-  filterType?: 'include' | 'exclude';
+  filterType?: 'include' | 'exclude';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to output verbose debug information to console */
   @Field(() => Boolean, { nullable: true })
-  verboseOutput?: boolean;
+  verboseOutput?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Default schema name for Flyway migration placeholder replacement */
   @Field(() => String, { nullable: true })
-  defaultSchemaName?: string;
+  defaultSchemaName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Human-readable name for the logging session */
   @Field(() => String, { nullable: true })
-  sessionName?: string;
+  sessionName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
 export class StartSqlLoggingInput {
   /** Optional custom filename for the SQL log file (auto-generated if not provided) */
   @Field(() => String, { nullable: true })
-  fileName?: string;
+  fileName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Configuration options for the logging session (merged with server defaults) */
   @Field(() => SqlLoggingOptionsInput, { nullable: true })
-  options?: SqlLoggingOptionsInput;
+  options?: SqlLoggingOptionsInput;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to filter SQL statements to only those from the current user */
   @Field(() => Boolean, { nullable: true })
-  filterToCurrentUser?: boolean;
+  filterToCurrentUser?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class SqlLoggingConfig {
   /** Whether SQL logging is enabled in the server configuration */
   @Field(() => Boolean)
-  enabled: boolean;
+  enabled: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Default logging options applied to new sessions (can be overridden) */
   @Field(() => SqlLoggingOptions)
-  defaultOptions: SqlLoggingOptions;
+  defaultOptions: SqlLoggingOptions;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Directory path where SQL log files are allowed to be created */
   @Field(() => String)
-  allowedLogDirectory: string;
+  allowedLogDirectory: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Maximum number of concurrent SQL logging sessions allowed */
   @Field(() => Int)
-  maxActiveSessions: number;
+  maxActiveSessions: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Whether to automatically delete log files that contain no SQL statements */
   @Field(() => Boolean)
-  autoCleanupEmptyFiles: boolean;
+  autoCleanupEmptyFiles: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Timeout in milliseconds after which inactive sessions are automatically stopped */
   @Field(() => Int)
-  sessionTimeout: number;
+  sessionTimeout: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** Current number of active SQL logging sessions */
   @Field(() => Int)
-  activeSessionCount: number;
+  activeSessionCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -312,9 +312,9 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Query(() => SqlLoggingConfig)
-  async sqlLoggingConfig(@Ctx() context: AppContext): Promise<SqlLoggingConfig> {
+  async sqlLoggingConfig(@Ctx() context: AppContext): Promise<SqlLoggingConfig> {  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     await this.checkOwnerAccess(context);
-    const config = await loadConfig();
+    const config = await LoadConfig();
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const activeSessions = provider.GetActiveSqlLoggingSessions();
 
@@ -368,7 +368,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Query(() => [SqlLoggingSession])
-  async activeSqlLoggingSessions(@Ctx() context: AppContext): Promise<SqlLoggingSession[]> {
+  async activeSqlLoggingSessions(@Ctx() context: AppContext): Promise<SqlLoggingSession[]> {  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     await this.checkOwnerAccess(context);
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
@@ -422,12 +422,12 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Mutation(() => SqlLoggingSession)
-  async startSqlLogging(
+  async startSqlLogging(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     @Arg('input', () => StartSqlLoggingInput) input: StartSqlLoggingInput,
     @Ctx() context: AppContext
   ): Promise<SqlLoggingSession> {
     await this.checkOwnerAccess(context);
-    const config = await loadConfig();
+    const config = await LoadConfig();
     
     // Check if SQL logging is enabled
     if (!config.sqlLogging?.enabled) {
@@ -516,7 +516,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Mutation(() => Boolean)
-  async stopSqlLogging(
+  async stopSqlLogging(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     @Arg('sessionId', () => String) sessionId: string,
     @Ctx() context: AppContext
   ): Promise<boolean> {
@@ -562,7 +562,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Mutation(() => Boolean)
-  async stopAllSqlLogging(@Ctx() context: AppContext): Promise<boolean> {
+  async stopAllSqlLogging(@Ctx() context: AppContext): Promise<boolean> {  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     await this.checkOwnerAccess(context);
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     await provider.DisposeAllSqlLoggingSessions();
@@ -597,14 +597,14 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Mutation(() => SqlLoggingOptions)
-  async updateSqlLoggingDefaults(
+  async updateSqlLoggingDefaults(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     @Arg('options', () => SqlLoggingOptionsInput) options: SqlLoggingOptionsInput,
     @Ctx() context: AppContext
   ): Promise<SqlLoggingOptions> {
     await this.checkOwnerAccess(context);
     // Note: This updates the runtime configuration only, not the file
     // In a production system, you might want to persist this to a database
-    const config = await loadConfig();
+    const config = await LoadConfig();
     if (!config.sqlLogging) {
       throw new Error('SQL logging configuration not found');
     }
@@ -640,13 +640,13 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * ```
    */
   @Query(() => String)
-  async readSqlLogFile(
+  async readSqlLogFile(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     @Arg('sessionId', () => String) sessionId: string,
     @Arg('maxLines', () => Int, { nullable: true }) maxLines: number | null,
     @Ctx() context: AppContext
   ): Promise<string> {
     await this.checkOwnerAccess(context);
-    const config = await loadConfig();
+    const config = await LoadConfig();
     
     // Check if SQL logging is enabled
     if (!config.sqlLogging?.enabled) {
@@ -707,7 +707,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * @throws Error if user doesn't have Owner privileges
    */
   @Query(() => String)
-  async debugCurrentUserEmail(@Ctx() context: AppContext): Promise<string> {
+  async debugCurrentUserEmail(@Ctx() context: AppContext): Promise<string> {  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     await this.checkOwnerAccess(context);
 
     const contextUserEmail = context.userPayload?.email || 'NOT_SET';

package/src/resolvers/TaskGraphFrameResolver.ts

@@ -26,86 +26,86 @@ export const TASK_GRAPH_FRAMES_TOPIC = 'TASK_GRAPH_FRAMES';
 @ObjectType()
 export class TaskGraphFrameNotification {
   @Field(() => String)
-  kind!: string;
+  kind!: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => ID)
-  parentTaskId!: string;
+  parentTaskId!: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => ID, { nullable: true })
-  taskId?: string;
+  taskId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  taskName?: string;
+  taskName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  status?: string;
+  status?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  errorMessage?: string;
+  errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => ID, { nullable: true })
-  assignedUserId?: string;
+  assignedUserId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  completedCount?: number;
+  completedCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  totalCount?: number;
+  totalCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   // ── GateDecision ──────────────────────────────────────────────────────────
   @Field(() => ID, { nullable: true })
-  edgeId?: string;
+  edgeId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => ID, { nullable: true })
-  dependsOnTaskId?: string;
+  dependsOnTaskId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** 'satisfied' | 'notTaken' | 'held' */
   @Field(() => String, { nullable: true })
-  verdict?: string;
+  verdict?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  conditionText?: string;
+  conditionText?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  reason?: string;
+  reason?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   // ── ClaimChanged ──────────────────────────────────────────────────────────
   /** 'claimed' | 'heartbeat-lost' | 'reclaimed' */
   @Field(() => String, { nullable: true })
-  claimEvent?: string;
+  claimEvent?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  claimedBy?: string;
+  claimedBy?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  claimExpiresAt?: string;
+  claimExpiresAt?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   // ── PassCompleted ─────────────────────────────────────────────────────────
   @Field(() => Number, { nullable: true })
-  passNumber?: number;
+  passNumber?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  eligibleCount?: number;
+  eligibleCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  heldCount?: number;
+  heldCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  claimedCount?: number;
+  claimedCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   /** The dispatcher instance's own load across every graph — not this graph's in-flight count. */
   @Field(() => Number, { nullable: true })
-  instanceInFlightCount?: number;
+  instanceInFlightCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   // ── NodeProgress ──────────────────────────────────────────────────────────
   @Field(() => String, { nullable: true })
-  progressMessage?: string;
+  progressMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  progressPercent?: number;
+  progressPercent?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Date)
-  date!: Date;
+  date!: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -137,7 +137,7 @@ export interface TaskGraphFrameFilterContext {
  * another user's workflow — including its per-step error messages. **Fails closed** — a missing
  * identity on either side never matches.
  */
-export function taskGraphFrameFilter(data: {
+export function TaskGraphFrameFilter(data: {
   payload: TaskGraphFramePayload;
   args: TaskGraphFrameArgs;
   context: TaskGraphFrameFilterContext | undefined;
@@ -156,6 +156,15 @@ export function taskGraphFrameFilter(data: {
   return UUIDsEqual(payload.ownerUserId, connectionUserId);
 }
 
+/** @deprecated Use {@link TaskGraphFrameFilter}. */
+export function taskGraphFrameFilter(data: {
+  payload: TaskGraphFramePayload;
+  args: TaskGraphFrameArgs;
+  context: TaskGraphFrameFilterContext | undefined;
+}): boolean {
+  return TaskGraphFrameFilter(data);
+}
+
 /**
  * MJServer's `TaskGraphObserver` — turns dispatcher frames into a PubSub publish.
  *
@@ -189,9 +198,9 @@ export class TaskGraphFrameResolver {
   @Subscription(() => TaskGraphFrameNotification, {
     topics: TASK_GRAPH_FRAMES_TOPIC,
     filter: (data: ResolverFilterData<TaskGraphFramePayload, TaskGraphFrameArgs, TaskGraphFrameFilterContext>) =>
-      taskGraphFrameFilter(data),
+      TaskGraphFrameFilter(data),
   })
-  taskGraphFrames(
+  taskGraphFrames(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
     @Root() payload: TaskGraphFramePayload,
     @Arg('parentTaskId', () => ID) parentTaskId: string
   ): TaskGraphFrameNotification {