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

package/src/resolvers/GetDataResolver.ts

@@ -6,8 +6,8 @@ import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { NoLog } from '../logging/NoLog.js';
 import { v4 as uuidv4 } from 'uuid';
 import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
-import { getDbType } from '../index.js';
-import { getSystemUser } from '../auth/index.js';
+import { GetDbType } from '../index.js';
+import { GetSystemUser } from '../auth/index.js';
 import sql from 'mssql';
  
 @InputType()
@@ -125,7 +125,7 @@ export class GetDataResolver {
             LogStatus(`GetData invoked: ${input.Queries.length} queries`);
 
             // validate the token
-            if (!isTokenValid(input.Token)) {
+            if (!IsTokenValid(input.Token)) {
                 throw new Error(`Token ${input.Token} is not valid or has expired`);
             }
 
@@ -139,8 +139,8 @@ export class GetDataResolver {
             // Queries may contain {{query:"CategoryPath/QueryName(params)"}} tokens that
             // reference reusable queries. These must be resolved to CTEs before raw SQL execution.
             const compositionEngine = new QueryCompositionEngine();
-            const platform = getDbType();
-            const systemUser = await getSystemUser();
+            const platform = GetDbType();
+            const systemUser = await GetSystemUser();
 
             // Execute all queries in parallel, but execute each individual query in its own try catch block so that if one fails, the others can still be processed
             // and also so that we can capture the error message for each query and return it
@@ -204,7 +204,7 @@ export class GetDataResolver {
                                 Queries: input.Queries, 
                                 ErrorMessages: errorMessages }
 
-            recordTokenUse(input.Token, {request: input, results: returnVal});
+            RecordTokenUse(input.Token, {request: input, results: returnVal});
 
             // Success below is derived from having no errorMessages, check that array
             return returnVal;
@@ -296,7 +296,7 @@ const __defaultTokenLifeSpan = 1000 * 60 * 5; // 5 minutes
  * Critical finding).
  * @param now injectable for tests; defaults to the real current time
  */
-export function pruneExpiredTokens(now: Date = new Date()): void {
+export function PruneExpiredTokens(now: Date = new Date()): void {
     for (let i = __accessTokens.length - 1; i >= 0; i--) {
         if (__accessTokens[i].ExpiresAt <= now) {
             __accessTokens.splice(i, 1);
@@ -304,17 +304,27 @@ export function pruneExpiredTokens(now: Date = new Date()): void {
     }
 }
 
+/** @deprecated Use {@link PruneExpiredTokens}. */
+export function pruneExpiredTokens(now: Date = new Date()): void {
+    return PruneExpiredTokens(now);
+}
+
 /** Number of tokens currently tracked (post-sweep, at last mutation). Exposed for tests/diagnostics. */
-export function getAccessTokenCount(): number {
+export function GetAccessTokenCount(): number {
     return __accessTokens.length;
 }
 
-export function registerAccessToken(token?: string, lifeSpan: number = __defaultTokenLifeSpan, requestorPayload?: any): GetDataAccessToken {
-    pruneExpiredTokens();
+/** @deprecated Use {@link GetAccessTokenCount}. */
+export function getAccessTokenCount(): number {
+    return GetAccessTokenCount();
+}
+
+export function RegisterAccessToken(token?: string, lifeSpan: number = __defaultTokenLifeSpan, requestorPayload?: any): GetDataAccessToken {
+    PruneExpiredTokens();
 
     const tokenToUse = token || uuidv4();
 
-    if (tokenExists(tokenToUse)) {
+    if (TokenExists(tokenToUse)) {
         // should never happen if we used the uuidv4() function but could happen if someone tries to use a custom token
         throw new Error(`Token ${tokenToUse} already exists`);
     }
@@ -327,7 +337,12 @@ export function registerAccessToken(token?: string, lifeSpan: number = __default
     __accessTokens.push(newToken);
     return newToken;
 }
-export function deleteAccessToken(token: string) {
+
+/** @deprecated Use {@link RegisterAccessToken}. */
+export function registerAccessToken(token?: string, lifeSpan: number = __defaultTokenLifeSpan, requestorPayload?: any): GetDataAccessToken {
+    return RegisterAccessToken(token, lifeSpan, requestorPayload);
+}
+export function DeleteAccessToken(token: string) {
     const index = __accessTokens.findIndex((t) => t.Token === token);
     if (index >= 0) {
         __accessTokens.splice(index, 1);
@@ -336,17 +351,32 @@ export function deleteAccessToken(token: string) {
         throw new Error(`Token ${token} does not exist`);
     }
 }
-export function tokenExists(token: string) {
+
+/** @deprecated Use {@link DeleteAccessToken}. */
+export function deleteAccessToken(token: string) {
+    return DeleteAccessToken(token);
+}
+export function TokenExists(token: string) {
     return __accessTokens.find((t) => t.Token === token) !== undefined;
 }
-export function isTokenValid(token: string) {
+
+/** @deprecated Use {@link TokenExists}. */
+export function tokenExists(token: string) {
+    return TokenExists(token);
+}
+export function IsTokenValid(token: string) {
     const t = __accessTokens.find((t) => t.Token === token);
     if (t) {
         return t.ExpiresAt > new Date();
     }
     return false;
+}
+
+/** @deprecated Use {@link IsTokenValid}. */
+export function isTokenValid(token: string) {
+    return IsTokenValid(token);
 } 
-export function recordTokenUse(token: string, usePayload: any) {
+export function RecordTokenUse(token: string, usePayload: any) {
     const t = __accessTokens.find((t) => t.Token === token);
     if (t) {
         if (!t.TokenUses) {
@@ -358,3 +388,8 @@ export function recordTokenUse(token: string, usePayload: any) {
         throw new Error(`Token ${token} does not exist`);
     }
 }
+
+/** @deprecated Use {@link RecordTokenUse}. */
+export function recordTokenUse(token: string, usePayload: any) {
+    return RecordTokenUse(token, usePayload);
+}

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -56,7 +56,7 @@ import { IntegrationProgressEmitter, IntegrationProgressReader } from "@memberju
 import type { IntegrationRunSnapshot, IntegrationRunKind } from "@memberjunction/integration-progress-artifacts";
 import { ResolverBase } from "../generic/ResolverBase.js";
 import { IntegrationCustomColumnPromoter } from "../integration/CustomColumnPromoter.js";
-import { ComputeCascadeRemovalSet, ComputeRemovedDependencyWarnings, decideFieldMapReconcile, DisableUnselectedEntityMaps, ReenableFieldMapsForEntityMap, ResetPullWatermarks, SetEntityMapEnabled } from "../integration/EntityMapLifecycle.js";
+import { ComputeCascadeRemovalSet, ComputeRemovedDependencyWarnings, DecideFieldMapReconcile, DisableUnselectedEntityMaps, ReenableFieldMapsForEntityMap, ResetPullWatermarks, SetEntityMapEnabled } from "../integration/EntityMapLifecycle.js";
 import { ComputeInactiveRowWarnings } from "../integration/InactiveRowWarnings.js";
 import { BuildCreateConnectionMessage, BuildDetachedRefreshMessage, BuildReactivateMessage, BuildUpdateConnectionMessage } from "../integration/SchemaRefreshLaunch.js";
 // Type-only: the registered runtime class for 'MJ: Company Integrations'. Lets the create path name the
@@ -6418,7 +6418,7 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         // The CHOICES live in a pure function (decideFieldMapReconcile — unit-tested); this method
         // applies the EFFECTS. Inline, the decision was untestable: this resolver imports
         // schema-builder and schema-engine, so it cannot be loaded in a unit test at all.
-        const plan = decideFieldMapReconcile(
+        const plan = DecideFieldMapReconcile(
             activeFields.map(f => f.Name),
             existingRows.map(fm => ({ SourceFieldName: fm.SourceFieldName, Status: fm.Status })),
             mapEnabled,

package/src/resolvers/ListOperationsResolver.ts

@@ -239,7 +239,7 @@ export class ComposeListsInput {
 // AppContext / type-graphql runtime.
 // ---------------------------------------------------------------------------
 
-export function toCoreSource(input: ListSourceInput): CoreListSource {
+export function ToCoreSource(input: ListSourceInput): CoreListSource {
   switch (input.Kind) {
     case 'list':
       if (!input.ListID) throw new Error("ListSourceInput.ListID is required when Kind='list'");
@@ -257,7 +257,12 @@ export function toCoreSource(input: ListSourceInput): CoreListSource {
   }
 }
 
-export function fromCoreDelta(delta: CoreListDelta): ListDeltaType {
+/** @deprecated Use {@link ToCoreSource}. */
+export function toCoreSource(input: ListSourceInput): CoreListSource {
+  return ToCoreSource(input);
+}
+
+export function FromCoreDelta(delta: CoreListDelta): ListDeltaType {
   return {
     TargetListId: delta.TargetListId,
     EntityName: delta.EntityName,
@@ -265,12 +270,17 @@ export function fromCoreDelta(delta: CoreListDelta): ListDeltaType {
     ToRemove: delta.ToRemove,
     Unchanged: delta.Unchanged,
     Counts: { ...delta.Counts },
-    Warnings: delta.Warnings.map(fromCoreWarning),
+    Warnings: delta.Warnings.map(FromCoreWarning),
     DeltaToken: delta.DeltaToken,
   };
 }
 
-export function fromCoreWarning(w: CoreListDeltaWarning): ListDeltaWarningType {
+/** @deprecated Use {@link FromCoreDelta}. */
+export function fromCoreDelta(delta: CoreListDelta): ListDeltaType {
+  return FromCoreDelta(delta);
+}
+
+export function FromCoreWarning(w: CoreListDeltaWarning): ListDeltaWarningType {
   return {
     Code: w.Code,
     Message: w.Message,
@@ -278,7 +288,12 @@ export function fromCoreWarning(w: CoreListDeltaWarning): ListDeltaWarningType {
   };
 }
 
-export function fromCoreApplyResult(r: CoreApplyResult): ApplyListResultType {
+/** @deprecated Use {@link FromCoreWarning}. */
+export function fromCoreWarning(w: CoreListDeltaWarning): ListDeltaWarningType {
+  return FromCoreWarning(w);
+}
+
+export function FromCoreApplyResult(r: CoreApplyResult): ApplyListResultType {
   return {
     Success: r.Success,
     ResultCode: r.ResultCode,
@@ -292,8 +307,13 @@ export function fromCoreApplyResult(r: CoreApplyResult): ApplyListResultType {
   };
 }
 
+/** @deprecated Use {@link FromCoreApplyResult}. */
+export function fromCoreApplyResult(r: CoreApplyResult): ApplyListResultType {
+  return FromCoreApplyResult(r);
+}
+
 /** Convert a `ListShareSummary` from the core into the GraphQL DTO. */
-export function fromCoreShareSummary(s: ListShareSummary): ListShareSummaryType {
+export function FromCoreShareSummary(s: ListShareSummary): ListShareSummaryType {
   return {
     PermissionID: s.PermissionID,
     ListID: s.ListID,
@@ -308,28 +328,53 @@ export function fromCoreShareSummary(s: ListShareSummary): ListShareSummaryType
   };
 }
 
+/** @deprecated Use {@link FromCoreShareSummary}. */
+export function fromCoreShareSummary(s: ListShareSummary): ListShareSummaryType {
+  return FromCoreShareSummary(s);
+}
+
 /** Guard for required-when-Kind-X fields on discriminated inputs. */
-export function requireField<T>(value: T | undefined, name: string): T {
+export function RequireField<T>(value: T | undefined, name: string): T {
   if (value == null) throw new Error(`'${name}' is required`);
   return value;
 }
 
+/** @deprecated Use {@link RequireField}. */
+export function requireField<T>(value: T | undefined, name: string): T {
+  return RequireField(value, name);
+}
+
 /** Three failure helpers — one per output type — keep the try/catch
  *  sites in the resolver methods tiny. */
+export function ShareUnexpected(e: unknown, op: string): ShareResultType {
+  const message = e instanceof Error ? e.message : String(e);
+  return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
+}
+
+/** @deprecated Use {@link ShareUnexpected}. */
 export function shareUnexpected(e: unknown, op: string): ShareResultType {
+  return ShareUnexpected(e, op);
+}
+export function InviteUnexpected(e: unknown, op: string): InviteResultType {
   const message = e instanceof Error ? e.message : String(e);
   return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
 }
+
+/** @deprecated Use {@link InviteUnexpected}. */
 export function inviteUnexpected(e: unknown, op: string): InviteResultType {
+  return InviteUnexpected(e, op);
+}
+export function AcceptInvitationUnexpected(e: unknown, op: string): AcceptInvitationResultType {
   const message = e instanceof Error ? e.message : String(e);
   return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
 }
+
+/** @deprecated Use {@link AcceptInvitationUnexpected}. */
 export function acceptInvitationUnexpected(e: unknown, op: string): AcceptInvitationResultType {
-  const message = e instanceof Error ? e.message : String(e);
-  return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
+  return AcceptInvitationUnexpected(e, op);
 }
 
-export function rebuildDeltaFromInput(input: ApplyDeltaInput): CoreListDelta {
+export function RebuildDeltaFromInput(input: ApplyDeltaInput): CoreListDelta {
   return {
     TargetListId: input.TargetListId,
     EntityName: input.EntityName,
@@ -348,6 +393,11 @@ export function rebuildDeltaFromInput(input: ApplyDeltaInput): CoreListDelta {
   };
 }
 
+/** @deprecated Use {@link RebuildDeltaFromInput}. */
+export function rebuildDeltaFromInput(input: ApplyDeltaInput): CoreListDelta {
+  return RebuildDeltaFromInput(input);
+}
+
 // ---------------------------------------------------------------------------
 // Resolver
 //
@@ -369,10 +419,10 @@ export class ListOperationsResolver extends ResolverBase {
     @Ctx() ctx: AppContext,
   ): Promise<ListDeltaType> {
     const ops = this.buildOps(ctx);
-    const source = toCoreSource(input.Source);
+    const source = ToCoreSource(input.Source);
     const target = input.Target === 'new' ? 'new' : ({ kind: 'list', listId: input.Target } as const);
     const delta = await ops.ComputeDelta(target, source, input.Mode);
-    return fromCoreDelta(delta);
+    return FromCoreDelta(delta);
   }
 
   @Mutation(() => ApplyListResultType, {
@@ -384,12 +434,12 @@ export class ListOperationsResolver extends ResolverBase {
   ): Promise<ApplyListResultType> {
     const ops = this.buildOps(ctx);
     try {
-      const delta = rebuildDeltaFromInput(input);
+      const delta = RebuildDeltaFromInput(input);
       const result = await ops.ApplyDelta(delta, {
         ConfirmDrops: input.ConfirmDrops,
         DeltaToken: input.DeltaToken,
       });
-      return fromCoreApplyResult(result);
+      return FromCoreApplyResult(result);
     } catch (e) {
       return this.unexpectedFailure(e, 'ApplyListDelta');
     }
@@ -412,7 +462,7 @@ export class ListOperationsResolver extends ResolverBase {
         RefreshMode: options.RefreshMode,
       };
       const result = await ops.MaterializeFromView(viewId, opts);
-      return fromCoreApplyResult(result);
+      return FromCoreApplyResult(result);
     } catch (e) {
       return this.unexpectedFailure(e, 'MaterializeListFromView');
     }
@@ -427,7 +477,7 @@ export class ListOperationsResolver extends ResolverBase {
     const ops = this.buildOps(ctx);
     try {
       const result = await ops.AddViewResultsToList(viewId, listId);
-      return fromCoreApplyResult(result);
+      return FromCoreApplyResult(result);
     } catch (e) {
       return this.unexpectedFailure(e, 'AddViewResultsToList');
     }
@@ -443,7 +493,7 @@ export class ListOperationsResolver extends ResolverBase {
     const ops = this.buildOps(ctx);
     try {
       const result = await ops.RefreshFromSource(listId, mode, { ConfirmDrops: confirmDrops });
-      return fromCoreApplyResult(result);
+      return FromCoreApplyResult(result);
     } catch (e) {
       return this.unexpectedFailure(e, 'RefreshListFromSource');
     }
@@ -458,10 +508,10 @@ export class ListOperationsResolver extends ResolverBase {
     @Ctx() ctx: AppContext,
   ): Promise<ListDeltaType> {
     const ops = this.buildOps(ctx);
-    const inputs = input.Inputs.map(toCoreSource);
-    const target = input.Target ? toCoreSource(input.Target) : undefined;
+    const inputs = input.Inputs.map(ToCoreSource);
+    const target = input.Target ? ToCoreSource(input.Target) : undefined;
     const delta = await ops.ComputeSetOp(input.Op, inputs, target);
-    return fromCoreDelta(delta);
+    return FromCoreDelta(delta);
   }
 
   // -----------------------------------------------------------------------
@@ -480,8 +530,8 @@ export class ListOperationsResolver extends ResolverBase {
     try {
       const target: ShareTarget =
         input.Target.Kind === 'user'
-          ? { kind: 'user', userId: requireField(input.Target.UserID, 'Target.UserID') }
-          : { kind: 'role', roleId: requireField(input.Target.RoleID, 'Target.RoleID') };
+          ? { kind: 'user', userId: RequireField(input.Target.UserID, 'Target.UserID') }
+          : { kind: 'role', roleId: RequireField(input.Target.RoleID, 'Target.RoleID') };
       const result = await sharing.Share({
         ListID: input.ListID,
         Target: target,
@@ -489,7 +539,7 @@ export class ListOperationsResolver extends ResolverBase {
       });
       return result;
     } catch (e) {
-      return shareUnexpected(e, 'ShareList');
+      return ShareUnexpected(e, 'ShareList');
     }
   }
 
@@ -502,7 +552,7 @@ export class ListOperationsResolver extends ResolverBase {
     try {
       return await sharing.Unshare(permissionId);
     } catch (e) {
-      return shareUnexpected(e, 'UnshareList');
+      return ShareUnexpected(e, 'UnshareList');
     }
   }
 
@@ -520,7 +570,7 @@ export class ListOperationsResolver extends ResolverBase {
         TtlMs: input.TtlHours != null ? input.TtlHours * 60 * 60 * 1000 : undefined,
       });
     } catch (e) {
-      return inviteUnexpected(e, 'InviteToList');
+      return InviteUnexpected(e, 'InviteToList');
     }
   }
 
@@ -533,7 +583,7 @@ export class ListOperationsResolver extends ResolverBase {
     try {
       return await sharing.AcceptInvitation(token);
     } catch (e) {
-      return acceptInvitationUnexpected(e, 'AcceptListInvitation');
+      return AcceptInvitationUnexpected(e, 'AcceptListInvitation');
     }
   }
 
@@ -546,7 +596,7 @@ export class ListOperationsResolver extends ResolverBase {
     try {
       return await sharing.RevokeInvitation(invitationId);
     } catch (e) {
-      return shareUnexpected(e, 'RevokeListInvitation');
+      return ShareUnexpected(e, 'RevokeListInvitation');
     }
   }
 
@@ -557,7 +607,7 @@ export class ListOperationsResolver extends ResolverBase {
   ): Promise<ListShareSummaryType[]> {
     const sharing = this.buildSharing(ctx);
     const shares = await sharing.GetSharesForList(listId);
-    return shares.map(fromCoreShareSummary);
+    return shares.map(FromCoreShareSummary);
   }
 
   @Query(() => [SharedListSummaryType])

package/src/resolvers/MCPResolver.ts

@@ -19,7 +19,7 @@ import {
 } from '@memberjunction/ai-mcp-client';
 import { AppContext } from '../types.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { publishStatusUpdate } from '../generic/PushStatusResolver.js';
+import { PublishStatusUpdate } from '../generic/PushStatusResolver.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { configInfo } from '../config.js';
 
@@ -493,13 +493,13 @@ export class MCPToolSummary {
 @ObjectType()
 export class MCPToolPageResult {
     @Field(() => [MCPToolSummary])
-    items: MCPToolSummary[];
+    items: MCPToolSummary[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    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
 
     @Field()
-    hasMore: boolean;
+    hasMore: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -508,13 +508,13 @@ export class MCPToolPageResult {
 @ObjectType()
 export class MCPToolServerCount {
     @Field()
-    serverID: string;
+    serverID: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    serverName: string;
+    serverName: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    count: number;
+    count: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -524,10 +524,10 @@ export class MCPToolServerCount {
 @ObjectType()
 export class MCPToolCategoryCount {
     @Field()
-    category: string;
+    category: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    count: number;
+    count: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -536,13 +536,13 @@ export class MCPToolCategoryCount {
 @ObjectType()
 export class MCPToolCountsResult {
     @Field(() => Int)
-    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
 
     @Field(() => [MCPToolServerCount])
-    countByServer: MCPToolServerCount[];
+    countByServer: MCPToolServerCount[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [MCPToolCategoryCount])
-    countByCategory: MCPToolCategoryCount[];
+    countByCategory: MCPToolCategoryCount[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -1247,7 +1247,7 @@ export class MCPResolver extends ResolverBase {
      * @returns OAuth event notification
      */
     @Subscription(() => MCPOAuthEventNotification, { topics: MCP_OAUTH_EVENTS_TOPIC })
-    onMCPOAuthEvent(
+    onMCPOAuthEvent(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
         @Root() payload: MCPOAuthEventPayload
     ): MCPOAuthEventNotification {
         return {
@@ -1361,7 +1361,7 @@ export class MCPResolver extends ResolverBase {
             result
         };
 
-        publishStatusUpdate(pubSub, { sessionId, ownerUserId, message: JSON.stringify(progressMessage) });
+        PublishStatusUpdate(pubSub, { sessionId, ownerUserId, message: JSON.stringify(progressMessage) });
     }
 
     /**
@@ -1653,7 +1653,7 @@ export class MCPResolver extends ResolverBase {
  * @param pubSub - PubSub engine
  * @param event - OAuth event details
  */
-export async function publishMCPOAuthEvent(
+export async function PublishMCPOAuthEvent(
     pubSub: PubSubEngine,
     event: {
         eventType: MCPOAuthEventType;
@@ -1676,3 +1676,18 @@ export async function publishMCPOAuthEvent(
 
     await pubSub.publish(MCP_OAUTH_EVENTS_TOPIC, payload);
 }
+
+/** @deprecated Use {@link PublishMCPOAuthEvent}. */
+export async function publishMCPOAuthEvent(
+    pubSub: PubSubEngine,
+    event: {
+        eventType: MCPOAuthEventType;
+        connectionId: string;
+        authorizationUrl?: string;
+        stateParameter?: string;
+        errorMessage?: string;
+        requiresReauthorization?: boolean;
+    }
+): Promise<void> {
+    return PublishMCPOAuthEvent(pubSub, event);
+}

package/src/resolvers/MergeRecordsResolver.ts

@@ -50,7 +50,17 @@ export class RecordDependencyResult {
   FieldName: string; // required
 
   @Field(() => CompositeKeyOutputType)
+  PrimaryKey: CompositeKey;
+
+  /** The same key under its pre-6.2 name, so older clients keep working. */
+  @Field(() => CompositeKeyOutputType, { deprecationReason: 'Use PrimaryKey. CompositeKey will be removed in a future release.' })
   CompositeKey: CompositeKey;
+
+  @Field(() => Boolean, { nullable: true })
+  IsSoftLink?: boolean;
+
+  @Field(() => String, { nullable: true })
+  EntityIDFieldName?: string;
 }
 
 @Resolver(RecordDependencyResult)
@@ -67,12 +77,14 @@ export class RecordDependencyResolver {
       const ck = new CompositeKey(ckInput.KeyValuePairs);
       const result = await md.GetRecordDependencies(entityName, ck);
       
-      // Map PrimaryKey to CompositeKey for GraphQL response
       return result.map(dep => ({
         EntityName: dep.EntityName,
         RelatedEntityName: dep.RelatedEntityName,
         FieldName: dep.FieldName,
-        CompositeKey: dep.PrimaryKey // Map PrimaryKey to CompositeKey
+        PrimaryKey: dep.PrimaryKey,
+        CompositeKey: dep.PrimaryKey,
+        IsSoftLink: dep.IsSoftLink,
+        EntityIDFieldName: dep.EntityIDFieldName,
       }));
     } catch (e) {
       LogError(e);

package/src/resolvers/QueryResolver.ts

@@ -97,34 +97,34 @@ export class RunQueryResultType {
 @InputType()
 export class RunQueryCacheStatusInput {
   @Field(() => String, { description: 'The maximum __mj_UpdatedAt value from cached results' })
-  maxUpdatedAt: string;
+  maxUpdatedAt: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { description: 'The number of rows in cached results' })
-  rowCount: number;
+  rowCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
 export class RunQueryWithCacheCheckInput {
   @Field(() => RunQueryInput, { description: 'The RunQuery parameters' })
-  params: RunQueryInput;
+  params: RunQueryInput;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => RunQueryCacheStatusInput, {
     nullable: true,
     description: 'Optional cache status - if provided, server will check if cache is current'
   })
-  cacheStatus?: RunQueryCacheStatusInput;
+  cacheStatus?: RunQueryCacheStatusInput;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class RunQueryWithCacheCheckResultOutput {
   @Field(() => Int, { description: 'The index of this query in the batch request' })
-  queryIndex: number;
+  queryIndex: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { description: 'The query ID' })
-  queryId: string;
+  queryId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { description: "'current', 'stale', 'no_validation', or 'error'" })
-  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,
@@ -133,25 +133,25 @@ export class RunQueryWithCacheCheckResultOutput {
   Results?: string;
 
   @Field(() => String, { nullable: true, description: 'Max __mj_UpdatedAt from results when stale' })
-  maxUpdatedAt?: string;
+  maxUpdatedAt?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { nullable: true, description: 'Row count of results when stale' })
-  rowCount?: number;
+  rowCount?: number;  // 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, description: 'Error message if status is error' })
-  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
 }
 
 @ObjectType()
 export class RunQueriesWithCacheCheckOutput {
   @Field(() => Boolean, { description: 'Whether the overall operation succeeded' })
-  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(() => [RunQueryWithCacheCheckResultOutput], { description: 'Results for each query in the batch' })
-  results: RunQueryWithCacheCheckResultOutput[];
+  results: RunQueryWithCacheCheckResultOutput[];  // 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, description: 'Overall error message if success is false' })
-  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
 }
 
 @Resolver()