@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.8

package/src/__tests__/ResolverBase.encryptedApiZeroReencrypt.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Unit tests verifying GraphQL read paths for encrypted fields (1.5):
+ * 1. ResolverBase.RunViewGenericInternal forwards PreserveRestrictedApiCiphertext: true and
+ *    invokes Encrypt() 0 times when AllowDecryptInAPI === false (both SendEncryptedValue: true
+ *    and SendEncryptedValue: false).
+ * 2. RunViewResolver.RunViewsWithCacheCheck applies ArrayFilterEncryptedFieldsForAPI to both
+ *    `stale` (full refresh) and `differential` (`updatedRows`) responses without mutating
+ *    provider-cached row objects in place, and without invoking Encrypt() when rows already
+ *    hold ciphertext.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { encryptMock, decryptMock } = vi.hoisted(() => ({
+    encryptMock: vi.fn(),
+    decryptMock: vi.fn(),
+}));
+
+vi.mock('@memberjunction/encryption', () => ({
+    EncryptionEngine: {
+        get Instance() {
+            return {
+                Config: vi.fn().mockResolvedValue(undefined),
+                Encrypt: encryptMock,
+                Decrypt: decryptMock,
+                IsEncrypted: (v: string | null | undefined) => typeof v === 'string' && v.startsWith('$ENC$'),
+                GetKeyByID: vi.fn().mockReturnValue({ Marker: '$ENC$' }),
+            };
+        },
+    },
+    IsEncryptionKeyUnavailable: () => false,
+    ReportEncryptionKeyUnavailable: vi.fn(),
+}));
+
+import {
+    DatabaseProviderBase,
+    EntityInfo,
+    RunViewParams,
+    RunViewResult,
+    RunViewsWithCacheCheckResponse,
+    RunViewWithCacheCheckParams,
+    UserInfo,
+    UserRoleInfo,
+} from '@memberjunction/core';
+import { ENCRYPTED_SENTINEL } from '@memberjunction/global';
+import type { PubSubEngine } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { RunDynamicViewInput, RunViewResolver } from '../generic/RunViewResolver.js';
+import type { AppContext, RunViewGenericParams, UserPayload } from '../types.js';
+
+const ENTITY_ID = 'ent-vault-001';
+const KEY_ID = '11111111-2222-3333-4444-555555555555';
+const CIPHERTEXT_PASSTHROUGH = `$ENC$${KEY_ID}$AES-256-GCM$iv1$cipher1$tag1`;
+const CIPHERTEXT_REDACTED = `$ENC$${KEY_ID}$AES-256-GCM$iv2$cipher2$tag2`;
+
+type RowScalar = string | number | boolean | null | undefined;
+type VaultRow = Record<string, RowScalar>;
+
+function buildVaultEntity(): EntityInfo {
+    return new EntityInfo({
+        ID: ENTITY_ID,
+        Name: 'Vault Items',
+        SchemaName: '__mj',
+        BaseTable: 'VaultItem',
+        BaseView: 'vwVaultItems',
+        Status: 'Active',
+        EntityPermissions: [
+            {
+                ID: 'p-1',
+                EntityID: ENTITY_ID,
+                RoleID: 'r-1',
+                CanRead: true,
+                CanCreate: false,
+                CanUpdate: false,
+                CanDelete: false,
+            },
+        ],
+        EntityFields: [
+            {
+                ID: 'f-id',
+                EntityID: ENTITY_ID,
+                Sequence: 1,
+                Name: 'ID',
+                Type: 'uniqueidentifier',
+                IsPrimaryKey: true,
+                AllowsNull: false,
+                Status: 'Active',
+            },
+            {
+                ID: 'f-cipher',
+                EntityID: ENTITY_ID,
+                Sequence: 2,
+                Name: 'SealedSecret',
+                Type: 'nvarchar',
+                Length: -1,
+                AllowsNull: true,
+                Encrypt: true,
+                EncryptionKeyID: KEY_ID,
+                AllowDecryptInAPI: false,
+                SendEncryptedValue: true,
+                Status: 'Active',
+            },
+            {
+                ID: 'f-sentinel',
+                EntityID: ENTITY_ID,
+                Sequence: 3,
+                Name: 'RedactedSecret',
+                Type: 'nvarchar',
+                Length: -1,
+                AllowsNull: true,
+                Encrypt: true,
+                EncryptionKeyID: KEY_ID,
+                AllowDecryptInAPI: false,
+                SendEncryptedValue: false,
+                Status: 'Active',
+            },
+            {
+                ID: 'f-plain',
+                EntityID: ENTITY_ID,
+                Sequence: 4,
+                Name: 'PublicLabel',
+                Type: 'nvarchar',
+                Length: 100,
+                AllowsNull: true,
+                Encrypt: false,
+                Status: 'Active',
+            },
+        ],
+    });
+}
+
+function buildUserPayload(): UserPayload {
+    const role = new UserRoleInfo({ UserID: 'u-1', RoleID: 'r-1', Role: 'Reader' });
+    const userRecord = new UserInfo(null, {
+        ID: 'u-1',
+        Name: 'Reader',
+        Email: 'reader@example.test',
+        IsActive: true,
+        UserRoles: [role],
+    });
+    return {
+        userRecord,
+        email: 'reader@example.test',
+        sessionId: 'sess-1',
+    };
+}
+
+class EncryptedReadProbeResolver extends ResolverBase {
+    public async ExecuteDynamicView(
+        viewInput: RunDynamicViewInput,
+        provider: DatabaseProviderBase,
+        userPayload: UserPayload
+    ): Promise<RunViewResult<VaultRow>> {
+        return (await this.RunDynamicViewGeneric(viewInput, provider, userPayload, {} as PubSubEngine)) as RunViewResult<VaultRow>;
+    }
+
+    public async ExecuteBatchViews(params: RunViewGenericParams[]): Promise<RunViewResult<VaultRow>[]> {
+        return (await this.RunViewsGenericInternal(params)) as RunViewResult<VaultRow>[];
+    }
+}
+
+describe('Zero decrypt-then-re-encrypt on GraphQL reads (1.5)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('passes PreserveRestrictedApiCiphertext: true in RunViewGenericInternal and calls Encrypt() 0 times', async () => {
+        const entity = buildVaultEntity();
+        const userPayload = buildUserPayload();
+        let capturedRunViewParams: RunViewParams | undefined;
+
+        const frozenProviderRow: VaultRow = Object.freeze({
+            ID: 'v-1',
+            SealedSecret: CIPHERTEXT_PASSTHROUGH,
+            RedactedSecret: CIPHERTEXT_REDACTED,
+            PublicLabel: 'Prod Key',
+        });
+
+        const fakeProvider = {
+            Entities: [entity],
+            EntityByName: (name: string) => (name === entity.Name ? entity : undefined),
+            EntityByID: (id: string) => (id === entity.ID ? entity : undefined),
+            DatabaseType: 'mssql',
+            RunView: async (params: RunViewParams): Promise<RunViewResult<VaultRow>> => {
+                capturedRunViewParams = params;
+                return {
+                    Success: true,
+                    Results: [frozenProviderRow],
+                    UserViewRunID: '',
+                    RowCount: 1,
+                    TotalRowCount: 1,
+                    ExecutionTime: 1,
+                    ErrorMessage: '',
+                };
+            },
+        } as object as DatabaseProviderBase;
+
+        const resolver = new EncryptedReadProbeResolver();
+        const out = await resolver.ExecuteDynamicView(
+            {
+                EntityName: entity.Name,
+                ExtraFilter: '',
+                OrderBy: '',
+                UserSearchString: '',
+                ExcludeUserViewRunID: '',
+                OverrideExcludeFilter: '',
+                IgnoreMaxRows: false,
+                MaxRows: 100,
+                ForceAuditLog: false,
+                AuditLogDescription: '',
+                ResultType: 'simple',
+                StartRow: 0,
+            },
+            fakeProvider,
+            userPayload
+        );
+
+        expect(capturedRunViewParams?.PreserveRestrictedApiCiphertext).toBe(true);
+        expect(out.Success).toBe(true);
+        expect(out.Results[0].SealedSecret).toBe(CIPHERTEXT_PASSTHROUGH);
+        expect(out.Results[0].RedactedSecret).toBe(ENCRYPTED_SENTINEL);
+        expect(out.Results[0].PublicLabel).toBe('Prod Key');
+        expect(encryptMock).not.toHaveBeenCalled();
+        expect(decryptMock).not.toHaveBeenCalled();
+    });
+
+    it('applies API encryption filtering on RunViewsWithCacheCheck stale and differential rows with 0 Encrypt() calls', async () => {
+        const entity = buildVaultEntity();
+        const userPayload = buildUserPayload();
+
+        const frozenStaleRow: VaultRow = Object.freeze({
+            ID: 'v-stale',
+            SealedSecret: CIPHERTEXT_PASSTHROUGH,
+            RedactedSecret: CIPHERTEXT_REDACTED,
+            PublicLabel: 'Stale Row',
+        });
+        const frozenDiffRow: VaultRow = Object.freeze({
+            ID: 'v-diff',
+            SealedSecret: CIPHERTEXT_PASSTHROUGH,
+            RedactedSecret: CIPHERTEXT_REDACTED,
+            PublicLabel: 'Diff Row',
+        });
+
+        const fakeProvider = {
+            Entities: [entity],
+            EntityByName: (name: string) => (name === entity.Name ? entity : undefined),
+            EntityByID: (id: string) => (id === entity.ID ? entity : undefined),
+            DatabaseType: 'mssql',
+            RunViewsWithCacheCheck: async (
+                _params: RunViewWithCacheCheckParams[]
+            ): Promise<RunViewsWithCacheCheckResponse> => ({
+                success: true,
+                results: [
+                    {
+                        viewIndex: 0,
+                        status: 'stale',
+                        results: [frozenStaleRow],
+                        maxUpdatedAt: '2026-04-01T00:00:00.000Z',
+                        rowCount: 1,
+                    },
+                    {
+                        viewIndex: 1,
+                        status: 'differential',
+                        differentialData: {
+                            updatedRows: [frozenDiffRow],
+                            deletedRecordIDs: [],
+                        },
+                        maxUpdatedAt: '2026-04-02T00:00:00.000Z',
+                        rowCount: 1,
+                    },
+                ],
+            }),
+        } as object as DatabaseProviderBase;
+
+        const resolver = new RunViewResolver();
+        const ctx: AppContext = {
+            userPayload,
+            providers: [{ provider: fakeProvider, type: 'Read-Only' }],
+            dataSources: [],
+        };
+
+        const response = await resolver.RunViewsWithCacheCheck(
+            [
+                { params: { EntityName: 'Vault Items' } },
+                {
+                    params: { EntityName: 'Vault Items' },
+                    cacheStatus: { maxUpdatedAt: '2026-04-01T00:00:00.000Z', rowCount: 1 },
+                },
+            ],
+            ctx
+        );
+
+        expect(response.success).toBe(true);
+        const staleParsed = JSON.parse(response.results[0].Results![0].Data) as VaultRow;
+        expect(staleParsed.SealedSecret).toBe(CIPHERTEXT_PASSTHROUGH);
+        expect(staleParsed.RedactedSecret).toBe(ENCRYPTED_SENTINEL);
+        expect(staleParsed.PublicLabel).toBe('Stale Row');
+
+        const diffParsed = JSON.parse(response.results[1].differentialData!.updatedRows[0].Data) as VaultRow;
+        expect(diffParsed.SealedSecret).toBe(CIPHERTEXT_PASSTHROUGH);
+        expect(diffParsed.RedactedSecret).toBe(ENCRYPTED_SENTINEL);
+        expect(diffParsed.PublicLabel).toBe('Diff Row');
+
+        expect(encryptMock).not.toHaveBeenCalled();
+        expect(decryptMock).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/ResolverBase.entityMessageRelay.test.ts

@@ -62,6 +62,7 @@ import type { UserPayload } from '../types.js';
 import { BuildUser, EmployeeEntity, FullWidthEmployeeRow, HR_ROLE_ID, SECRET_SALARY } from './fieldSecurityFixtures.js';
 
 const SUBSCRIPTIONS_KEY = '___MJServer___ResolverBase___EventSubscriptions';
+const ACTIVE_SESSIONS_KEY = '___MJServer___ResolverBase___ActiveEntitySessions';
 
 /** An entity object of `entityInfo` loaded by `owner`, holding the full row. */
 function entityOwnedBy(entityInfo: EntityInfo, owner: UserInfo) {
@@ -79,8 +80,14 @@ function entityOwnedBy(entityInfo: EntityInfo, owner: UserInfo) {
 type OwnedEntity = ReturnType<typeof entityOwnedBy>;
 
 class TestResolver extends ResolverBase {
-    public Listen(entity: OwnedEntity, sessionUser: UserInfo) {
-        this.ListenForEntityMessages(entity as unknown as BaseEntity, {} as PubSubEngine, { sessionId: 'session-a', userRecord: sessionUser } as UserPayload);
+    public CloudEventCount = 0;
+
+    protected override async EmitCloudEvent(): Promise<void> {
+        this.CloudEventCount++;
+    }
+
+    public Listen(entity: OwnedEntity, sessionUser: UserInfo, sessionId = 'session-a') {
+        this.ListenForEntityMessages(entity as unknown as BaseEntity, {} as PubSubEngine, { sessionId, userRecord: sessionUser } as UserPayload);
     }
 }
 
@@ -102,6 +109,8 @@ function resetListeners(): void {
     const subscriptions = store[SUBSCRIPTIONS_KEY] as Map<string, Subscription> | undefined;
     subscriptions?.forEach(s => s.unsubscribe());
     subscriptions?.clear();
+    const activeSessions = store[ACTIVE_SESSIONS_KEY] as Map<string, Map<string, object>> | undefined;
+    activeSessions?.clear();
 }
 
 let userA: UserInfo;
@@ -173,4 +182,46 @@ describe('ResolverBase.ListenForEntityMessages: relay to the listening session',
         expect(JSON.parse(statusUpdates[0].message!).message).toBe('step 2 of 5');
         expect(statusUpdates[0].ownerUserId).toBe('user-a');
     });
+
+    it('REGRESSION: routes status updates to subsequent users on the same entity type while emitting CloudEvent once', async () => {
+        const entityInfo = EmployeeEntity(false);
+        const resolver = new TestResolver();
+
+        // userA registers first on Employees, then userB registers second on Employees
+        resolver.Listen(entityOwnedBy(entityInfo, userA), userA, 'session-a');
+        resolver.Listen(entityOwnedBy(entityInfo, userB), userB, 'session-b');
+
+        // Event raised by userB's entity MUST reach userB's session (not be dropped because userA registered first!)
+        raise(entityOwnedBy(entityInfo, userB), 'other', 'userB progress');
+        await settle();
+
+        expect(statusUpdates).toHaveLength(1);
+        expect(statusUpdates[0].sessionId).toBe('session-b');
+        expect(statusUpdates[0].ownerUserId).toBe('user-b');
+        expect(JSON.parse(statusUpdates[0].message!).message).toBe('userB progress');
+        expect(resolver.CloudEventCount).toBe(1);
+
+        // And userA still receives userA's own events without leaking to userB
+        raise(entityOwnedBy(entityInfo, userA), 'other', 'userA progress');
+        await settle();
+
+        expect(statusUpdates).toHaveLength(2);
+        expect(statusUpdates[1].sessionId).toBe('session-a');
+        expect(statusUpdates[1].ownerUserId).toBe('user-a');
+        expect(resolver.CloudEventCount).toBe(2);
+    });
+
+    it('fans out status updates across multiple active browser sessions for the same user without duplicating CloudEvents', async () => {
+        const entityInfo = EmployeeEntity(false);
+        const resolver = new TestResolver();
+
+        resolver.Listen(entityOwnedBy(entityInfo, userA), userA, 'session-a-tab1');
+        resolver.Listen(entityOwnedBy(entityInfo, userA), userA, 'session-a-tab2');
+
+        raise(entityOwnedBy(entityInfo, userA), 'other', 'tab sync');
+        await settle();
+
+        expect(statusUpdates.map((u) => u.sessionId).sort()).toEqual(['session-a-tab1', 'session-a-tab2']);
+        expect(resolver.CloudEventCount).toBe(1);
+    });
 });

package/src/__tests__/ResolverBase.includeBinaryFields.test.ts

@@ -193,6 +193,54 @@ describe('IncludeBinaryFields forwarding — batch resolver path', () => {
     });
 });
 
+describe('SkipTotalRowCount forwarding', () => {
+    it('reaches provider.RunView on the dynamic, by-name and by-ID paths', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        const probe = new Probe();
+
+        await probe.RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', SkipTotalRowCount: true } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByNameGeneric(
+            { ViewName: 'Saved View', ExtraFilter: '', OrderBy: '', SkipTotalRowCount: true } as RunViewByNameInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByIDGeneric(
+            { ViewID: 'view-1', ExtraFilter: '', OrderBy: '', SkipTotalRowCount: true } as RunViewByIDInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls.map(c => c.SkipTotalRowCount)).toEqual([true, true, true]);
+    });
+
+    it('reaches provider.RunViews per view on the batch path', async () => {
+        const { provider, runViewsCalls } = recordingProvider();
+        const inputs = [
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', SkipTotalRowCount: true },
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '' },
+        ] as (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[];
+
+        await new Probe().RunViewsGeneric(inputs, provider, fakePayload());
+
+        expect(runViewsCalls[0].map(c => c.SkipTotalRowCount)).toEqual([true, undefined]);
+    });
+
+    it('leaves TotalRowCount undefined rather than defaulting it', async () => {
+        const { provider } = recordingProvider();
+        const skipped = provider as unknown as { RunView: (p: RunViewParams) => Promise<RunViewResult> };
+        const original = skipped.RunView;
+        skipped.RunView = async p => ({ ...(await original(p)), TotalRowCount: undefined });
+
+        const result = await new Probe().RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', SkipTotalRowCount: true } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(result?.TotalRowCount).toBeUndefined();
+    });
+});
+
 describe('MapFieldNamesToCodeNames — byte arrays become base64', () => {
     const provider = {
         EntityByName: (name: string) => (name === ENTITY_NAME ? (entityStub() as unknown as EntityInfo) : undefined),
@@ -301,6 +349,18 @@ describe('RunViewResolver.RunViewsWithCacheCheck — IncludeBinaryFields + Buffe
         expect(received[0].map(p => p.params.IncludeBinaryFields)).toEqual([true, false, undefined]);
     });
 
+    it('forwards SkipTotalRowCount into the core params', async () => {
+        const { ctx, received } = cacheCheckContext([]);
+        const input = [
+            { params: { EntityName: ENTITY_NAME, SkipTotalRowCount: true } },
+            { params: { EntityName: ENTITY_NAME } },
+        ] as RunViewWithCacheCheckInput[];
+
+        await new RunViewResolver().RunViewsWithCacheCheck(input, ctx);
+
+        expect(received[0].map(p => p.params.SkipTotalRowCount)).toEqual([true, undefined]);
+    });
+
     it('serializes Buffers in stale results as base64', async () => {
         const { ctx } = cacheCheckContext([{ ID: 'r1', Embedding: Buffer.from(BYTES) }]);
         const input = [{ params: { EntityName: ENTITY_NAME, IncludeBinaryFields: true } }] as RunViewWithCacheCheckInput[];

package/src/__tests__/RunAIAgentResolver.branch.test.ts

@@ -41,6 +41,8 @@ vi.mock('@memberjunction/ai-agents', () => ({
         }
     },
     ArtifactToolManager: class {},
+    CanAgentOwnSubAgentConsults: vi.fn(() => false),
+    LoadOpenSubAgentConsults: vi.fn(async () => []),
 }));
 
 vi.mock('../realtimeWidget/widgetGuestElevation.js', () => ({
@@ -220,6 +222,8 @@ describe('executeAIAgent — ConversationBranchID', () => {
         await execute(...base, null);
         const [withBranch, trunk] = hoisted.runAgentInConversation.mock.calls.map(c => c[0] as Record<string, unknown>);
         expect(withBranch.ConversationBranchID).toBe('branch-b');
+        expect(withBranch.handoffChain).toBeUndefined();
         expect(trunk).not.toHaveProperty('ConversationBranchID');
+        expect(trunk.handoffChain).toBeUndefined();
     });
 });