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

package/src/resolvers/TelemetryResolver.ts

@@ -13,58 +13,58 @@ import {
 @ObjectType()
 export class MemorySnapshotGQL {
     @Field(() => Float)
-    heapUsed: number;
+    heapUsed: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    heapTotal: number;
+    heapTotal: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    timestamp: number;
+    timestamp: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TelemetryEventGQL {
     @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
 
     @Field(() => String)
-    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(() => String)
-    operation: string;
+    operation: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    fingerprint: string;
+    fingerprint: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    startTime: number;
+    startTime: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float, { nullable: true })
-    endTime?: number;
+    endTime?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float, { nullable: true })
-    elapsedMs?: number;
+    elapsedMs?: 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 })
-    userId?: string;
+    userId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    params: string; // JSON stringified
+    params: string; // JSON stringified — 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 })
-    tags?: string[];
+    tags?: 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 })
-    stackTrace?: string;
+    stackTrace?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => MemorySnapshotGQL, { nullable: true })
-    memoryBefore?: MemorySnapshotGQL;
+    memoryBefore?: MemorySnapshotGQL;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => MemorySnapshotGQL, { nullable: true })
-    memoryAfter?: MemorySnapshotGQL;
+    memoryAfter?: MemorySnapshotGQL;  // 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 })
-    parentEventId?: string;
+    parentEventId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================
@@ -74,52 +74,52 @@ export class TelemetryEventGQL {
 @ObjectType()
 export class CallerLocationGQL {
     @Field(() => String)
-    location: string;
+    location: 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
 }
 
 @ObjectType()
 export class TelemetryPatternGQL {
     @Field(() => String)
-    fingerprint: string;
+    fingerprint: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    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(() => String)
-    operation: string;
+    operation: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    sampleParams: string; // JSON stringified
+    sampleParams: string; // JSON stringified — 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
 
     @Field(() => Float)
-    totalElapsedMs: number;
+    totalElapsedMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    avgElapsedMs: number;
+    avgElapsedMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    minElapsedMs: number;
+    minElapsedMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    maxElapsedMs: number;
+    maxElapsedMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [CallerLocationGQL])
-    callerLocations: CallerLocationGQL[];
+    callerLocations: CallerLocationGQL[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    firstSeen: number;
+    firstSeen: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    lastSeen: number;
+    lastSeen: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    windowStartTime: number;
+    windowStartTime: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================
@@ -129,37 +129,37 @@ export class TelemetryPatternGQL {
 @ObjectType()
 export class TelemetryInsightGQL {
     @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
 
     @Field(() => String)
-    severity: string;
+    severity: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    analyzerName: string;
+    analyzerName: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    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(() => String)
-    title: string;
+    title: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String)
-    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(() => String)
-    suggestion: string;
+    suggestion: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [String])
-    relatedEventIds: string[];
+    relatedEventIds: 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 })
-    entityName?: string;
+    entityName?: 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 })
-    metadata?: string; // JSON stringified
+    metadata?: string; // JSON stringified — case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    timestamp: number;
+    timestamp: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================
@@ -169,31 +169,31 @@ export class TelemetryInsightGQL {
 @ObjectType()
 export class CategoryStatsGQL {
     @Field(() => String)
-    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)
-    events: number;
+    events: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float)
-    avgMs: number;
+    avgMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TelemetryStatsGQL {
     @Field(() => Int)
-    totalEvents: number;
+    totalEvents: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    totalPatterns: number;
+    totalPatterns: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    totalInsights: number;
+    totalInsights: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    activeEvents: number;
+    activeEvents: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [CategoryStatsGQL])
-    byCategory: CategoryStatsGQL[];
+    byCategory: CategoryStatsGQL[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================
@@ -203,64 +203,64 @@ export class TelemetryStatsGQL {
 @ObjectType()
 export class CategoryOverrideGQL {
     @Field(() => String)
-    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(() => 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
 
     @Field(() => String, { nullable: true })
-    level?: string;
+    level?: 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 AutoTrimSettingsGQL {
     @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
 
     @Field(() => Int, { nullable: true })
-    maxEvents?: number;
+    maxEvents?: number;  // 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 })
-    maxAgeMs?: number;
+    maxAgeMs?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class DuplicateDetectionSettingsGQL {
     @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
 
     @Field(() => Int)
-    windowMs: number;
+    windowMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AnalyzerSettingsGQL {
     @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
 
     @Field(() => Int)
-    dedupeWindowMs: number;
+    dedupeWindowMs: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class TelemetrySettingsGQL {
     @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
 
     @Field(() => String)
-    level: string;
+    level: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [CategoryOverrideGQL])
-    categoryOverrides: CategoryOverrideGQL[];
+    categoryOverrides: CategoryOverrideGQL[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => AutoTrimSettingsGQL)
-    autoTrim: AutoTrimSettingsGQL;
+    autoTrim: AutoTrimSettingsGQL;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => DuplicateDetectionSettingsGQL)
-    duplicateDetection: DuplicateDetectionSettingsGQL;
+    duplicateDetection: DuplicateDetectionSettingsGQL;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => AnalyzerSettingsGQL)
-    analyzers: AnalyzerSettingsGQL;
+    analyzers: AnalyzerSettingsGQL;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================
@@ -270,46 +270,46 @@ export class TelemetrySettingsGQL {
 @InputType()
 export class TelemetryEventFilterInput {
     @Field(() => String, { nullable: true })
-    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(() => String, { nullable: true })
-    operation?: string;
+    operation?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float, { nullable: true })
-    minElapsedMs?: number;
+    minElapsedMs?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Float, { nullable: true })
-    since?: number;
+    since?: number;  // 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 })
-    limit?: number;
+    limit?: 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 TelemetryPatternFilterInput {
     @Field(() => String, { nullable: true })
-    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, { nullable: true })
-    minCount?: number;
+    minCount?: 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 })
-    sortBy?: string;
+    sortBy?: 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 TelemetryInsightFilterInput {
     @Field(() => String, { nullable: true })
-    severity?: string;
+    severity?: 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 })
-    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(() => String, { nullable: true })
-    entityName?: string;
+    entityName?: 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 })
-    limit?: number;
+    limit?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 // ============================================================================

package/src/resolvers/VectorizeEntityResolver.ts

@@ -1,26 +1,27 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, Float } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
+import { IMetadataProvider, LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { EntityVectorSyncer, VectorizeEntityParams, VectorizeProgressUpdate } from '@memberjunction/ai-vector-sync';
 import { PubSubManager } from '../generic/PubSubManager.js';
 import { PipelineProgressNotification } from './PipelineProgressResolver.js';
 import { v4 as uuidv4 } from 'uuid';
+import { GetReadWriteProvider } from '../util.js';
 
 const PIPELINE_PROGRESS_TOPIC = 'PIPELINE_PROGRESS';
 
 @ObjectType()
 export class VectorizeEntityResult {
-    @Field()
+    @Field(() => Boolean)
     Success: boolean;
 
-    @Field({ nullable: true })
+    @Field(() => String, { nullable: true })
     Status?: string;
 
-    @Field({ nullable: true })
+    @Field(() => String, { nullable: true })
     ErrorMessage?: string;
 
-    @Field({ nullable: true })
+    @Field(() => String, { nullable: true })
     PipelineRunID?: string;
 }
 
@@ -28,10 +29,10 @@ export class VectorizeEntityResult {
 export class VectorizeEntityResolver extends ResolverBase {
     @Mutation(() => VectorizeEntityResult)
     async VectorizeEntity(
-        @Arg('entityDocumentID') entityDocumentID: string,
-        @Arg('entityID') entityID: string,
+        @Arg('entityDocumentID', () => String) entityDocumentID: string,
+        @Arg('entityID', () => String) entityID: string,
         @Arg('batchSize', () => Float, { nullable: true }) batchSize?: number,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
+        @Ctx() { userPayload, providers }: AppContext = {} as AppContext
     ): Promise<VectorizeEntityResult> {
         try {
             const currentUser = this.GetUserFromPayload(userPayload);
@@ -39,12 +40,15 @@ export class VectorizeEntityResolver extends ResolverBase {
                 return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
             }
 
+            // Capture the request's provider before returning, so the background run writes through the
+            // same connection the caller used. It is also the colocated vector host (#4910).
+            const provider = GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) ?? undefined;
             const pipelineRunID = uuidv4();
             LogStatus(`VectorizeEntity: starting pipeline ${pipelineRunID} for entity document ${entityDocumentID}`);
 
             // Fire-and-forget: start the pipeline in the background and return immediately.
             // Progress is delivered to the client via the PipelineProgress GraphQL subscription.
-            this.runPipelineInBackground(pipelineRunID, entityDocumentID, entityID, batchSize, currentUser);
+            this.runPipelineInBackground(pipelineRunID, entityDocumentID, entityID, batchSize, currentUser, provider);
 
             return {
                 Success: true,
@@ -71,10 +75,11 @@ export class VectorizeEntityResolver extends ResolverBase {
         entityDocumentID: string,
         entityID: string,
         batchSize: number | undefined,
-        currentUser: UserInfo
+        currentUser: UserInfo,
+        provider?: IMetadataProvider
     ): Promise<void> {
         try {
-            const syncer = new EntityVectorSyncer();
+            const syncer = new EntityVectorSyncer(provider);
             await syncer.Config(true, currentUser);
 
             const params: VectorizeEntityParams = {

package/src/resolvers/__tests__/GetDataResolver.tokens.test.ts

@@ -12,22 +12,24 @@ import { describe, it, expect, vi } from 'vitest';
 // vars to even import. Mock those heavy imports out so this file stays a true,
 // isolated unit test of the token-tracking logic (mirrors the mocking convention
 // in RealtimeBridgeResolver.test.ts).
-vi.mock('../../index.js', () => ({ getDbType: vi.fn() }));
+vi.mock('../../index.js', () => ({ GetDbType: vi.fn(),
+    get getDbType() { return this.GetDbType; } }));
 vi.mock('@memberjunction/generic-database-provider', () => ({
   QueryCompositionEngine: vi.fn(() => ({ HasCompositionTokens: vi.fn(() => false) })),
 }));
 vi.mock('../../util.js', () => ({ GetReadOnlyDataSource: vi.fn(), GetReadOnlyProvider: vi.fn() }));
-vi.mock('../../auth/index.js', () => ({ getSystemUser: vi.fn() }));
+vi.mock('../../auth/index.js', () => ({ GetSystemUser: vi.fn(),
+    get getSystemUser() { return this.GetSystemUser; } }));
 vi.mock('mssql', () => ({ default: { Request: vi.fn() } }));
 
 import {
-  registerAccessToken,
-  deleteAccessToken,
-  tokenExists,
-  isTokenValid,
-  recordTokenUse,
-  pruneExpiredTokens,
-  getAccessTokenCount,
+  RegisterAccessToken,
+  DeleteAccessToken,
+  TokenExists,
+  IsTokenValid,
+  RecordTokenUse,
+  PruneExpiredTokens,
+  GetAccessTokenCount,
 } from '../GetDataResolver.js';
 
 // ---------------------------------------------------------------------------
@@ -51,88 +53,88 @@ const uniqueToken = () => `test-token-${Date.now()}-${++seq}`;
 describe('GetDataResolver access-token lifecycle', () => {
   it('registerAccessToken() creates a token that is valid and exists', () => {
     const token = uniqueToken();
-    const created = registerAccessToken(token, 60_000);
+    const created = RegisterAccessToken(token, 60_000);
     expect(created.Token).toBe(token);
-    expect(tokenExists(token)).toBe(true);
-    expect(isTokenValid(token)).toBe(true);
+    expect(TokenExists(token)).toBe(true);
+    expect(IsTokenValid(token)).toBe(true);
   });
 
   it('registerAccessToken() throws when the same custom token is registered twice', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
-    expect(() => registerAccessToken(token, 60_000)).toThrow(/already exists/);
+    RegisterAccessToken(token, 60_000);
+    expect(() => RegisterAccessToken(token, 60_000)).toThrow(/already exists/);
   });
 
   it('isTokenValid() is false for an unknown token and for an expired one', () => {
-    expect(isTokenValid('never-registered-token')).toBe(false);
+    expect(IsTokenValid('never-registered-token')).toBe(false);
 
     const token = uniqueToken();
-    registerAccessToken(token, -1); // already expired (ExpiresAt in the past)
-    expect(isTokenValid(token)).toBe(false);
+    RegisterAccessToken(token, -1); // already expired (ExpiresAt in the past)
+    expect(IsTokenValid(token)).toBe(false);
   });
 
   it('deleteAccessToken() removes a token and throws for an unknown one', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
-    expect(tokenExists(token)).toBe(true);
+    RegisterAccessToken(token, 60_000);
+    expect(TokenExists(token)).toBe(true);
 
-    deleteAccessToken(token);
-    expect(tokenExists(token)).toBe(false);
-    expect(() => deleteAccessToken(token)).toThrow(/does not exist/);
+    DeleteAccessToken(token);
+    expect(TokenExists(token)).toBe(false);
+    expect(() => DeleteAccessToken(token)).toThrow(/does not exist/);
   });
 
   it('recordTokenUse() appends to TokenUses and throws for an unknown token', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
+    RegisterAccessToken(token, 60_000);
 
-    expect(() => recordTokenUse(token, { some: 'payload' })).not.toThrow();
-    expect(() => recordTokenUse('never-registered-token', {})).toThrow(/does not exist/);
+    expect(() => RecordTokenUse(token, { some: 'payload' })).not.toThrow();
+    expect(() => RecordTokenUse('never-registered-token', {})).toThrow(/does not exist/);
   });
 
   it('pruneExpiredTokens() removes only tokens whose ExpiresAt has passed', () => {
     const expiredToken = uniqueToken();
     const liveToken = uniqueToken();
-    registerAccessToken(expiredToken, -1); // already expired
-    registerAccessToken(liveToken, 60_000); // still valid
+    RegisterAccessToken(expiredToken, -1); // already expired
+    RegisterAccessToken(liveToken, 60_000); // still valid
 
-    pruneExpiredTokens();
+    PruneExpiredTokens();
 
-    expect(tokenExists(expiredToken)).toBe(false);
-    expect(tokenExists(liveToken)).toBe(true);
+    expect(TokenExists(expiredToken)).toBe(false);
+    expect(TokenExists(liveToken)).toBe(true);
   });
 
   it('pruneExpiredTokens() accepts an injected "now" for deterministic testing', () => {
     const token = uniqueToken();
     const registeredAt = new Date('2026-01-01T00:00:00Z');
-    registerAccessToken(token, 5 * 60 * 1000); // 5-minute lifespan from real "now"
+    RegisterAccessToken(token, 5 * 60 * 1000); // 5-minute lifespan from real "now"
 
     // Simulate a check far in the future — token should count as expired at that instant.
     const farFuture = new Date(registeredAt.getTime() + 365 * 24 * 60 * 60 * 1000);
-    pruneExpiredTokens(farFuture);
+    PruneExpiredTokens(farFuture);
 
-    expect(tokenExists(token)).toBe(false);
+    expect(TokenExists(token)).toBe(false);
   });
 
   it('the core Round 7 regression: registering many expired tokens does not grow the array without bound', () => {
-    const before = getAccessTokenCount();
+    const before = GetAccessTokenCount();
 
     // Simulate 50 short-lived tokens that all expire immediately (e.g. a burst
     // of external calls with a near-zero lifespan, or tokens whose consumer
     // never came back before expiry — the exact shape of the leak this fix
     // addresses).
     for (let i = 0; i < 50; i++) {
-      registerAccessToken(`${uniqueToken()}-burst-${i}`, -1);
+      RegisterAccessToken(`${uniqueToken()}-burst-${i}`, -1);
     }
 
     // Register one more, healthy token — its registerAccessToken() call sweeps
     // all 50 expired ones out, so the count should NOT have grown by 51; it
     // should only reflect whatever was live before plus this one new token.
     const survivorToken = uniqueToken();
-    registerAccessToken(survivorToken, 60_000);
+    RegisterAccessToken(survivorToken, 60_000);
 
     // The 50 expired burst tokens must be gone — the array self-bounded rather
     // than accumulating every registration for the life of the process.
-    expect(getAccessTokenCount()).toBeLessThan(before + 51);
-    expect(tokenExists(survivorToken)).toBe(true);
+    expect(GetAccessTokenCount()).toBeLessThan(before + 51);
+    expect(TokenExists(survivorToken)).toBe(true);
   });
 });