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

package/src/__tests__/RemoteBrowserActionResolver.ownership.test.ts

@@ -0,0 +1,98 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { MJAIAgentSessionEntity } from '@memberjunction/core-entities';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator,
+        Mutation: noopDecorator,
+        Query: noopDecorator,
+        Subscription: noopDecorator,
+        ObjectType: noopDecorator,
+        InputType: noopDecorator,
+        Field: noopDecorator,
+        Arg: noopDecorator,
+        Args: noopDecorator,
+        Ctx: noopDecorator,
+        PubSub: noopDecorator,
+        Root: noopDecorator,
+        Float: class {},
+        Int: class {},
+        ID: class {},
+    };
+});
+
+vi.mock('@memberjunction/remote-browser-server', () => ({
+    NormalizeInstanceKey: (key?: string) => key,
+    RemoteBrowserEngine: { Instance: {} },
+}));
+vi.mock('@memberjunction/aiengine', () => ({ AIEngine: { Instance: { Config: vi.fn(), Prompts: [] } } }));
+vi.mock('@memberjunction/ai-prompts', async (importOriginal) => ({
+    ...(await importOriginal<typeof import('@memberjunction/ai-prompts')>()),
+    AIPromptRunner: class {},
+}));
+vi.mock('@memberjunction/ai-core-plus', async (importOriginal) => ({
+    ...(await importOriginal<typeof import('@memberjunction/ai-core-plus')>()),
+    AIPromptParams: class {},
+}));
+
+import { RemoteBrowserActionResolver } from '../resolvers/RemoteBrowserActionResolver.js';
+
+const uuid = (a: string, b: string) =>
+    [a.repeat(8), b.repeat(4), '4' + b.repeat(3), '8' + b.repeat(3), b.repeat(12)].join('-');
+const ANON = uuid('A', '0');
+const SESSION = uuid('1', '1');
+const CONVERSATION = uuid('2', '2');
+
+const guest = (visitorId: string) =>
+    ({
+        ID: ANON,
+        IsMagicLinkAnonymous: true,
+        // An unscoped multi-use invite: redemptions are told apart by mj_sid (a resource scope would be shared).
+        AnonymousVisitorID: visitorId,
+    }) as unknown as UserInfo;
+
+function makeProvider(sessionFound = true, externalId = 'visitor-1'): IMetadataProvider {
+    return {
+        GetEntityObject: vi.fn(async (entityName: string) =>
+            entityName === 'MJ: AI Agent Sessions'
+                ? { ID: SESSION, UserID: ANON, ConversationID: CONVERSATION, Load: vi.fn(async () => sessionFound) }
+                : { ExternalID: externalId, Load: vi.fn(async () => true) },
+        ),
+    } as unknown as IMetadataProvider;
+}
+
+class TestableRemoteBrowserResolver extends RemoteBrowserActionResolver {
+    public async LoadOwned(
+        agentSessionID: string,
+        contextUser: UserInfo,
+        provider: IMetadataProvider,
+    ): Promise<MJAIAgentSessionEntity> {
+        return this.loadOwnedSession(agentSessionID, contextUser, provider);
+    }
+}
+
+describe('RemoteBrowserActionResolver.loadOwnedSession anonymous visitor ownership', () => {
+    it('allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new TestableRemoteBrowserResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        const loaded = await resolver.LoadOwned(SESSION, guest('visitor-1'), provider);
+        expect(loaded.ID).toBe(SESSION);
+
+        await expect(resolver.LoadOwned(SESSION, guest('visitor-2'), provider)).rejects.toThrow(
+            `Not authorized: remote-browser session ${SESSION} is not owned by you.`,
+        );
+    });
+
+    it('throws the expected not-found message when the session does not exist', async () => {
+        const resolver = new TestableRemoteBrowserResolver();
+        const provider = makeProvider(false);
+
+        await expect(resolver.LoadOwned(SESSION, guest('visitor-1'), provider)).rejects.toThrow(
+            `Remote-browser session ${SESSION} not found.`,
+        );
+    });
+});

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

@@ -1,6 +1,6 @@
 // Reflect.metadata polyfill at import time.
 import 'reflect-metadata';
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { BaseEntity, EntityFieldTSType, EntityInfo, UserInfo, type EntityFieldInfo, type IMetadataProvider } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 
@@ -97,6 +97,11 @@ describe('ResolverBase.MustLoadTruthFromDatabase & hasCompleteOldValues', () =>
         expect(probe.MustLoad({ Name: ' mj: conversation details ', TrackRecordChanges: false }, true)).toBe(true);
     });
 
+    it("always loads a conversation and an agent session, so client OldValues cannot hide a change to the anonymous ownership key (#4931)", () => {
+        expect(probe.MustLoad({ Name: 'MJ: Conversations', TrackRecordChanges: false }, true)).toBe(true);
+        expect(probe.MustLoad({ Name: 'MJ: AI Agent Sessions', TrackRecordChanges: false }, true)).toBe(true);
+    });
+
     it('still trusts OldValues on other untracked entities without field security when OldValues___ covers all writable fields', () => {
         const fields = buildTagEntityFields();
         const completeOldValues = [
@@ -149,15 +154,16 @@ describe('ResolverBase.TestAndSetClientOldValuesToDBValues — partial delta Upd
         EntityFields: buildTagEntityFields(),
     });
 
-    function createLoadedTagEntity(errorLogSaves: Array<Record<string, unknown>> = []): { entity: BaseEntity; user: UserInfo } {
+    function createLoadedTagEntity(errorLogSaves: Array<Record<string, unknown>> = [], failSaveWith?: string): { entity: BaseEntity; user: UserInfo } {
         const fakeProvider = {
             Entities: [tagEntityInfo],
             GetEntityObject: async () => {
                 const errEntity: Record<string, unknown> = {
                     Save: async () => {
                         errorLogSaves.push({ ...errEntity });
-                        return true;
+                        return failSaveWith === undefined;
                     },
+                    LatestResult: failSaveWith === undefined ? null : { CompleteMessage: failSaveWith },
                 };
                 return errEntity;
             },
@@ -222,12 +228,39 @@ describe('ResolverBase.TestAndSetClientOldValuesToDBValues — partial delta Upd
 
         // Warning is logged to ErrorLog, and save still applies the new value
         expect(errorLogSaves).toHaveLength(1);
-        expect(errorLogSaves[0].Code).toBe('ENTITY_SAVE_INCONSISTENCY');
+        expect(errorLogSaves[0].Code).toBe('SAVE_INCONSISTENCY');
+        // ErrorLog.Code is NCHAR(20)
+        expect(String(errorLogSaves[0].Code).length).toBeLessThanOrEqual(20);
         expect(String(errorLogSaves[0].Message)).toContain('Display_Name');
         expect(entity.Get('Display Name')).toBe('Client New Display');
         expect(entity.Get('Description')).toBe('Untouched DB Description');
     });
 
+    it('reports the entity name and the reason when the ErrorLog save fails', async () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const { entity, user } = createLoadedTagEntity([], 'value too long for Code');
+        try {
+            await probe.TestAndSet(
+                entity,
+                {
+                    ID: '11111111-2222-3333-4444-555555555555',
+                    Display_Name: 'Client New Display',
+                    OldValues___: [
+                        { Key: 'ID', Value: '11111111-2222-3333-4444-555555555555' },
+                        { Key: 'Display_Name', Value: 'Stale Client Display' },
+                    ],
+                },
+                user
+            );
+            const message = errorSpy.mock.calls.map((c) => String(c[0])).join('\n');
+            expect(message).toContain('Failed to save ErrorLog record');
+            expect(message).toContain('value too long for Code');
+            expect(message).toContain(entity.EntityInfo.Name);
+        } finally {
+            errorSpy.mockRestore();
+        }
+    });
+
     it('does not false-positive when a non-overlapping field differs in the DB', async () => {
         const errorLogSaves: Array<Record<string, unknown>> = [];
         const { entity, user } = createLoadedTagEntity(errorLogSaves);

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

@@ -0,0 +1,52 @@
+/**
+ * The GraphQL delete returns the record's last state. It is projected for the caller, so an
+ * entity object that holds a full-width row (loaded as another user, or not narrowed at its
+ * source) never hands the caller a value they are denied.
+ */
+import 'reflect-metadata';
+import { describe, it, expect } from 'vitest';
+import type { UserInfo } from '@memberjunction/core';
+import { EmployeeEntity, FullWidthEmployeeRow, HRUser, Intern, SECRET_SALARY } from './fieldSecurityFixtures.js';
+
+/** Drives the real `ResolverBase.DeleteRecord` with its unrelated collaborators stubbed on the instance. */
+async function deleteAs(user: UserInfo): Promise<Record<string, unknown>> {
+    const { ResolverBase } = await import('../generic/ResolverBase.js');
+    const entityObject = {
+        EntityInfo: EmployeeEntity(true),
+        InnerLoad: async () => true,
+        GetAll: () => FullWidthEmployeeRow(),
+        Delete: async () => true,
+        LatestResult: { Message: '' },
+    };
+    const provider = { GetEntityObject: async () => entityObject, Entities: [] };
+    const resolver = Object.create(ResolverBase.prototype) as Record<string, unknown> & {
+        DeleteRecord: (...args: unknown[]) => Promise<Record<string, unknown>>;
+    };
+    resolver.CheckAPIKeyScopeAuthorization = async () => undefined;
+    resolver.BeforeDelete = async () => true;
+    resolver.AfterDelete = async () => undefined;
+    resolver.ListenForEntityMessages = () => undefined;
+    resolver.GetUserFromPayload = () => user;
+    return resolver.DeleteRecord(
+        'Employees',
+        { KeyValuePairs: [{ FieldName: 'ID', Value: 'emp-1' }] },
+        {},
+        provider,
+        { email: 'x@example.test', userRecord: user },
+        { publish: async () => undefined },
+    );
+}
+
+describe('ResolverBase.DeleteRecord: the returned last state is projected for the caller', () => {
+    it('REGRESSION: returns no denied value even when the entity object holds the full row', async () => {
+        const returned = await deleteAs(Intern());
+        expect(returned).not.toHaveProperty('Salary');
+        expect(JSON.stringify(returned)).not.toContain(String(SECRET_SALARY));
+        expect(returned.ID).toBe('emp-1');
+    });
+
+    it('returns every value to a caller who is denied nothing', async () => {
+        const returned = await deleteAs(HRUser());
+        expect(returned.Salary).toBe(SECRET_SALARY);
+    });
+});

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

@@ -0,0 +1,176 @@
+/**
+ * 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';
+
+/** 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 Listen(entity: OwnedEntity, sessionUser: UserInfo) {
+        this.ListenForEntityMessages(entity as unknown as BaseEntity, {} as PubSubEngine, { sessionId: 'session-a', 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();
+}
+
+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');
+    });
+});

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,29 @@ 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']);
     });
 });
 

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

@@ -0,0 +1,68 @@
+// ResolverBase transitively pulls in type-graphql decorators, which need the
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import type { PubSubEngine } from 'type-graphql';
+import { UserInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { PUSH_STATUS_UPDATES_TOPIC, StatusUpdateOwnerID } from '../generic/PushStatusResolver.js';
+import type { UserPayload } from '../types.js';
+
+/**
+ * `ResolverBase.PublishStatusUpdate` stamps the owner the caller's socket is authenticated as. For a widget guest
+ * whose run is elevated to the system user, that is the guest's owner key: a push stamped with the elevated user's ID
+ * never passes the subscription filter on the guest's socket.
+ */
+
+const ANONYMOUS_USER_ID = 'AAAAAAAA-0000-4000-8000-0000000000A0';
+const SYSTEM_USER_ID = 'BBBBBBBB-0000-4000-8000-0000000000B0';
+
+/** Reaches the protected publish wrapper. */
+class Probe extends ResolverBase {
+    public Publish(pubSub: PubSubEngine, userPayload: UserPayload): void {
+        this.PublishStatusUpdate(pubSub, 'session-1', 'progress', userPayload);
+    }
+}
+
+function elevatedGuestPayload(): UserPayload {
+    const guest = new UserInfo(null, { ID: ANONYMOUS_USER_ID, Email: 'anonymous@magic-link.local' });
+    guest.IsMagicLinkAnonymous = true;
+    guest.AnonymousVisitorID = 'sid-guest-1';
+    return {
+        sessionId: 'session-1',
+        email: 'system@example.com',
+        userRecord: new UserInfo(null, { ID: SYSTEM_USER_ID, Email: 'system@example.com' }),
+        ElevatedFrom: guest,
+    };
+}
+
+describe('ResolverBase.PublishStatusUpdate — the owner it stamps', () => {
+    it("stamps an elevated widget guest's own owner key, not the system user it was elevated to", () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub: PubSubEngine = { publish, subscribe: vi.fn(), unsubscribe: vi.fn(), asyncIterator: vi.fn() };
+        const userPayload = elevatedGuestPayload();
+
+        new Probe().Publish(pubSub, userPayload);
+
+        expect(publish).toHaveBeenCalledOnce();
+        expect(publish.mock.calls[0][0]).toBe(PUSH_STATUS_UPDATES_TOPIC);
+        const payload = publish.mock.calls[0][1] as { sessionId: string; ownerUserId: string; message: string };
+        expect(payload).toMatchObject({ sessionId: 'session-1', message: 'progress' });
+        expect(payload.ownerUserId).toBe(StatusUpdateOwnerID(userPayload));
+        expect(payload.ownerUserId).toBe(`${ANONYMOUS_USER_ID.toLowerCase()}|sid-guest-1`);
+    });
+
+    it('stamps a signed-in user with their user ID', () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub: PubSubEngine = { publish, subscribe: vi.fn(), unsubscribe: vi.fn(), asyncIterator: vi.fn() };
+        const userPayload: UserPayload = {
+            sessionId: 'session-1',
+            email: 'user@example.com',
+            userRecord: new UserInfo(null, { ID: 'CCCCCCCC-0000-4000-8000-0000000000C0', Email: 'user@example.com' }),
+        };
+
+        new Probe().Publish(pubSub, userPayload);
+
+        expect((publish.mock.calls[0][1] as { ownerUserId: string }).ownerUserId).toBe('CCCCCCCC-0000-4000-8000-0000000000C0');
+    });
+});

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

@@ -0,0 +1,130 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { UserViewEngine } from '@memberjunction/core-entities';
+import type { MJUserViewEntityExtended } from '@memberjunction/core-entities';
+import { RunView } from '@memberjunction/core';
+import type { IMetadataProvider, IRunViewProvider, RunViewParams, UserInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { RunViewResolver, RunViewByNameInput, RunViewByIDInput } from '../generic/RunViewResolver.js';
+
+class UserViewProbe extends ResolverBase {
+    public async TestRunViewByID(
+        viewInput: RunViewByIDInput,
+        provider: IMetadataProvider,
+        userPayload: { userRecord: UserInfo; email: string }
+    ) {
+        return this.RunViewByIDGeneric(viewInput, provider, userPayload as never);
+    }
+
+    public async TestRunViewByName(
+        viewInput: RunViewByNameInput,
+        provider: IMetadataProvider,
+        userPayload: { userRecord: UserInfo; email: string }
+    ) {
+        return this.RunViewByNameGeneric(viewInput, provider, userPayload as never);
+    }
+}
+
+describe('ResolverBase & RunViewResolver UserViewEngine cache and ViewEntity forwarding (MJ-CORE-9)', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('resolves MJ: User Views from UserViewEngine cache first, forwards ViewEntity into RunViewParams, and reuses _resolvedViewEntity in RunViewResolver', async () => {
+        const mockViewEntity = {
+            ID: 'view-123',
+            Name: 'Active Widgets',
+            EntityID: 'entity-widgets',
+            Entity: 'Widgets',
+            WhereClause: 'Status = 1',
+            GridState: null,
+            SortState: null,
+        } as unknown as MJUserViewEntityExtended;
+
+        vi.spyOn(UserViewEngine.Instance, 'Loaded', 'get').mockReturnValue(true);
+        const getViewByIdSpy = vi.spyOn(UserViewEngine.Instance, 'GetViewById').mockReturnValue(mockViewEntity);
+        const getViewByNameSpy = vi.spyOn(UserViewEngine.Instance, 'GetViewByName').mockReturnValue(mockViewEntity);
+
+        const capturedRunViewParams: RunViewParams[] = [];
+        const providerRunViewSpy = vi.fn().mockImplementation(async (params: RunViewParams) => {
+            capturedRunViewParams.push(params);
+            return {
+                Success: true,
+                Results: [{ ID: 'w-1', Name: 'Widget A' }],
+                RowCount: 1,
+                TotalRowCount: 1,
+                ExecutionTime: 2,
+                ErrorMessage: '',
+                UserViewRunID: '',
+            };
+        });
+        const fakeProvider = {
+            Entities: [
+                {
+                    ID: 'entity-widgets',
+                    Name: 'Widgets',
+                    PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                    Fields: [
+                        { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                        { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    ],
+                    EncryptedFields: [],
+                },
+            ],
+            EntityByName: () => ({
+                ID: 'entity-widgets',
+                Name: 'Widgets',
+                PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                Fields: [
+                    { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                ],
+                EncryptedFields: [],
+            }),
+            EntityByID: () => ({
+                ID: 'entity-widgets',
+                Name: 'Widgets',
+                PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                Fields: [
+                    { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                ],
+                EncryptedFields: [],
+            }),
+            RunView: providerRunViewSpy,
+        } as unknown as IMetadataProvider & IRunViewProvider;
+
+        const userPayload = {
+            email: 'tester@example.com',
+            userRecord: { ID: 'u-1', Email: 'tester@example.com' } as unknown as UserInfo,
+        };
+
+        const resolver = new RunViewResolver();
+        const findBySpy = vi.spyOn(
+            resolver as unknown as { findBy: (...args: unknown[]) => Promise<unknown> },
+            'findBy'
+        );
+
+        const byIdResult = await resolver.RunViewByID(
+            { ViewID: 'view-123' } as RunViewByIDInput,
+            { providers: [{ provider: fakeProvider, type: 'Read-Only' }], userPayload } as never
+        );
+
+        expect(getViewByIdSpy).toHaveBeenCalledWith('view-123');
+        expect(findBySpy).not.toHaveBeenCalled();
+        expect(capturedRunViewParams).toHaveLength(1);
+        expect(capturedRunViewParams[0].ViewEntity).toBe(mockViewEntity);
+        expect(byIdResult?.Results).toHaveLength(1);
+
+        const byNameResult = await resolver.RunViewByName(
+            { ViewName: 'Active Widgets' } as RunViewByNameInput,
+            { providers: [{ provider: fakeProvider, type: 'Read-Only' }], userPayload } as never
+        );
+
+        expect(getViewByNameSpy).toHaveBeenCalledWith('Active Widgets');
+        expect(findBySpy).not.toHaveBeenCalled();
+        expect(capturedRunViewParams).toHaveLength(2);
+        expect(capturedRunViewParams[1].ViewEntity).toBe(mockViewEntity);
+        expect(byNameResult?.Results).toHaveLength(1);
+    });
+});