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

package/src/__tests__/pushStatusFanOut.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for cross-instance fan-out of push-status updates (MJ #4222).
+ *
+ * Behind a load balancer the browser's WebSocket lives on one replica while the mutation driving
+ * the agent may be handled by another, so a completion can be published to a topic that has no
+ * subscriber. Replicating progress and completion closes that.
+ *
+ * Three properties are pinned here because each one, if wrong, produces a bug that looks like
+ * something else entirely:
+ *
+ * - **Streaming content is not replicated.** It is hundreds of messages per second, each carrying
+ *   a full serialized agent run. Replicating it would look like a network problem, not a bug here.
+ * - **Every publish carries `SourceServerId`.** Without it, echo suppression on the receiving side
+ *   has nothing to match and every push is delivered twice.
+ * - **A hook that throws does not break local delivery.** The message bus is an optimization over
+ *   the durable tail query; the local path must work when it is down.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+    publishStatusUpdate,
+    ParseReplicatedStatusUpdate,
+    ShouldReplicateStatusUpdate,
+    SetPushStatusPublishHook,
+    type PushStatusNotificationPayload,
+} from '../generic/PushStatusResolver.js';
+import { MJGlobal } from '@memberjunction/global';
+import type { PubSubEngine } from 'type-graphql';
+
+const SESSION = 'session-1';
+const OWNER = 'U0000000-0000-0000-0000-000000000000';
+
+function fakePubSub() {
+    const published: Array<{ topic: string; payload: PushStatusNotificationPayload }> = [];
+    const engine = {
+        publish: (topic: string, payload: PushStatusNotificationPayload) => {
+            published.push({ topic, payload });
+            return Promise.resolve();
+        },
+    } as unknown as PubSubEngine;
+    return { engine, published };
+}
+
+const envelope = (type: string) => JSON.stringify({ resolver: 'RunAIAgentResolver', type, status: 'ok', data: {} });
+
+afterEach(() => {
+    SetPushStatusPublishHook(undefined);
+});
+
+describe('ShouldReplicateStatusUpdate', () => {
+    it('replicates execution progress', () => {
+        expect(ShouldReplicateStatusUpdate(envelope('ExecutionProgress'))).toBe(true);
+    });
+
+    it('does not replicate streaming content', () => {
+        expect(ShouldReplicateStatusUpdate(envelope('StreamingContent'))).toBe(false);
+    });
+
+    it('replicates a plain-string message, which is rare and low-rate', () => {
+        expect(ShouldReplicateStatusUpdate('agent finished')).toBe(true);
+    });
+
+    it('does not replicate an empty message', () => {
+        expect(ShouldReplicateStatusUpdate(undefined)).toBe(false);
+        expect(ShouldReplicateStatusUpdate('')).toBe(false);
+    });
+
+    it('replicates JSON that is not the resolver envelope', () => {
+        expect(ShouldReplicateStatusUpdate(JSON.stringify({ hello: 'world' }))).toBe(true);
+    });
+});
+
+describe('publishStatusUpdate fan-out', () => {
+    beforeEach(() => {
+        SetPushStatusPublishHook(undefined);
+    });
+
+    it('stamps the publishing instance on every payload', () => {
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(published).toHaveLength(1);
+        expect(published[0].payload.SourceServerId).toBe(MJGlobal.Instance.ProcessUUID);
+    });
+
+    it('still publishes locally when no hook is registered', () => {
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(published[0].payload.ownerUserId).toBe(OWNER);
+    });
+
+    it('forwards a replicable update to the hook', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        const { engine } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(hook).toHaveBeenCalledTimes(1);
+        const forwarded = hook.mock.calls[0][0] as PushStatusNotificationPayload;
+        expect(forwarded.sessionId).toBe(SESSION);
+        expect(forwarded.ownerUserId).toBe(OWNER);
+        expect(forwarded.SourceServerId).toBe(MJGlobal.Instance.ProcessUUID);
+    });
+
+    it('does not forward streaming content, but still delivers it locally', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('StreamingContent') });
+
+        expect(hook).not.toHaveBeenCalled();
+        expect(published).toHaveLength(1);
+    });
+
+    it('delivers locally even when the hook throws', () => {
+        SetPushStatusPublishHook(() => {
+            throw new Error('redis is down');
+        });
+        const { engine, published } = fakePubSub();
+
+        expect(() =>
+            publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') })
+        ).not.toThrow();
+        expect(published).toHaveLength(1);
+    });
+
+    it('publishes locally before attempting fan-out', () => {
+        const order: string[] = [];
+        SetPushStatusPublishHook(() => order.push('hook'));
+        const engine = {
+            publish: () => {
+                order.push('local');
+                return Promise.resolve();
+            },
+        } as unknown as PubSubEngine;
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(order).toEqual(['local', 'hook']);
+    });
+
+    it('clears the hook when set with no argument', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        SetPushStatusPublishHook(undefined);
+        const { engine } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(hook).not.toHaveBeenCalled();
+    });
+});
+
+describe('ParseReplicatedStatusUpdate', () => {
+    /**
+     * Messages on the shared channel come from other processes, so every field is checked before
+     * the update is republished onto the local topic, where the subscription filter compares
+     * `ownerUserId` against the connection's user.
+     */
+    const LOCAL = 'LOCAL-PROCESS';
+    const raw = (over: Record<string, unknown> = {}) =>
+        JSON.stringify({ sessionId: SESSION, ownerUserId: OWNER, message: 'hello', SourceServerId: 'OTHER', ...over });
+
+    it('returns the update from another instance', () => {
+        expect(ParseReplicatedStatusUpdate(raw(), LOCAL)).toEqual({
+            sessionId: SESSION,
+            ownerUserId: OWNER,
+            message: 'hello',
+            SourceServerId: 'OTHER',
+        });
+    });
+
+    it('drops our own message echoed back by the bus', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ SourceServerId: LOCAL }), LOCAL)).toBeNull();
+    });
+
+    it('drops an update with no identity', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ ownerUserId: '' }), LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate(raw({ sessionId: undefined }), LOCAL)).toBeNull();
+    });
+
+    it('drops identity fields that are not strings', () => {
+        // A truthy object would pass a presence check and reach the filter as the wrong type.
+        expect(ParseReplicatedStatusUpdate(raw({ ownerUserId: { ID: OWNER } }), LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate(raw({ sessionId: 42 }), LOCAL)).toBeNull();
+    });
+
+    it('drops a message body that is not a string', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ message: { type: 'x' } }), LOCAL)).toBeNull();
+    });
+
+    it('accepts an update with no message body', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ message: undefined }), LOCAL)?.message).toBeUndefined();
+    });
+
+    it('drops malformed JSON and values that are not objects', () => {
+        expect(ParseReplicatedStatusUpdate('{not json', LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate('null', LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate('42', LOCAL)).toBeNull();
+    });
+});

package/src/__tests__/pushStatusResolver.filter.test.ts

@@ -10,7 +10,7 @@
  */
 import 'reflect-metadata';
 import { describe, it, expect } from 'vitest';
-import { statusUpdatesFilter, type PushStatusNotificationPayload, type StatusUpdatesFilterContext } from '../generic/PushStatusResolver';
+import { StatusUpdatesFilter, type PushStatusNotificationPayload, type StatusUpdatesFilterContext } from '../generic/PushStatusResolver';
 import type { UserPayload } from '../types';
 
 const OWNER = 'AA11BB22-0000-4000-8000-000000000001';
@@ -28,29 +28,29 @@ function push(overrides: Partial<PushStatusNotificationPayload> = {}): PushStatu
 
 describe('statusUpdatesFilter (B49 session-hijack gate)', () => {
   it('delivers when sessionId matches AND the connection identity owns the push', () => {
-    expect(statusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: ctxFor(OWNER) })).toBe(true);
+    expect(StatusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: ctxFor(OWNER) })).toBe(true);
   });
 
   it('THE FIX: rejects a matching sessionId when the connection identity is a DIFFERENT user (hijack)', () => {
     // Attacker lifted the victim's sessionId and subscribes with it — but their authenticated
     // connection identity is their own, so delivery must be denied.
-    expect(statusUpdatesFilter({ payload: push({ ownerUserId: OWNER }), args: { sessionId: SESSION }, context: ctxFor(ATTACKER) })).toBe(false);
+    expect(StatusUpdatesFilter({ payload: push({ ownerUserId: OWNER }), args: { sessionId: SESSION }, context: ctxFor(ATTACKER) })).toBe(false);
   });
 
   it('rejects when the requested sessionId does not match the push', () => {
-    expect(statusUpdatesFilter({ payload: push(), args: { sessionId: 'some-other-session' }, context: ctxFor(OWNER) })).toBe(false);
+    expect(StatusUpdatesFilter({ payload: push(), args: { sessionId: 'some-other-session' }, context: ctxFor(OWNER) })).toBe(false);
   });
 
   it('fails closed when the push carries no ownerUserId', () => {
-    expect(statusUpdatesFilter({ payload: push({ ownerUserId: '' }), args: { sessionId: SESSION }, context: ctxFor(OWNER) })).toBe(false);
+    expect(StatusUpdatesFilter({ payload: push({ ownerUserId: '' }), args: { sessionId: SESSION }, context: ctxFor(OWNER) })).toBe(false);
   });
 
   it('fails closed when the connection has no authenticated identity', () => {
-    expect(statusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: ctxFor(undefined) })).toBe(false);
-    expect(statusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: undefined })).toBe(false);
+    expect(StatusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: ctxFor(undefined) })).toBe(false);
+    expect(StatusUpdatesFilter({ payload: push(), args: { sessionId: SESSION }, context: undefined })).toBe(false);
   });
 
   it('matches identity case-insensitively (SQL Server upper vs PostgreSQL lower UUIDs)', () => {
-    expect(statusUpdatesFilter({ payload: push({ ownerUserId: OWNER.toUpperCase() }), args: { sessionId: SESSION }, context: ctxFor(OWNER.toLowerCase()) })).toBe(true);
+    expect(StatusUpdatesFilter({ payload: push({ ownerUserId: OWNER.toUpperCase() }), args: { sessionId: SESSION }, context: ctxFor(OWNER.toLowerCase()) })).toBe(true);
   });
 });

package/src/__tests__/secretRedactor.failOpen.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import type { IMetadataProvider } from '@memberjunction/core';
-import { redactArg, ResetUnboundCrudInputWarnings } from '../logging/secretRedactor.js';
+import { RedactArg, ResetUnboundCrudInputWarnings } from '../logging/secretRedactor.js';
 
 /**
  * `redactArg` binds a GraphQL input type to an entity by NAME:
@@ -42,7 +42,7 @@ afterEach(() => {
 
 describe('redactArg — entity-bound inputs (the codegen case)', () => {
     it('redacts an encrypted column, keeping the rest', () => {
-        const out = redactArg({
+        const out = RedactArg({
             inputTypeName: 'CreateMJCredentialInput',
             rawValue: { Name: 'Stripe', Values: SECRET },
             provider: CREDENTIAL_ENTITY,
@@ -55,7 +55,7 @@ describe('redactArg — entity-bound inputs (the codegen case)', () => {
     });
 
     it('emits no warning, because the binding resolved', () => {
-        redactArg({
+        RedactArg({
             inputTypeName: 'CreateMJCredentialInput',
             rawValue: { Values: SECRET },
             provider: CREDENTIAL_ENTITY,
@@ -76,14 +76,14 @@ describe('redactArg — name matches the convention but no entity exists', () =>
     };
 
     it('falls open — values are logged, which is the defect being surfaced', () => {
-        const out = redactArg({ ...unbound });
+        const out = RedactArg({ ...unbound });
         // Documents current behaviour: no entity binding and no @NoLog means no
         // redaction source, so the value survives into the log.
         expect(JSON.stringify(out)).toContain(SECRET);
     });
 
     it('now warns, naming the input type and what to do about it', () => {
-        redactArg({ ...unbound });
+        RedactArg({ ...unbound });
 
         expect(console.warn).toHaveBeenCalledTimes(1);
         const message = vi.mocked(console.warn).mock.calls[0][0] as string;
@@ -94,22 +94,22 @@ describe('redactArg — name matches the convention but no entity exists', () =>
     });
 
     it('warns only once per input type, however hot the mutation is', () => {
-        redactArg({ ...unbound });
-        redactArg({ ...unbound });
-        redactArg({ ...unbound });
+        RedactArg({ ...unbound });
+        RedactArg({ ...unbound });
+        RedactArg({ ...unbound });
         expect(console.warn).toHaveBeenCalledTimes(1);
     });
 
     it('warns separately for a different unbound input type', () => {
-        redactArg({ ...unbound });
-        redactArg({ ...unbound, inputTypeName: 'CreateScheduleInput' });
+        RedactArg({ ...unbound });
+        RedactArg({ ...unbound, inputTypeName: 'CreateScheduleInput' });
         expect(console.warn).toHaveBeenCalledTimes(2);
     });
 });
 
 describe('redactArg — @NoLog closes the gap the metadata cannot', () => {
     it('redacts a marked field on an input with no entity binding', () => {
-        const out = redactArg({
+        const out = RedactArg({
             inputTypeName: 'CreateConnectionInput',
             rawValue: { CredentialName: 'acme', CredentialValues: SECRET },
             provider: CREDENTIAL_ENTITY,
@@ -123,7 +123,7 @@ describe('redactArg — @NoLog closes the gap the metadata cannot', () => {
     });
 
     it('a parameter-level mark redacts the whole arg regardless of binding', () => {
-        const out = redactArg({
+        const out = RedactArg({
             inputTypeName: 'CreateConnectionInput',
             rawValue: { CredentialValues: SECRET },
             provider: CREDENTIAL_ENTITY,

package/src/__tests__/secretRedactor.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import type { IMetadataProvider } from '@memberjunction/core';
-import { redactArg } from '../logging/secretRedactor.js';
+import { RedactArg } from '../logging/secretRedactor.js';
 
 type EncryptedField = { Name: string };
 type FakeEntity = { ClassName: string; EncryptedFields: EncryptedField[] };
@@ -22,7 +22,7 @@ describe('redactArg', () => {
   };
 
   it('returns "<redacted>" when noLogParameter is set, regardless of other inputs', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateMJCredentialInput',
       rawValue: { Values: 'FAKE_SECRET_VALUE_DO_NOT_USE' },
       provider: makeProvider([credentialEntity]),
@@ -33,7 +33,7 @@ describe('redactArg', () => {
   });
 
   it('returns "<metadata-not-ready>" when the provider has no entities (bootstrap window)', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateMJCredentialInput',
       rawValue: { Values: 'FAKE_SECRET_VALUE_DO_NOT_USE' },
       provider: makeProvider([]),
@@ -44,7 +44,7 @@ describe('redactArg', () => {
   });
 
   it('fails open (passes through) when input type does not match Create/Update<X>Input regex', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'SomeCustomArgs',
       rawValue: { accessToken: 'FAKE_TOKEN' },
       provider: makeProvider([credentialEntity]),
@@ -55,7 +55,7 @@ describe('redactArg', () => {
   });
 
   it('fails open when input type matches regex but no entity is found', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateUnknownEntityInput',
       rawValue: { Foo: 'bar' },
       provider: makeProvider([credentialEntity]),
@@ -66,7 +66,7 @@ describe('redactArg', () => {
   });
 
   it('redacts top-level keys matching EntityFieldInfo.Encrypt=true on entity-bound CRUD inputs', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateMJCredentialInput',
       rawValue: { ID: 'abc-123', Name: 'HubSpot', Values: 'FAKE_SECRET_VALUE_DO_NOT_USE' },
       provider: makeProvider([credentialEntity]),
@@ -81,7 +81,7 @@ describe('redactArg', () => {
   });
 
   it('redacts top-level keys in noLogFields even when EncryptedFields does not include them', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateUserInput',
       rawValue: { Name: 'Alice', SecretToken: 'oops' },
       provider: makeProvider([userEntity]),
@@ -95,7 +95,7 @@ describe('redactArg', () => {
   });
 
   it('Update<X>Input is also handled (not just Create<X>Input)', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'UpdateMJCredentialInput',
       rawValue: { ID: 'abc-123', Values: 'NEW_FAKE_SECRET' },
       provider: makeProvider([credentialEntity]),
@@ -113,7 +113,7 @@ describe('redactArg', () => {
     // resolvers as metadata-bound instead of flooding with false positives. Security is identical:
     // delete inputs carry PK + Options only — no encrypted field, so nothing is redacted, the keys
     // just pass through. See docs/adr/0001-graphql-variables-logging-tiered-by-verbose.md.
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'DeleteMJCredentialInput',
       rawValue: { ID: 'abc-123' },
       provider: makeProvider([credentialEntity]),
@@ -125,7 +125,7 @@ describe('redactArg', () => {
 
   it('Delete<X>Input never exposes an encrypted value even if one were somehow present', () => {
     // Defense-in-depth: even if a delete input carried an encrypted field name, it must still mask.
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'DeleteMJCredentialInput',
       rawValue: { ID: 'abc-123', Values: 'FAKE_SECRET_VALUE_DO_NOT_USE' },
       provider: makeProvider([credentialEntity]),
@@ -136,7 +136,7 @@ describe('redactArg', () => {
   });
 
   it('only walks TOP-level keys — nested objects with encrypted-field names are not recursed', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateMJCredentialInput',
       rawValue: {
         Name: 'HubSpot',
@@ -151,7 +151,7 @@ describe('redactArg', () => {
   });
 
   it('passes non-object raw values through to shortenForLog', () => {
-    const result = redactArg({
+    const result = RedactArg({
       inputTypeName: 'CreateMJCredentialInput',
       rawValue: 'plain-string',
       provider: makeProvider([credentialEntity]),

package/src/__tests__/serverExtensionReservedRoots.test.ts

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import {
     CORE_CONSTANT_RESERVED_SERVER_EXTENSION_ROOTS,
     CORE_STATIC_RESERVED_SERVER_EXTENSION_ROOTS,
-    coreReservedServerExtensionRoots,
+    CoreReservedServerExtensionRoots,
 } from '../serverExtensionReservedRoots.js';
 import { validateServerExtensionRootPath } from '@memberjunction/server-extensions-core';
 
@@ -58,12 +58,12 @@ describe('coreReservedServerExtensionRoots', () => {
 
     it('structurally guarantees every pre-auth app.use / app.get / app.post mount in index.ts is reserved', () => {
         const indexSrc = readFileSync(join(SRC, 'index.ts'), 'utf8');
-        const authMiddlewareIndex = indexSrc.indexOf('app.use(createUnifiedAuthMiddleware');
+        const authMiddlewareIndex = indexSrc.indexOf('app.use(CreateUnifiedAuthMiddleware');
         expect(authMiddlewareIndex).toBeGreaterThan(0);
         const preAuthSrc = indexSrc.substring(0, authMiddlewareIndex);
 
         const mountRegex = /app\.(?:use|get|post)\s*\(\s*([^,\s)]+)/g;
-        const reservedRoots = coreReservedServerExtensionRoots('/');
+        const reservedRoots = CoreReservedServerExtensionRoots('/');
 
         // Explicit allowlist of known non-path middleware mounts (e.g. app.use(mw), app.use(cors()), app.use(compression(...)))
         const knownNonPathTokens = [
@@ -71,7 +71,7 @@ describe('coreReservedServerExtensionRoots', () => {
             'express.',
             'compression',
             'cookieParser',
-            'createUnifiedAuthMiddleware',
+            'CreateUnifiedAuthMiddleware',
             'mw',
         ];
         const isKnownNonPath = (t: string): boolean =>
@@ -120,7 +120,7 @@ describe('coreReservedServerExtensionRoots', () => {
     });
 
     it('includes graphqlRootPath and every core mount', () => {
-        const roots = coreReservedServerExtensionRoots('/api');
+        const roots = CoreReservedServerExtensionRoots('/api');
         expect(roots).toEqual(
             expect.arrayContaining([
                 '/api',
@@ -139,7 +139,7 @@ describe('coreReservedServerExtensionRoots', () => {
     });
 
     it('closes the F-M2 bypasses: cased /auth and sibling /healthcheck', () => {
-        const extra = coreReservedServerExtensionRoots('/');
+        const extra = CoreReservedServerExtensionRoots('/');
         expect(validateServerExtensionRootPath('/Auth', extra)).toMatch(/reserved prefix/);
         expect(validateServerExtensionRootPath('/healthcheck', extra)).toMatch(/reserved prefix/);
         expect(validateServerExtensionRootPath('/Healthcheck', extra)).toMatch(/reserved prefix/);
@@ -156,7 +156,7 @@ describe('coreReservedServerExtensionRoots', () => {
     });
 
     it('reserves a non-default graphqlRootPath and its nested paths', () => {
-        const extra = coreReservedServerExtensionRoots('/api');
+        const extra = CoreReservedServerExtensionRoots('/api');
         expect(validateServerExtensionRootPath('/api', extra)).toMatch(/reserved prefix/);
         expect(validateServerExtensionRootPath('/api/graphql', extra)).toMatch(/reserved prefix/);
         expect(validateServerExtensionRootPath('/apiv2', extra)).toBeNull();

package/src/__tests__/subscriptionRedaction.test.ts

@@ -45,7 +45,7 @@ vi.mock('../config.js', () => ({
   },
 }));
 
-import { variablesLoggingMiddleware } from '../logging/variablesLoggingMiddleware.js';
+import { VariablesLoggingMiddleware } from '../logging/variablesLoggingMiddleware.js';
 
 /**
  * Build a synthetic GraphQLResolveInfo-shaped object that matches what type-graphql passes
@@ -99,7 +99,7 @@ describe('variablesLoggingMiddleware', () => {
 
   it('skips field resolvers (info.path.prev !== undefined) without logging', async () => {
     const next = vi.fn(async () => 'next-result');
-    const result = await variablesLoggingMiddleware(
+    const result = await VariablesLoggingMiddleware(
       {
         root: undefined,
         args: { x: 1 },
@@ -126,7 +126,7 @@ describe('variablesLoggingMiddleware', () => {
       ],
     };
 
-    await variablesLoggingMiddleware(
+    await VariablesLoggingMiddleware(
       {
         root: undefined,
         args: { input: { ID: 'abc', Name: 'HubSpot', Values: 'FAKE_SECRET' } },
@@ -165,7 +165,7 @@ describe('variablesLoggingMiddleware', () => {
       Entities: [{ ClassName: 'SomeUnrelatedEntity', EncryptedFields: [] }],
     };
 
-    await variablesLoggingMiddleware(
+    await VariablesLoggingMiddleware(
       {
         root: undefined,
         args: { token: 'plaintext-leak' },
@@ -196,7 +196,7 @@ describe('variablesLoggingMiddleware', () => {
     const next = vi.fn(async () => undefined);
     const fakeProvider = { Entities: [] };
 
-    await variablesLoggingMiddleware(
+    await VariablesLoggingMiddleware(
       {
         root: undefined,
         args: { input: { Values: 'FAKE_SECRET' } },

package/src/__tests__/unifiedAuth.test.ts

@@ -59,16 +59,22 @@ vi.mock('jsonwebtoken', () => ({
 }));
 
 vi.mock('../auth/index.js', () => ({
-  getSigningKeys: mockGetSigningKeys,
-  getSystemUser: vi.fn(),
-  getValidationOptions: mockGetValidationOptions,
-  verifyUserRecord: mockVerifyUserRecord,
-  extractUserInfoFromPayload: mockExtractUserInfo,
+  GetSigningKeys: mockGetSigningKeys,
+    get getSigningKeys() { return this.GetSigningKeys; },
+  GetSystemUser: vi.fn(),
+    get getSystemUser() { return this.GetSystemUser; },
+  GetValidationOptions: mockGetValidationOptions,
+    get getValidationOptions() { return this.GetValidationOptions; },
+  VerifyUserRecord: mockVerifyUserRecord,
+    get verifyUserRecord() { return this.VerifyUserRecord; },
+  ExtractUserInfoFromPayload: mockExtractUserInfo,
+    get extractUserInfoFromPayload() { return this.ExtractUserInfoFromPayload; },
 }));
 
 vi.mock('../cache.js', () => {
   const map = new Map<string, boolean>();
-  return { authCache: map };
+  return { AuthCache: map,
+    get authCache() { return this.AuthCache; } };
 });
 
 vi.mock('../config.js', () => ({
@@ -95,7 +101,7 @@ vi.mock('@memberjunction/api-keys', () => ({
   GetAPIKeyEngine: vi.fn(),
 }));
 
-import { createUnifiedAuthMiddleware } from '../context.js';
+import { CreateUnifiedAuthMiddleware } from '../context.js';
 import type { Request, Response, NextFunction } from 'express';
 import type { DataSourceInfo } from '../types.js';
 
@@ -178,11 +184,11 @@ function setupSuccessfulAuth() {
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
 describe('createUnifiedAuthMiddleware', () => {
-  let middleware: ReturnType<typeof createUnifiedAuthMiddleware>;
+  let middleware: ReturnType<typeof CreateUnifiedAuthMiddleware>;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    middleware = createUnifiedAuthMiddleware(mockDataSources);
+    middleware = CreateUnifiedAuthMiddleware(mockDataSources);
   });
 
   describe('OPTIONS passthrough', () => {

package/src/__tests__/visitorIdentity.resolve.test.ts

@@ -13,7 +13,7 @@ vi.mock('@memberjunction/core', async (importOriginal) => {
     };
 });
 
-import { resolveIdentityByEmail } from '../realtimeWidget/visitorIdentity.js';
+import { ResolveIdentityByEmail } from '../realtimeWidget/visitorIdentity.js';
 import type { EntityInfo, IMetadataProvider, UserInfo } from '@memberjunction/core';
 
 type LookupParams = { EntityName: string; ExtraFilter: string; Fields: string[] };
@@ -32,7 +32,7 @@ describe('resolveIdentityByEmail — the configured identity entity can have ANY
     it('selects the real key column and returns its bare value for a single non-ID key', async () => {
         runViewMock.mockResolvedValue({ Success: true, Results: [{ individual_id: 4711 }] });
         const provider = makeProvider({ ID: 'ent-persons', PrimaryKeys: [{ Name: 'individual_id' }] });
-        const out = await resolveIdentityByEmail('ada@example.com', user, provider, { entityName: 'Persons', emailField: 'EmailAddress' });
+        const out = await ResolveIdentityByEmail('ada@example.com', user, provider, { entityName: 'Persons', EmailField: 'EmailAddress' });
         expect(lastParams().Fields).toEqual(['individual_id']);
         expect(lastParams().ExtraFilter).toBe("EmailAddress = 'ada@example.com'");
         expect(out).toEqual({ entityId: 'ent-persons', recordId: '4711' });
@@ -41,7 +41,7 @@ describe('resolveIdentityByEmail — the configured identity entity can have ANY
     it('selects EVERY key column and carries a composite key as a full segment, not its first column', async () => {
         runViewMock.mockResolvedValue({ Success: true, Results: [{ OrderID: '11055', LineNo: 3 }] });
         const provider = makeProvider({ ID: 'ent-lines', PrimaryKeys: [{ Name: 'OrderID' }, { Name: 'LineNo' }] });
-        const out = await resolveIdentityByEmail('x@y.com', user, provider, { entityName: 'Order Lines' });
+        const out = await ResolveIdentityByEmail('x@y.com', user, provider, { entityName: 'Order Lines' });
         expect(lastParams().Fields).toEqual(['OrderID', 'LineNo']);
         expect(out).toEqual({ entityId: 'ent-lines', recordId: 'OrderID|11055||LineNo|3' });
     });
@@ -49,13 +49,13 @@ describe('resolveIdentityByEmail — the configured identity entity can have ANY
     it('stays anonymous when no row matches or a key column is null', async () => {
         const provider = makeProvider({ ID: 'ent-users', PrimaryKeys: [{ Name: 'ID' }] });
         runViewMock.mockResolvedValue({ Success: true, Results: [] });
-        expect(await resolveIdentityByEmail('none@y.com', user, provider)).toBeUndefined();
+        expect(await ResolveIdentityByEmail('none@y.com', user, provider)).toBeUndefined();
         runViewMock.mockResolvedValue({ Success: true, Results: [{ ID: null }] });
-        expect(await resolveIdentityByEmail('null@y.com', user, provider)).toBeUndefined();
+        expect(await ResolveIdentityByEmail('null@y.com', user, provider)).toBeUndefined();
     });
 
     it('stays anonymous when the configured entity is not in metadata', async () => {
-        expect(await resolveIdentityByEmail('a@b.com', user, makeProvider(undefined), { entityName: 'Nope' })).toBeUndefined();
+        expect(await ResolveIdentityByEmail('a@b.com', user, makeProvider(undefined), { entityName: 'Nope' })).toBeUndefined();
         expect(runViewMock).not.toHaveBeenCalled();
     });
 });