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

package/src/__tests__/newUsers.test.ts

@@ -168,7 +168,8 @@ vi.mock('@memberjunction/global', async (importOriginal) => {
     };
 });
 
-vi.mock('../auth/initializeProviders.js', () => ({ initializeAuthProviders: vi.fn() }));
+vi.mock('../auth/initializeProviders.js', () => ({ InitializeAuthProviders: vi.fn(),
+    get initializeAuthProviders() { return this.InitializeAuthProviders; } }));
 
 vi.mock('@memberjunction/auth-providers', () => ({
     AuthProviderFactory: {
@@ -195,7 +196,7 @@ vi.mock('@memberjunction/api-keys', () => ({
 
 // ─── Import after mocks ─────────────────────────────────────────────────────
 import { NewUserBase } from '../auth/newUsers.js';
-import { verifyUserRecord } from '../auth/index.js';
+import { VerifyUserRecord } from '../auth/index.js';
 
 // ─── Mock-entity plumbing ───────────────────────────────────────────────────
 
@@ -557,7 +558,7 @@ describe('verifyUserRecord', () => {
     }
 
     it('returns undefined when no email is supplied', async () => {
-        const user = await verifyUserRecord(undefined, 'A', 'B');
+        const user = await VerifyUserRecord(undefined, 'A', 'B');
 
         expect(user).toBeUndefined();
         expect(mockGetEntityObject).not.toHaveBeenCalled();
@@ -566,7 +567,7 @@ describe('verifyUserRecord', () => {
     it('returns the cached user, matching email case-insensitively and trimmed', async () => {
         addCacheUser('someone@example.com');
 
-        const user = await verifyUserRecord('  SomeOne@Example.COM  ', 'A', 'B');
+        const user = await VerifyUserRecord('  SomeOne@Example.COM  ', 'A', 'B');
 
         expect(user).toBeDefined();
         expect((user as unknown as { Email: string }).Email).toBe('someone@example.com');
@@ -577,7 +578,7 @@ describe('verifyUserRecord', () => {
         mockCacheUsers.push({ ID: 'broken-1', Name: 'Broken', Email: '  ', Type: 'User' });
         const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
 
-        const user = await verifyUserRecord('missing@example.com', undefined, undefined);
+        const user = await VerifyUserRecord('missing@example.com', undefined, undefined);
 
         expect(user).toBeUndefined();
         expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('broken-1'));
@@ -587,15 +588,15 @@ describe('verifyUserRecord', () => {
         it('does NOT create a user when autoCreateNewUsers is false', async () => {
             mockConfig.userHandling.autoCreateNewUsers = false;
 
-            const user = await verifyUserRecord('new@example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
         });
 
         it('does NOT create a user when firstName or lastName is missing', async () => {
-            const missingFirst = await verifyUserRecord('new@example.com', undefined, 'User');
-            const missingLast = await verifyUserRecord('new@example.com', 'New', undefined);
+            const missingFirst = await VerifyUserRecord('new@example.com', undefined, 'User');
+            const missingLast = await VerifyUserRecord('new@example.com', 'New', undefined);
 
             expect(missingFirst).toBeUndefined();
             expect(missingLast).toBeUndefined();
@@ -605,7 +606,7 @@ describe('verifyUserRecord', () => {
         it('creates the user when enabled and domains are unrestricted, stamping config roles onto the returned UserInfo', async () => {
             mockConfig.userHandling.newUserRoles = ['UI', 'Developer'];
 
-            const user = await verifyUserRecord('new@example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User');
 
             expect(user).toBeDefined();
             const stamped = user as unknown as { Email: string; UserRoles: Array<{ Role: string; RoleID: string; UserID: string }> };
@@ -621,7 +622,7 @@ describe('verifyUserRecord', () => {
         it('returns undefined when the underlying createNewUser fails', async () => {
             saveBehavior['MJ: Users'] = () => false;
 
-            const user = await verifyUserRecord('new@example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             // The cache is no longer empty at rest (it holds the configured context user), so
@@ -637,35 +638,35 @@ describe('verifyUserRecord', () => {
         });
 
         it('creates the user when the email domain is authorized', async () => {
-            const user = await verifyUserRecord('new@example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User');
 
             expect(user).toBeDefined();
             expect(entitiesOf('MJ: Users')).toHaveLength(1);
         });
 
         it('does NOT create when the email domain is not authorized', async () => {
-            const user = await verifyUserRecord('new@evil.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@evil.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
         });
 
         it('creates when restricted and no request Origin is supplied, if the email domain is authorized', async () => {
-            const user = await verifyUserRecord('new@example.com', 'New', 'User', undefined);
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User', undefined);
 
             expect(user).toBeDefined();
             expect(entitiesOf('MJ: Users')).toHaveLength(1);
         });
 
         it('does NOT create when a forged Origin is authorized but the email domain is not', async () => {
-            const user = await verifyUserRecord('new@evil.com', 'New', 'User', 'example.com');
+            const user = await VerifyUserRecord('new@evil.com', 'New', 'User', 'example.com');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
         });
 
         it('matches email domains case-insensitively', async () => {
-            const user = await verifyUserRecord('new@EXAMPLE.COM', 'New', 'User');
+            const user = await VerifyUserRecord('new@EXAMPLE.COM', 'New', 'User');
 
             expect(user).toBeDefined();
         });
@@ -673,7 +674,7 @@ describe('verifyUserRecord', () => {
         it('supports wildcard patterns for email subdomains', async () => {
             mockConfig.userHandling.newUserAuthorizedDomains = ['*.example.com'];
 
-            const user = await verifyUserRecord('new@mail.example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@mail.example.com', 'New', 'User');
 
             expect(user).toBeDefined();
         });
@@ -681,7 +682,7 @@ describe('verifyUserRecord', () => {
         it('does NOT match the apex against "*.example.com" (pattern is matched in full)', async () => {
             mockConfig.userHandling.newUserAuthorizedDomains = ['*.example.com'];
 
-            const user = await verifyUserRecord('new@example.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
@@ -690,27 +691,27 @@ describe('verifyUserRecord', () => {
         it('rejects prefix confusion: "*.example.com" does not match "evilexample.com" (dot is escaped)', async () => {
             mockConfig.userHandling.newUserAuthorizedDomains = ['*.example.com'];
 
-            const user = await verifyUserRecord('new@evilexample.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@evilexample.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
         });
 
         it('rejects suffix confusion: the pattern is anchored, so "example.com.evil.com" is not authorized', async () => {
-            const user = await verifyUserRecord('new@example.com.evil.com', 'New', 'User');
+            const user = await VerifyUserRecord('new@example.com.evil.com', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
         });
 
         it('rejects "evilexample.com" against the plain "example.com" pattern (anchored at both ends)', async () => {
-            const user = await verifyUserRecord('x@evilexample.com', 'New', 'User');
+            const user = await VerifyUserRecord('x@evilexample.com', 'New', 'User');
 
             expect(user).toBeUndefined();
         });
 
         it('does NOT create when the identity has no email domain (username-only IdP)', async () => {
-            const user = await verifyUserRecord('bare-username', 'New', 'User');
+            const user = await VerifyUserRecord('bare-username', 'New', 'User');
 
             expect(user).toBeUndefined();
             expect(mockGetEntityObject).not.toHaveBeenCalled();
@@ -727,7 +728,7 @@ describe('verifyUserRecord', () => {
             });
             const dataSource = {} as unknown as import('mssql').ConnectionPool;
 
-            const user = await verifyUserRecord('late@example.com', undefined, undefined, undefined, dataSource);
+            const user = await VerifyUserRecord('late@example.com', undefined, undefined, undefined, dataSource);
 
             expect(user).toBeDefined();
             expect((user as unknown as { Email: string }).Email).toBe('late@example.com');
@@ -739,7 +740,7 @@ describe('verifyUserRecord', () => {
             mockConfig.userHandling.updateCacheWhenNotFound = true;
             const dataSource = {} as unknown as import('mssql').ConnectionPool;
 
-            const user = await verifyUserRecord('never@example.com', undefined, undefined, undefined, dataSource);
+            const user = await VerifyUserRecord('never@example.com', undefined, undefined, undefined, dataSource);
 
             expect(user).toBeUndefined();
             expect(mockRefresh).toHaveBeenCalledTimes(1);

package/src/__tests__/principals.test.ts

@@ -13,7 +13,7 @@
  * singleton nor a database — the seam is `(candidate, users) -> resolution`.
  */
 import { describe, it, expect } from 'vitest';
-import { resolvePrincipalFrom, type ResolvablePrincipal } from '../auth/principals.js';
+import { ResolvePrincipalFrom, type ResolvablePrincipal } from '../auth/principals.js';
 
 /**
  * The system user's ID, pinned by `UserCache` (`SYSTEM_USER_ID`) and seeded by every baseline.
@@ -63,14 +63,14 @@ const STOCK_HOST: ResolvablePrincipal[] = [SYSTEM, ANONYMOUS, HOST_ADMIN];
 describe('resolvePrincipalFrom', () => {
     describe('the shipped default (#4209)', () => {
         it('resolves the email-shaped default to the seeded System user', () => {
-            const result = resolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
 
             expect(result.user).toBe(SYSTEM);
             expect(result.reason).toBe('email');
         });
 
         it('reports no warning when the default resolves, so a stock host logs nothing', () => {
-            const result = resolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
 
             expect(result.warning).toBeUndefined();
         });
@@ -81,8 +81,8 @@ describe('resolvePrincipalFrom', () => {
             // `SELECT * FROM vwUsers` carries no ORDER BY and the cache is mutated in place at
             // runtime, so row order differs between boots AND within a process. Attribution must
             // not depend on it: this is what made CreatedByUserID incidental.
-            const ordered = resolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
-            const reversed = resolvePrincipalFrom(SHIPPED_DEFAULT, [...STOCK_HOST].reverse(), SYSTEM_USER_ID);
+            const ordered = ResolvePrincipalFrom(SHIPPED_DEFAULT, STOCK_HOST, SYSTEM_USER_ID);
+            const reversed = ResolvePrincipalFrom(SHIPPED_DEFAULT, [...STOCK_HOST].reverse(), SYSTEM_USER_ID);
 
             expect(reversed.user).toBe(ordered.user);
         });
@@ -107,7 +107,7 @@ describe('resolvePrincipalFrom', () => {
                 IsActive: true,
             };
 
-            const result = resolvePrincipalFrom('support@acme.com', [emailSupport, namedSupport], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('support@acme.com', [emailSupport, namedSupport], SYSTEM_USER_ID);
 
             expect(result.user).toBe(namedSupport);
             expect(result.reason).toBe('name');
@@ -125,15 +125,15 @@ describe('resolvePrincipalFrom', () => {
         const HIGH: ResolvablePrincipal = { ID: 'FFFFFFFF-0000-0000-0000-00000000000F', Name: 'shared.name', Email: 'high@acme.com', Type: 'User', IsActive: true };
 
         it('picks the lowest-ID user when two users share the configured Name', () => {
-            const result = resolvePrincipalFrom('shared.name', [HIGH, LOW, SYSTEM], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('shared.name', [HIGH, LOW, SYSTEM], SYSTEM_USER_ID);
 
             expect(result.user).toBe(LOW);
             expect(result.reason).toBe('name');
         });
 
         it('resolves a duplicated Name identically however the cache is ordered', () => {
-            const forward = resolvePrincipalFrom('shared.name', [HIGH, LOW, SYSTEM], SYSTEM_USER_ID);
-            const reversed = resolvePrincipalFrom('shared.name', [SYSTEM, LOW, HIGH], SYSTEM_USER_ID);
+            const forward = ResolvePrincipalFrom('shared.name', [HIGH, LOW, SYSTEM], SYSTEM_USER_ID);
+            const reversed = ResolvePrincipalFrom('shared.name', [SYSTEM, LOW, HIGH], SYSTEM_USER_ID);
 
             expect(reversed.user).toBe(forward.user);
         });
@@ -145,7 +145,7 @@ describe('resolvePrincipalFrom', () => {
             const lowEmail: ResolvablePrincipal = { ...LOW, Name: 'a.person', Email: 'shared@acme.com' };
             const highEmail: ResolvablePrincipal = { ...HIGH, Name: 'b.person', Email: 'shared@acme.com' };
 
-            const result = resolvePrincipalFrom('shared@acme.com', [highEmail, lowEmail, SYSTEM], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('shared@acme.com', [highEmail, lowEmail, SYSTEM], SYSTEM_USER_ID);
 
             expect(result.user).toBe(lowEmail);
             expect(result.reason).toBe('email');
@@ -169,7 +169,7 @@ describe('resolvePrincipalFrom', () => {
         };
 
         it('does not resolve a deactivated candidate by Email', () => {
-            const result = resolvePrincipalFrom('departed@acme.com', [...STOCK_HOST, RETIRED], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('departed@acme.com', [...STOCK_HOST, RETIRED], SYSTEM_USER_ID);
 
             expect(result.user).toBe(SYSTEM);
             expect(result.reason).toBe('system');
@@ -180,14 +180,14 @@ describe('resolvePrincipalFrom', () => {
             // most: without it the guarantee holds only for the rungs nobody configures.
             const renamed: ResolvablePrincipal = { ...RETIRED, Name: 'ops-service-account', Email: 'ops@acme.com' };
 
-            const result = resolvePrincipalFrom('ops-service-account', [...STOCK_HOST, renamed], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('ops-service-account', [...STOCK_HOST, renamed], SYSTEM_USER_ID);
 
             expect(result.user).toBe(SYSTEM);
             expect(result.reason).toBe('system');
         });
 
         it('reports that the candidate matched but is inactive, not that it matched nothing', () => {
-            const result = resolvePrincipalFrom('departed@acme.com', [...STOCK_HOST, RETIRED], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('departed@acme.com', [...STOCK_HOST, RETIRED], SYSTEM_USER_ID);
 
             // "matched no user's Name or Email" would send the operator hunting for a typo in a
             // value that is spelled correctly. The fix here is to reactivate the account or name a
@@ -215,7 +215,7 @@ describe('resolvePrincipalFrom', () => {
                 IsActive: true,
             };
 
-            const result = resolvePrincipalFrom('ops@acme.com', [inactiveByName, activeByEmail], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('ops@acme.com', [inactiveByName, activeByEmail], SYSTEM_USER_ID);
 
             expect(result.user).toBe(activeByEmail);
             expect(result.reason).toBe('email');
@@ -224,14 +224,14 @@ describe('resolvePrincipalFrom', () => {
     });
     describe('fallbacks', () => {
         it('falls back to the System user rather than an arbitrary Owner when the candidate is unresolvable', () => {
-            const result = resolvePrincipalFrom('nobody@nowhere.example', STOCK_HOST, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', STOCK_HOST, SYSTEM_USER_ID);
 
             expect(result.user).toBe(SYSTEM);
             expect(result.reason).toBe('system');
         });
 
         it('warns when a configured candidate did not resolve, naming the candidate', () => {
-            const result = resolvePrincipalFrom('nobody@nowhere.example', STOCK_HOST, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', STOCK_HOST, SYSTEM_USER_ID);
 
             expect(result.warning).toContain('nobody@nowhere.example');
         });
@@ -239,7 +239,7 @@ describe('resolvePrincipalFrom', () => {
         it('falls back to the System user WITHOUT warning when no candidate is configured', () => {
             // Zod defaults this setting to '', so an unset/blank value must not be reported as a
             // misconfiguration — but it must still land somewhere deterministic.
-            const result = resolvePrincipalFrom('', STOCK_HOST, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('', STOCK_HOST, SYSTEM_USER_ID);
 
             expect(result.user).toBe(SYSTEM);
             expect(result.warning).toBeUndefined();
@@ -256,7 +256,7 @@ describe('resolvePrincipalFrom', () => {
             };
             const users = [laterOwner, HOST_ADMIN, ANONYMOUS];
 
-            const result = resolvePrincipalFrom('nobody@nowhere.example', users, SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', users, SYSTEM_USER_ID);
 
             expect(result.user).toBe(HOST_ADMIN);
             expect(result.reason).toBe('owner');
@@ -271,7 +271,7 @@ describe('resolvePrincipalFrom', () => {
                 IsActive: false,
             };
 
-            const result = resolvePrincipalFrom('nobody@nowhere.example', [inactiveOwner, HOST_ADMIN], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', [inactiveOwner, HOST_ADMIN], SYSTEM_USER_ID);
 
             expect(result.user).toBe(HOST_ADMIN);
         });
@@ -281,7 +281,7 @@ describe('resolvePrincipalFrom', () => {
             // "we never act as a disabled user, except as the one user we reach first".
             const inactiveSystem: ResolvablePrincipal = { ...SYSTEM, IsActive: false };
 
-            const result = resolvePrincipalFrom('nobody@nowhere.example', [inactiveSystem, HOST_ADMIN], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', [inactiveSystem, HOST_ADMIN], SYSTEM_USER_ID);
 
             expect(result.user).toBe(HOST_ADMIN);
             expect(result.reason).toBe('owner');
@@ -290,13 +290,13 @@ describe('resolvePrincipalFrom', () => {
         it('returns no principal when the system user is deactivated and no active Owner remains', () => {
             const inactiveSystem: ResolvablePrincipal = { ...SYSTEM, IsActive: false };
 
-            const result = resolvePrincipalFrom('nobody@nowhere.example', [inactiveSystem, ANONYMOUS], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom('nobody@nowhere.example', [inactiveSystem, ANONYMOUS], SYSTEM_USER_ID);
 
             expect(result.user).toBeNull();
         });
 
         it('returns no principal at all when the cache is empty', () => {
-            const result = resolvePrincipalFrom(SHIPPED_DEFAULT, [], SYSTEM_USER_ID);
+            const result = ResolvePrincipalFrom(SHIPPED_DEFAULT, [], SYSTEM_USER_ID);
 
             expect(result.user).toBeNull();
             expect(result.reason).toBe('none');

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]),