@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.7

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

@@ -0,0 +1,227 @@
+/**
+ * The entity-message relay in `ResolverBase.ListenForEntityMessages`.
+ *
+ * There is one listener per entity name per process, and it relays to the session that created
+ * it. So it must relay only events raised by an object that belongs to that session's user, and
+ * never the record values a payload can carry: a delete's payload is the whole deleted row.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { statusUpdates } = vi.hoisted(() => ({
+    statusUpdates: [] as Array<{ sessionId: string; ownerUserId: string; message: string | undefined }>,
+}));
+
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({ SQLServerDataProvider: class {} }));
+vi.mock('@memberjunction/generic-database-provider', () => ({ UserCache: { Users: [] } }));
+vi.mock('cloudevents', () => ({
+    CloudEvent: class {},
+    httpTransport: () => () => undefined,
+    emitterFor: () => () => undefined,
+}));
+vi.mock('type-graphql', () => {
+    const noop = () => () => undefined;
+    return {
+        Resolver: noop, Mutation: noop, Query: noop, Subscription: noop, Ctx: noop, Arg: noop, PubSub: noop,
+        Root: noop, ObjectType: noop, InputType: noop, Field: noop, FieldResolver: noop,
+        Int: undefined, Float: undefined, registerEnumType: () => undefined,
+    };
+});
+vi.mock('graphql', () => ({ GraphQLError: class extends Error {} }));
+vi.mock('mssql', () => ({}));
+vi.mock('@memberjunction/api-keys', () => ({ GetAPIKeyEngine: vi.fn() }));
+vi.mock('@memberjunction/encryption', () => ({ EncryptionEngine: { Instance: {} } }));
+vi.mock('@memberjunction/graphql-dataprovider', () => ({ FieldMapper: class { MapFieldName(n: string) { return n; } ReverseMapFieldName(n: string) { return n; } } }));
+vi.mock('../generic/PubSubManager.js', () => ({ PubSubManager: { Instance: { Publish: () => undefined } } }));
+vi.mock('../generic/PushStatusResolver.js', () => ({
+    PUSH_STATUS_UPDATES_TOPIC: 'test-push-topic',
+    PublishStatusUpdate: (_pubSub: unknown, update: { sessionId: string; ownerUserId: string; message: string | undefined }) => {
+        statusUpdates.push(update);
+    },
+    // Mirrors the real StatusUpdateOwnerKey/StatusUpdateOwnerID (#4931): the elevated principal's
+    // key when the payload stands in for one, else the request user's. Anonymous visitors key on
+    // `id|scope`; these relay cases are all named users, so the ID is the whole key.
+    StatusUpdateOwnerKey: (user: { ID?: string } | null | undefined) => user?.ID ?? '',
+    StatusUpdateOwnerID: (payload: { ElevatedFrom?: { ID?: string }; userRecord?: { ID?: string } } | undefined) =>
+        payload?.ElevatedFrom?.ID ?? payload?.userRecord?.ID ?? '',
+}));
+vi.mock('../generic/RunViewResolver.js', () => ({ RunViewByIDInput: class {}, RunViewByNameInput: class {}, RunDynamicViewInput: class {} }));
+vi.mock('../generic/DeleteOptionsInput.js', () => ({ DeleteOptionsInput: class {} }));
+vi.mock('../types.js', () => ({ RunViewGenericParams: class {} }));
+vi.mock('@memberjunction/core-entities', () => ({}));
+vi.mock('@memberjunction/core', async () => {
+    const actual = await vi.importActual<typeof import('@memberjunction/core')>('@memberjunction/core');
+    return { ...actual, LogError: vi.fn(), LogStatus: vi.fn(), LogDebug: vi.fn() };
+});
+
+import { BaseEntity, BaseEntityEvent, EntityInfo, UserInfo } from '@memberjunction/core';
+import { MJEventType, MJGlobal } from '@memberjunction/global';
+import type { PubSubEngine } from 'type-graphql';
+import { Subscription } from 'rxjs';
+import { ResolverBase } from '../generic/ResolverBase';
+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) {
+    const row = FullWidthEmployeeRow();
+    return {
+        EntityInfo: entityInfo,
+        ContextCurrentUser: owner,
+        GetAll: () => ({ ...row }),
+        PrimaryKey: { KeyValuePairs: [{ FieldName: 'ID', Value: row.ID }] },
+        Fields: entityInfo.Fields.map(f => ({ Name: f.Name, Dirty: false })),
+        Get: (name: string) => (row as Record<string, unknown>)[name],
+        GetDirtyFieldNames: (): string[] => [],
+    };
+}
+type OwnedEntity = ReturnType<typeof entityOwnedBy>;
+
+class TestResolver extends ResolverBase {
+    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);
+    }
+}
+
+function raise(entity: OwnedEntity, type: BaseEntityEvent['type'], payload: unknown): void {
+    const args = new BaseEntityEvent();
+    args.type = type;
+    args.payload = payload;
+    args.baseEntity = entity as unknown as BaseEntity;
+    MJGlobal.Instance.RaiseEvent({ component: null, event: MJEventType.ComponentEvent, eventCode: BaseEntity.BaseEventCode, args });
+}
+
+/** Lets the async listener run for every event raised so far. */
+async function settle(): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, 10));
+}
+
+function resetListeners(): void {
+    const store = MJGlobal.Instance.GetGlobalObjectStore();
+    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;
+let userB: UserInfo;
+
+beforeEach(() => {
+    statusUpdates.length = 0;
+    resetListeners();
+    userA = BuildUser([HR_ROLE_ID], 'user-a');
+    userB = BuildUser([HR_ROLE_ID], 'user-b');
+});
+
+describe('ResolverBase.ListenForEntityMessages: relay to the listening session', () => {
+    it("REGRESSION: never relays another user's delete to the session that created the listener", async () => {
+        const entityInfo = EmployeeEntity(false);
+        new TestResolver().Listen(entityOwnedBy(entityInfo, userA), userA);
+
+        raise(entityOwnedBy(entityInfo, userB), 'delete', { OldValues: FullWidthEmployeeRow() });
+        await settle();
+
+        expect(statusUpdates).toHaveLength(0);
+    });
+
+    it('REGRESSION: relays the session user\'s own delete with the key and type, never the deleted row', async () => {
+        const entityInfo = EmployeeEntity(false);
+        new TestResolver().Listen(entityOwnedBy(entityInfo, userA), userA);
+
+        raise(entityOwnedBy(entityInfo, userA), 'delete', { OldValues: FullWidthEmployeeRow() });
+        await settle();
+
+        expect(statusUpdates).toHaveLength(1);
+        const message = JSON.parse(statusUpdates[0].message!) as Record<string, unknown>;
+        expect(message.entityName).toBe('Employees');
+        expect(message.eventType).toBe('delete');
+        expect(message.message).toBeUndefined();
+        expect(statusUpdates[0].message).not.toContain(String(SECRET_SALARY));
+    });
+
+    it('REGRESSION: an entity under field security never relays a payload, even to its own user', async () => {
+        const entityInfo = EmployeeEntity(true);
+        new TestResolver().Listen(entityOwnedBy(entityInfo, userA), userA);
+
+        raise(entityOwnedBy(entityInfo, userA), 'other', { Salary: SECRET_SALARY });
+        await settle();
+
+        expect(statusUpdates).toHaveLength(1);
+        expect(JSON.parse(statusUpdates[0].message!).message).toBeUndefined();
+    });
+
+    it('REGRESSION: MJ: Record Changes never relays a payload', async () => {
+        const recordChanges = new EntityInfo({ ID: 'rc', Name: 'MJ: Record Changes', SchemaName: '__mj', BaseTable: 'RecordChange', BaseView: 'vwRecordChanges', Fields: [] });
+        new TestResolver().Listen(entityOwnedBy(recordChanges, userA), userA);
+
+        raise(entityOwnedBy(recordChanges, userA), 'other', { ChangesJSON: `{"Salary":${SECRET_SALARY}}` });
+        await settle();
+
+        expect(statusUpdates).toHaveLength(1);
+        expect(statusUpdates[0].message).not.toContain(String(SECRET_SALARY));
+    });
+
+    it("still relays a progress message from the session user's own object", async () => {
+        const entityInfo = EmployeeEntity(false);
+        new TestResolver().Listen(entityOwnedBy(entityInfo, userA), userA);
+
+        raise(entityOwnedBy(entityInfo, userA), 'other', 'step 2 of 5');
+        await settle();
+
+        expect(statusUpdates).toHaveLength(1);
+        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

@@ -158,7 +158,7 @@ describe('IncludeBinaryFields forwarding — batch resolver path', () => {
     it('RunViewsGeneric → RunViewsGenericInternal forwards the per-view flag to provider.RunViews', async () => {
         const { provider, runViewsCalls } = recordingProvider();
         const inputs = [
-            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true },
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true, AlternateBaseView: 'Active Vectors' },
             { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '' },
         ] as (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[];
 
@@ -167,7 +167,77 @@ describe('IncludeBinaryFields forwarding — batch resolver path', () => {
         expect(runViewsCalls).toHaveLength(1);
         expect(runViewsCalls[0]).toHaveLength(2);
         expect(runViewsCalls[0][0].IncludeBinaryFields).toBe(true);
+        expect(runViewsCalls[0][0].AlternateBaseView).toBe('Active Vectors');
         expect(runViewsCalls[0][1].IncludeBinaryFields).toBeUndefined();
+        expect(runViewsCalls[0][1].AlternateBaseView).toBeUndefined();
+    });
+
+    it('RunDynamicViewGeneric, RunViewByNameGeneric, and RunViewByIDGeneric forward AlternateBaseView to provider.RunView', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        const probe = new Probe();
+
+        await probe.RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', AlternateBaseView: 'Active Vectors' } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByNameGeneric(
+            { ViewName: 'Saved View', ExtraFilter: '', OrderBy: '', AlternateBaseView: '' } as RunViewByNameInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByIDGeneric(
+            { ViewID: 'view-1', ExtraFilter: '', OrderBy: '', AlternateBaseView: 'Draft Vectors' } as RunViewByIDInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls.map(c => c.AlternateBaseView)).toEqual(['Active Vectors', '', 'Draft Vectors']);
+    });
+});
+
+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();
     });
 });
 
@@ -279,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[];