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

package/src/__tests__/ListOperationsResolver.test.ts

@@ -22,24 +22,24 @@ import type { ApplyResult, ListDelta } from '@memberjunction/lists-base';
 import {
   ApplyDeltaInput,
   ListSourceInput,
-  fromCoreApplyResult,
-  fromCoreDelta,
-  fromCoreWarning,
-  rebuildDeltaFromInput,
-  toCoreSource,
+  FromCoreApplyResult,
+  FromCoreDelta,
+  FromCoreWarning,
+  RebuildDeltaFromInput,
+  ToCoreSource,
 } from '../resolvers/ListOperationsResolver.js';
 
 describe('ListOperationsResolver — boundary converters', () => {
   describe('toCoreSource', () => {
     it('maps a list-kind input to a core ListSource', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'list', ListID: 'list-1' });
-      const result = toCoreSource(input);
+      const result = ToCoreSource(input);
       expect(result).toEqual({ kind: 'list', listId: 'list-1' });
     });
 
     it('maps a view-kind input to a core ListSource', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'view', ViewID: 'view-1' });
-      expect(toCoreSource(input)).toEqual({ kind: 'view', viewId: 'view-1' });
+      expect(ToCoreSource(input)).toEqual({ kind: 'view', viewId: 'view-1' });
     });
 
     it('maps an adhoc-kind input to a core ListSource', () => {
@@ -48,7 +48,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         EntityName: 'Contacts',
         ExtraFilter: "Status='Active'",
       });
-      expect(toCoreSource(input)).toEqual({
+      expect(ToCoreSource(input)).toEqual({
         kind: 'adhoc',
         entityName: 'Contacts',
         extraFilter: "Status='Active'",
@@ -57,22 +57,22 @@ describe('ListOperationsResolver — boundary converters', () => {
 
     it('throws when list-kind input has no ListID', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'list' });
-      expect(() => toCoreSource(input)).toThrow(/ListID is required/);
+      expect(() => ToCoreSource(input)).toThrow(/ListID is required/);
     });
 
     it('throws when view-kind input has no ViewID', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'view' });
-      expect(() => toCoreSource(input)).toThrow(/ViewID is required/);
+      expect(() => ToCoreSource(input)).toThrow(/ViewID is required/);
     });
 
     it('throws when adhoc-kind input lacks EntityName or ExtraFilter', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'adhoc', EntityName: 'X' });
-      expect(() => toCoreSource(input)).toThrow(/EntityName and ExtraFilter/);
+      expect(() => ToCoreSource(input)).toThrow(/EntityName and ExtraFilter/);
     });
 
     it('throws on an unknown discriminator', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'mystery' as never });
-      expect(() => toCoreSource(input)).toThrow(/Unknown ListSourceInput\.Kind/);
+      expect(() => ToCoreSource(input)).toThrow(/Unknown ListSourceInput\.Kind/);
     });
   });
 
@@ -90,7 +90,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         ],
         DeltaToken: 'abc.def',
       };
-      const output = fromCoreDelta(delta);
+      const output = FromCoreDelta(delta);
       expect(output).toMatchObject({
         TargetListId: 'list-1',
         EntityName: 'Contacts',
@@ -111,7 +111,7 @@ describe('ListOperationsResolver — boundary converters', () => {
 
   describe('fromCoreWarning', () => {
     it('leaves DetailsJSON undefined when no details supplied', () => {
-      const output = fromCoreWarning({ Code: 'EMPTY_SOURCE', Message: 'No records' });
+      const output = FromCoreWarning({ Code: 'EMPTY_SOURCE', Message: 'No records' });
       expect(output.DetailsJSON).toBeUndefined();
     });
   });
@@ -126,7 +126,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         CreatedListId: 'list-1',
         Counts: { Added: 5, Removed: 2, Failed: 0 },
       };
-      const output = fromCoreApplyResult(result);
+      const output = FromCoreApplyResult(result);
       expect(output).toMatchObject({
         Success: true,
         ResultCode: 'SUCCESS',
@@ -145,7 +145,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         Message: 'partial',
         Errors: ['failed record a'],
       };
-      expect(fromCoreApplyResult(result).Errors).toEqual(['failed record a']);
+      expect(FromCoreApplyResult(result).Errors).toEqual(['failed record a']);
     });
   });
 
@@ -165,7 +165,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         DeltaToken: 'tok',
         ConfirmDrops: true,
       });
-      const out = rebuildDeltaFromInput(input);
+      const out = RebuildDeltaFromInput(input);
       expect(out).toMatchObject({
         TargetListId: 'list-1',
         EntityName: 'Contacts',

package/src/__tests__/MediaStreamHandler.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseRangeHeaderLoose, parseRange } from '../rest/mediaRange.js';
+import { ParseRangeHeaderLoose, ParseRange } from '../rest/mediaRange.js';
 
 /**
  * Tests for the pure HTTP-Range parsing helpers behind the authenticated `/media/:fileId`
@@ -16,34 +16,34 @@ import { parseRangeHeaderLoose, parseRange } from '../rest/mediaRange.js';
 
 describe('parseRangeHeaderLoose (streaming path — no known total)', () => {
     it('parses a closed range bytes=start-end into inclusive offsets', () => {
-        expect(parseRangeHeaderLoose('bytes=0-499')).toEqual({ start: 0, end: 499 });
-        expect(parseRangeHeaderLoose('bytes=200-1023')).toEqual({ start: 200, end: 1023 });
+        expect(ParseRangeHeaderLoose('bytes=0-499')).toEqual({ start: 0, end: 499 });
+        expect(ParseRangeHeaderLoose('bytes=200-1023')).toEqual({ start: 200, end: 1023 });
     });
 
     it('leaves end undefined for an open-ended range bytes=start- (stream to EOF)', () => {
-        expect(parseRangeHeaderLoose('bytes=500-')).toEqual({ start: 500 });
-        expect(parseRangeHeaderLoose('bytes=0-')).toEqual({ start: 0 });
+        expect(ParseRangeHeaderLoose('bytes=500-')).toEqual({ start: 500 });
+        expect(ParseRangeHeaderLoose('bytes=0-')).toEqual({ start: 0 });
     });
 
     it('tolerates surrounding whitespace', () => {
-        expect(parseRangeHeaderLoose('  bytes=10-20  ')).toEqual({ start: 10, end: 20 });
+        expect(ParseRangeHeaderLoose('  bytes=10-20  ')).toEqual({ start: 10, end: 20 });
     });
 
     it('returns undefined when end < start (nonsensical range)', () => {
-        expect(parseRangeHeaderLoose('bytes=500-100')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=500-100')).toBeUndefined();
     });
 
     it('returns undefined for malformed / multi-range / suffix-only headers', () => {
-        expect(parseRangeHeaderLoose('bytes=abc-def')).toBeUndefined();
-        expect(parseRangeHeaderLoose('bytes=-500')).toBeUndefined(); // suffix range — left to a full read
-        expect(parseRangeHeaderLoose('bytes=0-100,200-300')).toBeUndefined(); // multi-range
-        expect(parseRangeHeaderLoose('items=0-100')).toBeUndefined(); // wrong unit
-        expect(parseRangeHeaderLoose('bytes=')).toBeUndefined();
-        expect(parseRangeHeaderLoose('')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=abc-def')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=-500')).toBeUndefined(); // suffix range — left to a full read
+        expect(ParseRangeHeaderLoose('bytes=0-100,200-300')).toBeUndefined(); // multi-range
+        expect(ParseRangeHeaderLoose('items=0-100')).toBeUndefined(); // wrong unit
+        expect(ParseRangeHeaderLoose('bytes=')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('')).toBeUndefined();
     });
 
     it('accepts a zero-length point range bytes=N-N', () => {
-        expect(parseRangeHeaderLoose('bytes=42-42')).toEqual({ start: 42, end: 42 });
+        expect(ParseRangeHeaderLoose('bytes=42-42')).toEqual({ start: 42, end: 42 });
     });
 });
 
@@ -51,41 +51,41 @@ describe('parseRange (buffer path — known total)', () => {
     const TOTAL = 1000;
 
     it('parses a closed range within bounds', () => {
-        expect(parseRange('bytes=0-499', TOTAL)).toEqual({ start: 0, end: 499 });
+        expect(ParseRange('bytes=0-499', TOTAL)).toEqual({ start: 0, end: 499 });
     });
 
     it('clamps end to the last byte when the requested end exceeds total', () => {
         // bytes=500-99999 against a 1000-byte file → end clamps to 999.
-        expect(parseRange('bytes=500-99999', TOTAL)).toEqual({ start: 500, end: 999 });
+        expect(ParseRange('bytes=500-99999', TOTAL)).toEqual({ start: 500, end: 999 });
     });
 
     it('resolves an open-ended range to the last byte', () => {
-        expect(parseRange('bytes=200-', TOTAL)).toEqual({ start: 200, end: 999 });
+        expect(ParseRange('bytes=200-', TOTAL)).toEqual({ start: 200, end: 999 });
     });
 
     it('returns undefined when start is at or past EOF (unsatisfiable → 416)', () => {
-        expect(parseRange('bytes=1000-1100', TOTAL)).toBeUndefined(); // start === total
-        expect(parseRange('bytes=2000-', TOTAL)).toBeUndefined(); // start > total
+        expect(ParseRange('bytes=1000-1100', TOTAL)).toBeUndefined(); // start === total
+        expect(ParseRange('bytes=2000-', TOTAL)).toBeUndefined(); // start > total
     });
 
     it('returns undefined when end < start after parsing', () => {
-        expect(parseRange('bytes=600-100', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=600-100', TOTAL)).toBeUndefined();
     });
 
     it('returns undefined for malformed / multi-range / suffix-only headers', () => {
-        expect(parseRange('bytes=abc-', TOTAL)).toBeUndefined();
-        expect(parseRange('bytes=-200', TOTAL)).toBeUndefined();
-        expect(parseRange('bytes=0-100,200-300', TOTAL)).toBeUndefined();
-        expect(parseRange('items=0-100', TOTAL)).toBeUndefined();
-        expect(parseRange('', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=abc-', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=-200', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=0-100,200-300', TOTAL)).toBeUndefined();
+        expect(ParseRange('items=0-100', TOTAL)).toBeUndefined();
+        expect(ParseRange('', TOTAL)).toBeUndefined();
     });
 
     it('handles the very first byte and the very last byte exactly', () => {
-        expect(parseRange('bytes=0-0', TOTAL)).toEqual({ start: 0, end: 0 });
-        expect(parseRange('bytes=999-999', TOTAL)).toEqual({ start: 999, end: 999 });
+        expect(ParseRange('bytes=0-0', TOTAL)).toEqual({ start: 0, end: 0 });
+        expect(ParseRange('bytes=999-999', TOTAL)).toEqual({ start: 999, end: 999 });
     });
 
     it('tolerates surrounding whitespace', () => {
-        expect(parseRange('  bytes=10-20  ', TOTAL)).toEqual({ start: 10, end: 20 });
+        expect(ParseRange('  bytes=10-20  ', TOTAL)).toEqual({ start: 10, end: 20 });
     });
 });

package/src/__tests__/NoLog.test.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { describe, it, expect } from 'vitest';
-import { NoLog, hasNoLogParameter, getNoLogFields } from '../logging/NoLog.js';
+import { NoLog, HasNoLogParameter, GetNoLogFields } from '../logging/NoLog.js';
 
 describe('NoLog decorator', () => {
   it('marks a resolver method parameter (3-arg call) and is readable via hasNoLogParameter', () => {
@@ -11,9 +11,9 @@ describe('NoLog decorator', () => {
     }
     NoLog(MyResolver.prototype, 'doThing', 1);
 
-    expect(hasNoLogParameter(MyResolver, 'doThing', 1)).toBe(true);
-    expect(hasNoLogParameter(MyResolver, 'doThing', 0)).toBe(false);
-    expect(hasNoLogParameter(MyResolver, 'unknownMethod', 0)).toBe(false);
+    expect(HasNoLogParameter(MyResolver, 'doThing', 1)).toBe(true);
+    expect(HasNoLogParameter(MyResolver, 'doThing', 0)).toBe(false);
+    expect(HasNoLogParameter(MyResolver, 'unknownMethod', 0)).toBe(false);
   });
 
   it('marks a field on an input class (2-arg call) and is readable via getNoLogFields', () => {
@@ -24,7 +24,7 @@ describe('NoLog decorator', () => {
     }
     NoLog(MyInput.prototype, 'Token');
 
-    const fields = getNoLogFields(MyInput);
+    const fields = GetNoLogFields(MyInput);
     expect(fields.has('Token')).toBe(true);
     expect(fields.has('Queries')).toBe(false);
     expect(fields.size).toBe(1);
@@ -41,8 +41,8 @@ describe('NoLog decorator', () => {
       B: string = '';
     }
 
-    expect(hasNoLogParameter(UndecoratedResolver, 'doNothing', 0)).toBe(false);
-    expect(getNoLogFields(UndecoratedInput).size).toBe(0);
+    expect(HasNoLogParameter(UndecoratedResolver, 'doNothing', 0)).toBe(false);
+    expect(GetNoLogFields(UndecoratedInput).size).toBe(0);
   });
 
   it('supports multiple parameter marks on the same method', () => {
@@ -54,9 +54,9 @@ describe('NoLog decorator', () => {
     NoLog(TwoSecrets.prototype, 'handle', 0);
     NoLog(TwoSecrets.prototype, 'handle', 2);
 
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 0)).toBe(true);
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 1)).toBe(false);
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 2)).toBe(true);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 0)).toBe(true);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 1)).toBe(false);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 2)).toBe(true);
   });
 
   it('supports multiple field marks on the same input class', () => {
@@ -68,7 +68,7 @@ describe('NoLog decorator', () => {
     NoLog(TwoFieldSecrets.prototype, 'A');
     NoLog(TwoFieldSecrets.prototype, 'C');
 
-    const fields = getNoLogFields(TwoFieldSecrets);
+    const fields = GetNoLogFields(TwoFieldSecrets);
     expect(fields.has('A')).toBe(true);
     expect(fields.has('B')).toBe(false);
     expect(fields.has('C')).toBe(true);

package/src/__tests__/PrimaryKeyAlwaysMapped.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { selectFieldsToMap } from '../integration/EntityMapLifecycle.js';
+import { SelectFieldsToMap } from '../integration/EntityMapLifecycle.js';
 
 /**
  * Deselecting the primary key must not cost the object its identity.
@@ -18,41 +18,41 @@ const names = (out: Array<{ Name: string }>) => out.map(x => x.Name);
 
 describe('selectFieldsToMap — the primary key is never optional', () => {
     it('includes the key even when the user did not select it', () => {
-        expect(names(selectFieldsToMap(ALL, ['name', 'email']))).toEqual(['id', 'name', 'email']);
+        expect(names(SelectFieldsToMap(ALL, ['name', 'email']))).toEqual(['id', 'name', 'email']);
     });
 
     it('includes the key when the selection is EMPTY — an empty choice is still a choice', () => {
         // Distinct from "no selection". An empty array is unusual but real, and it still cannot
         // produce a keyless map.
-        expect(names(selectFieldsToMap(ALL, []))).toEqual(['id']);
+        expect(names(SelectFieldsToMap(ALL, []))).toEqual(['id']);
     });
 
     it('does not duplicate the key when it IS selected', () => {
-        expect(names(selectFieldsToMap(ALL, ['id', 'name']))).toEqual(['id', 'name']);
+        expect(names(SelectFieldsToMap(ALL, ['id', 'name']))).toEqual(['id', 'name']);
     });
 
     it('null or undefined selection means every field', () => {
-        expect(names(selectFieldsToMap(ALL, null))).toEqual(['id', 'name', 'email', 'notes']);
-        expect(names(selectFieldsToMap(ALL, undefined))).toEqual(['id', 'name', 'email', 'notes']);
+        expect(names(SelectFieldsToMap(ALL, null))).toEqual(['id', 'name', 'email', 'notes']);
+        expect(names(SelectFieldsToMap(ALL, undefined))).toEqual(['id', 'name', 'email', 'notes']);
     });
 
     it('keeps every part of a COMPOSITE key, selected or not', () => {
         const composite = [f('tenant_id', true), f('row_id', true), f('label')];
-        expect(names(selectFieldsToMap(composite, ['label']))).toEqual(['tenant_id', 'row_id', 'label']);
+        expect(names(SelectFieldsToMap(composite, ['label']))).toEqual(['tenant_id', 'row_id', 'label']);
     });
 
     it('matches selection names case-insensitively', () => {
-        expect(names(selectFieldsToMap(ALL, ['NAME', 'Email']))).toEqual(['id', 'name', 'email']);
+        expect(names(SelectFieldsToMap(ALL, ['NAME', 'Email']))).toEqual(['id', 'name', 'email']);
     });
 
     it('preserves the discovered field order', () => {
         // Field-map creation walks this list; reordering would reshuffle Priority-adjacent behaviour
         // for no reason.
-        expect(names(selectFieldsToMap(ALL, ['notes', 'name']))).toEqual(['id', 'name', 'notes']);
+        expect(names(SelectFieldsToMap(ALL, ['notes', 'name']))).toEqual(['id', 'name', 'notes']);
     });
 
     it('an object with no key at all is unaffected', () => {
         const keyless = [f('a'), f('b')];
-        expect(names(selectFieldsToMap(keyless, ['a']))).toEqual(['a']);
+        expect(names(SelectFieldsToMap(keyless, ['a']))).toEqual(['a']);
     });
 });

package/src/__tests__/RESTEndpointHandler.test.ts

@@ -188,26 +188,26 @@ describe('RESTEndpointHandler.isEntityAllowed', () => {
     });
 
     it('blocks entities in excluded schemas (case-insensitive), with schema exclusion taking top precedence', () => {
-        const schemaOnly = makeHandler({ excludeSchemas: ['VAULT'] });
+        const schemaOnly = makeHandler({ ExcludeSchemas: ['VAULT'] });
         expect(schemaOnly.isEntityAllowed('Secrets')).toBe(false);
         expect(schemaOnly.isEntityAllowed('Users')).toBe(true); // other schemas unaffected
 
         // Even an explicit entity include cannot override a schema exclusion
-        const withInclude = makeHandler({ excludeSchemas: ['vault'], includeEntities: ['secrets'] });
+        const withInclude = makeHandler({ ExcludeSchemas: ['vault'], IncludeEntities: ['secrets'] });
         expect(withInclude.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('restricts to included schemas when includeSchemas is set', () => {
-        const handler = makeHandler({ includeSchemas: ['crm'] });
+        const handler = makeHandler({ IncludeSchemas: ['crm'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('blocks lowercase exact-name exclusions and wildcard exclusions of any case', () => {
-        const lowercase = makeHandler({ excludeEntities: ['secrets'] });
+        const lowercase = makeHandler({ ExcludeEntities: ['secrets'] });
         expect(lowercase.isEntityAllowed('Secrets')).toBe(false);
 
-        const wildcard = makeHandler({ excludeEntities: ['Secret*'] });
+        const wildcard = makeHandler({ ExcludeEntities: ['Secret*'] });
         expect(wildcard.isEntityAllowed('Secrets')).toBe(false);
         expect(wildcard.isEntityAllowed('Users')).toBe(true);
     });
@@ -217,25 +217,25 @@ describe('RESTEndpointHandler.isEntityAllowed', () => {
         // the RAW configured pattern (only the wildcard branch lowercases patterns).
         // An operator writing excludeEntities: ['Secrets'] — the natural casing —
         // gets NO exclusion. Pinned so a normalization fix flips this test.
-        const handler = makeHandler({ excludeEntities: ['Secrets'] });
+        const handler = makeHandler({ ExcludeEntities: ['Secrets'] });
         expect(handler.isEntityAllowed('Secrets')).toBe(true); // exclusion ineffective!
     });
 
     it('exclusions override inclusions for the same entity', () => {
-        const handler = makeHandler({ includeEntities: ['user*'], excludeEntities: ['userroles'] });
+        const handler = makeHandler({ IncludeEntities: ['user*'], ExcludeEntities: ['userroles'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('UserRoles')).toBe(false);
     });
 
     it('an include list denies everything not on it, with wildcard support', () => {
-        const handler = makeHandler({ includeEntities: ['user*'] });
+        const handler = makeHandler({ IncludeEntities: ['user*'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('UserRoles')).toBe(true);
         expect(handler.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('SECURITY GAP: a mixed-case exact inclusion fails to include (same raw-pattern comparison)', () => {
-        const handler = makeHandler({ includeEntities: ['Users'] });
+        const handler = makeHandler({ IncludeEntities: ['Users'] });
         expect(handler.isEntityAllowed('Users')).toBe(false); // include list active, but never matches
     });
 });
@@ -271,7 +271,7 @@ describe('RESTEndpointHandler middleware', () => {
 
     describe('checkEntityAccess', () => {
         it('rejects blocked entities with 403 before any handler runs', () => {
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const req = makeReq({ params: { entityName: 'Secrets' } });
             const { res, statusCode, jsonBody } = makeRes();
             const next = vi.fn();
@@ -286,7 +286,7 @@ describe('RESTEndpointHandler middleware', () => {
         });
 
         it('passes allowed entities through', () => {
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const next = vi.fn();
 
             handler.checkEntityAccess(makeReq({ params: { entityName: 'Users' } }), makeRes().res, next);
@@ -295,7 +295,7 @@ describe('RESTEndpointHandler middleware', () => {
         });
 
         it('passes through when no entityName param is present', () => {
-            const handler = makeHandler({ includeEntities: ['nothing'] });
+            const handler = makeHandler({ IncludeEntities: ['nothing'] });
             const next = vi.fn();
 
             handler.checkEntityAccess(makeReq({ params: {} }), makeRes().res, next);
@@ -565,7 +565,7 @@ describe('RESTEndpointHandler view routes', () => {
         });
 
         it('returns 403 WITHOUT invoking the view layer when every requested entity is blocked', async () => {
-            const handler = makeHandler({ includeEntities: ['users'] });
+            const handler = makeHandler({ IncludeEntities: ['users'] });
             const { res, statusCode } = makeRes();
 
             await handler.runViews(
@@ -579,7 +579,7 @@ describe('RESTEndpointHandler view routes', () => {
 
         it('silently drops blocked entities and executes only the allowed remainder', async () => {
             mockOpsRunViews.mockResolvedValue({ success: true, results: [{ Success: true, Results: [] }] });
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const req = makeReq({ body: { params: [{ EntityName: 'Users' }, { EntityName: 'Secrets' }] } });
             const { res, jsonBody } = makeRes();
 

package/src/__tests__/RealtimeBridgeResolver.test.ts

@@ -50,8 +50,10 @@ vi.mock('@memberjunction/ai-agents', () => ({
 // Mock the meeting-recording registration so the thin resolver is tested in isolation (no MJStorage /
 // core-entities graph). Its own behavior is covered by meetingRecordingRegistration.test.ts.
 vi.mock('../resolvers/meetingRecordingRegistration', () => ({
-  registerMeetingRecordingFile: vi.fn(async () => ({ Success: true, RecordingFileID: 'file-1', ConversationID: 'conv-1' })),
-  correlateRecordingStart: vi.fn(async () => true),
+  RegisterMeetingRecordingFile: vi.fn(async () => ({ Success: true, RecordingFileID: 'file-1', ConversationID: 'conv-1' })),
+    get registerMeetingRecordingFile() { return this.RegisterMeetingRecordingFile; },
+  CorrelateRecordingStart: vi.fn(async () => true),
+    get correlateRecordingStart() { return this.CorrelateRecordingStart; },
 }));
 
 import { RealtimeBridgeResolver, MintLiveKitClientTokenInput, LiveKitRecordingInput } from '../resolvers/RealtimeBridgeResolver';

package/src/__tests__/RealtimeSdpBrokerHandler.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import type { Request, Response, NextFunction } from 'express';
 import { MJGlobal, RegisterClass } from '@memberjunction/global';
 import { BaseRealtimeModel, RealtimeProxyRegistry, IRealtimeSession, RealtimeSessionParams } from '@memberjunction/ai';
-import { createRealtimeSdpBrokerRouter, createOpenAILiveBrokerRouter, requireTicket } from '../rest/RealtimeSdpBrokerHandler.js';
+import { CreateRealtimeSdpBrokerRouter, createOpenAILiveBrokerRouter, RequireTicket } from '../rest/RealtimeSdpBrokerHandler.js';
 
 @RegisterClass(BaseRealtimeModel, 'MockOpenAILiveForBrokerTest', 10)
 class MockOpenAILiveForBrokerTest extends BaseRealtimeModel {
@@ -67,20 +67,20 @@ function makeMockReqRes(query: Record<string, string>, body: unknown): {
 }
 
 describe('RealtimeSdpBrokerHandler', () => {
-    let router: ReturnType<typeof createRealtimeSdpBrokerRouter>;
+    let router: ReturnType<typeof CreateRealtimeSdpBrokerRouter>;
 
     beforeEach(() => {
-        router = createRealtimeSdpBrokerRouter();
+        router = CreateRealtimeSdpBrokerRouter();
     });
 
     it('createOpenAILiveBrokerRouter is backwards-compatible alias', () => {
-        expect(createOpenAILiveBrokerRouter).toBe(createRealtimeSdpBrokerRouter);
+        expect(createOpenAILiveBrokerRouter).toBe(CreateRealtimeSdpBrokerRouter);
     });
 
     it('requireTicket middleware rejects missing ticket without calling next()', () => {
         const { req, res, getStatus, getJson } = makeMockReqRes({}, {});
         const next = vi.fn();
-        requireTicket(req, res, next as NextFunction);
+        RequireTicket(req, res, next as NextFunction);
         expect(getStatus()).toBe(401);
         expect(getJson().error).toContain('missing ticket');
         expect(next).not.toHaveBeenCalled();
@@ -89,7 +89,7 @@ describe('RealtimeSdpBrokerHandler', () => {
     it('requireTicket middleware rejects invalid ticket without calling next()', () => {
         const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: 'non-existent-ticket' }, {});
         const next = vi.fn();
-        requireTicket(req, res, next as NextFunction);
+        RequireTicket(req, res, next as NextFunction);
         expect(getStatus()).toBe(401);
         expect(getJson().error).toContain('invalid or expired ticket');
         expect(next).not.toHaveBeenCalled();

package/src/__tests__/RefreshAdoptsNewColumns.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { decideFieldMapReconcile } from '../integration/EntityMapLifecycle.js';
+import { DecideFieldMapReconcile } from '../integration/EntityMapLifecycle.js';
 
 /**
  * A REFRESH adopts the source's current shape: new objects and new columns both arrive ENABLED.
@@ -17,20 +17,20 @@ const fm = (SourceFieldName: string, Status: string) => ({ SourceFieldName, Stat
 
 describe('decideFieldMapReconcile — a refresh adopts new columns', () => {
     it('creates a new column ENABLED on an enabled map, by default', () => {
-        const plan = decideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Active' }]);
         expect(plan.Enable).toEqual([]);
         expect(plan.Disable).toEqual([]);
     });
 
     it('autoEnableNewColumns:false gates it for a connection that wants to review first', () => {
-        const plan = decideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, false);
+        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, false);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
     });
 
     it('a DISABLED map never gets an Active column — the map always bounds the column', () => {
         // Adopting new columns must not resurrect a map the user switched off.
-        const plan = decideFieldMapReconcile(['brand_new_col'], [], false, true);
+        const plan = DecideFieldMapReconcile(['brand_new_col'], [], false, true);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
     });
 });
@@ -40,24 +40,24 @@ describe('decideFieldMapReconcile — retiring and restoring are both non-destru
         // That row is not new — it was disabled because the source stopped reporting the column, so
         // it returns to the state it had. Gating it would silently demote a column the user chose to
         // sync whenever the source flickered.
-        const plan = decideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], true, false);
+        const plan = DecideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], true, false);
         expect(plan.Enable).toEqual(['came_back']);
         expect(plan.Create).toEqual([]);   // reuses the row, never mints a second one
     });
 
     it('a column absent from the resolution is DISABLED, never deleted', () => {
-        const plan = decideFieldMapReconcile(['kept'], [fm('kept', 'Active'), fm('vanished', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['kept'], [fm('kept', 'Active'), fm('vanished', 'Active')], true);
         expect(plan.Disable).toEqual(['vanished']);
         expect(plan.Enable).toEqual([]);   // survivor untouched
     });
 
     it('does not re-enable anything while the map itself is disabled', () => {
-        const plan = decideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], false);
+        const plan = DecideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], false);
         expect(plan.Enable).toEqual([]);
     });
 
     it('matches source field names case-insensitively on both sides', () => {
-        const plan = decideFieldMapReconcile(['ID', 'Name'], [fm('id', 'Active'), fm('name', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['ID', 'Name'], [fm('id', 'Active'), fm('name', 'Active')], true);
         expect(plan.Create).toEqual([]);
         expect(plan.Disable).toEqual([]);
     });