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

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

@@ -0,0 +1,52 @@
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect } from 'vitest';
+import { EntityFieldTSType, type EntityFieldInfo, type EntityInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+
+/**
+ * Client old values arrive as strings, with dates as epoch milliseconds (the GraphQL Timestamp form).
+ * Loading them as-is made an unchanged date field an Invalid Date, so it read as edited: a
+ * Comments-only update to an MJ: Record Changes row was refused for "changing" ChangedAt.
+ */
+class Probe extends ResolverBase {
+    public Convert(field: Partial<EntityFieldInfo>, raw: unknown) {
+        return this.ClientOldValueToFieldValue(field as EntityFieldInfo, raw);
+    }
+    public MustLoad(entity: Partial<EntityInfo>, oldValues: boolean) {
+        return this.MustLoadTruthFromDatabase(entity as EntityInfo, { OldValues___: oldValues ? [{ Key: 'Comments', Value: null }] : undefined }, false, false);
+    }
+}
+const probe = new Probe();
+const dateField = { Name: 'ChangedAt', TSType: EntityFieldTSType.Date, Type: 'datetimeoffset', AllowsNull: false, DefaultValue: 'getutcdate()' };
+
+describe('ResolverBase.ClientOldValueToFieldValue', () => {
+    it('reads an epoch-milliseconds string as the same instant', () => {
+        const value = probe.Convert(dateField, '1790365634563') as Date;
+        expect(value).toBeInstanceOf(Date);
+        expect(value.getTime()).toBe(1790365634563);
+    });
+
+    it('reads an ISO date string too, and keeps null as null for a nullable date', () => {
+        expect((probe.Convert(dateField, '2026-09-25T19:47:14.563Z') as Date).toISOString()).toBe('2026-09-25T19:47:14.563Z');
+        expect(probe.Convert({ ...dateField, AllowsNull: true, DefaultValue: null }, null)).toBeNull();
+    });
+
+    it('types numbers and booleans like the field', () => {
+        expect(probe.Convert({ Name: 'N', TSType: EntityFieldTSType.Number, Type: 'int' }, '42')).toBe(42);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit' }, 'false')).toBe(false);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit', AllowsNull: true }, null)).toBe(false);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit' }, '1')).toBe(true);
+        expect(probe.Convert({ Name: 'M', TSType: EntityFieldTSType.Number, Type: 'money' }, '1.5')).toBe(1.5);
+    });
+});
+
+describe('ResolverBase.MustLoadTruthFromDatabase', () => {
+    it('always loads a Record Change from the database, so client OldValues cannot pin forged audit columns', () => {
+        expect(probe.MustLoad({ Name: 'MJ: Record Changes', TrackRecordChanges: false }, true)).toBe(true);
+    });
+
+    it('still trusts OldValues on other untracked entities without field security', () => {
+        expect(probe.MustLoad({ Name: 'MJ: Tags', TrackRecordChanges: false, EnableFieldLevelSecurity: false }, true)).toBe(false);
+    });
+});

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

@@ -183,6 +183,16 @@ describe('loadConversationHistoryWithAttachments — history floor', () => {
     });
 });
 
+function executeArgs(conversationHistoryFrom?: Date): unknown[] {
+    const userPayload = { sessionId: 'session-1', userRecord: USER };
+    return [
+        {}, {}, 'agent-1', userPayload, '[{"role":"user","content":"hi"}]', 'session-1', pubSub,
+        undefined, undefined, undefined, undefined, undefined, undefined, 'detail-1', false, false,
+        undefined, undefined, 'conv-1', undefined, undefined, undefined, undefined,
+        conversationHistoryFrom,
+    ];
+}
+
 describe('executeAIAgent — ConversationHistoryFrom', () => {
     function wire() {
         const { resolver, seams } = makeResolver();
@@ -199,20 +209,10 @@ describe('executeAIAgent — ConversationHistoryFrom', () => {
         return execute;
     }
 
-    function positional(conversationHistoryFrom?: Date): unknown[] {
-        const userPayload = { sessionId: 'session-1', userRecord: USER };
-        return [
-            {}, {}, 'agent-1', userPayload, '[{"role":"user","content":"hi"}]', 'session-1', pubSub,
-            undefined, undefined, undefined, undefined, undefined, undefined, 'detail-1', false, false,
-            undefined, undefined, 'conv-1', undefined, undefined, undefined, undefined,
-            conversationHistoryFrom,
-        ];
-    }
-
     it('puts the floor on the run\'s params', async () => {
         const execute = wire();
         const floor = new Date(FLOOR_ISO);
-        await execute(...positional(floor));
+        await execute(...executeArgs(floor));
 
         const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
         expect(params.ConversationHistoryFrom).toBe(floor);
@@ -220,9 +220,179 @@ describe('executeAIAgent — ConversationHistoryFrom', () => {
 
     it('leaves it unset without a floor', async () => {
         const execute = wire();
-        await execute(...positional());
+        await execute(...executeArgs());
 
         const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
         expect(params.ConversationHistoryFrom).toBeUndefined();
     });
 });
+
+describe('executeAIAgent — status publishing', () => {
+    const agentRun = {
+        ID: 'run-1',
+        ConversationDetailID: 'detail-1',
+        Steps: [{ StepName: 'Answer' }],
+        GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
+    };
+
+    function envelopes(publish: ReturnType<typeof vi.fn>): Array<Record<string, unknown>> {
+        return publish.mock.calls.map((call) => JSON.parse((call[1] as { message: string }).message) as Record<string, unknown>);
+    }
+
+    it('publishes progress, streamed text, the partial result, and the completion from the runner callbacks', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        seams.persistInFlightAgentFailure = vi.fn().mockResolvedValue(undefined);
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const publish = vi.fn().mockResolvedValue(undefined);
+        (pubSub as unknown as { publish: Fn }).publish = publish;
+        hoisted.runAgentInConversation.mockReset().mockImplementation(async (params: {
+            onProgress?: (progress: { step: string; message?: string; percentage?: number; metadata?: Record<string, unknown> }) => void;
+            onStreaming?: (chunk: { content: string; isComplete: boolean; stepType?: string; kind?: string }) => void;
+        }) => {
+            params.onProgress?.({ step: 'initialization', message: 'noise', metadata: { agentRun } });
+            params.onProgress?.({
+                step: 'prompt_execution',
+                message: 'Writing',
+                percentage: 40,
+                metadata: { agentRun, agentName: 'Betty' },
+            });
+            params.onStreaming?.({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+            return {
+                agentResult: { success: true, agentRun, payload: { text: 'Hello' } },
+                agentResponseDetailId: 'detail-1',
+                conversationId: 'conv-1',
+            };
+        });
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean }>;
+        }).executeAIAgent.bind(resolver);
+
+        const result = await execute(...executeArgs());
+
+        expect(result.success).toBe(true);
+        const sent = envelopes(publish);
+        expect(sent.map((row) => (row.data as { type: string }).type)).toEqual([
+            'progress',
+            'streaming',
+            'partial_result',
+            'complete',
+        ]);
+        expect(sent[0].type).toBe('ExecutionProgress');
+        expect(sent[0].resolver).toBe('RunAIAgentResolver');
+        expect((sent[1].data as { streaming: { content: string } }).streaming.content).toBe('Hel');
+        const completion = sent[3].data as { conversationDetailId: string; agentRunId: string; success: boolean };
+        expect(completion.conversationDetailId).toBe('detail-1');
+        expect(completion.agentRunId).toBe('run-1');
+        expect(completion.success).toBe(true);
+    });
+
+    it('publishes a failure completion when a fire-and-forget run rejects', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.executeAIAgent = vi.fn().mockRejectedValue(new Error('background blew up'));
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const localPubSub = { publish } as unknown as PubSubEngine;
+        const userPayload = { sessionId: 'session-1', userRecord: USER };
+        const runInBackground = (resolver as unknown as {
+            executeAgentInBackground(...args: unknown[]): void;
+        }).executeAgentInBackground.bind(resolver);
+
+        runInBackground(
+            {}, {}, 'agent-1', userPayload, '[]', 'session-1', localPubSub,
+            undefined, undefined, undefined, undefined, undefined, 'detail-1',
+        );
+        await vi.waitFor(() => expect(publish).toHaveBeenCalled());
+
+        const sent = envelopes(publish);
+        expect(sent).toHaveLength(1);
+        expect(sent[0].type).toBe('StreamingContent');
+        expect(sent[0].resolver).toBe('RunAIAgentResolver');
+        const completion = sent[0].data as {
+            type: string;
+            agentRunId: string;
+            conversationDetailId: string;
+            success: boolean;
+            errorMessage: string;
+            result: string;
+        };
+        expect(completion).toMatchObject({
+            type: 'complete',
+            agentRunId: 'unknown',
+            conversationDetailId: 'detail-1',
+            success: false,
+            errorMessage: 'background blew up',
+            result: JSON.stringify({ success: false, errorMessage: 'background blew up' }),
+        });
+    });
+
+    it('saves a Running run reported by progress as Failed when the agent throws', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const runningRun = {
+            ID: 'run-1',
+            Status: 'Running',
+            ErrorMessage: '',
+            CompletedAt: null as Date | null,
+            EnsureSaveComplete: vi.fn().mockResolvedValue(undefined),
+            Save: vi.fn().mockResolvedValue(true),
+        };
+        const detail = {
+            Status: 'Complete',
+            Load: vi.fn().mockResolvedValue(true),
+            Save: vi.fn().mockResolvedValue(true),
+        };
+        const provider = { GetEntityObject: vi.fn().mockResolvedValue(detail) };
+        hoisted.runAgentInConversation.mockReset().mockImplementation(async (params: {
+            onProgress?: (progress: { step: string; metadata?: Record<string, unknown> }) => void;
+        }) => {
+            params.onProgress?.({ step: 'prompt_execution', metadata: { agentRun: runningRun } });
+            throw new Error('agent threw mid-run');
+        });
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean; errorMessage?: string }>;
+        }).executeAIAgent.bind(resolver);
+        const args = executeArgs();
+        args[0] = provider;
+
+        const result = await execute(...args);
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toBe('agent threw mid-run');
+        expect(runningRun.Status).toBe('Failed');
+        expect(runningRun.ErrorMessage).toBe('agent threw mid-run');
+        expect(runningRun.CompletedAt).toBeInstanceOf(Date);
+        expect(runningRun.EnsureSaveComplete).toHaveBeenCalled();
+        expect(runningRun.Save).toHaveBeenCalled();
+        expect(detail.Save).not.toHaveBeenCalled();
+    });
+});
+
+describe('persistInFlightAgentFailure — a refused conversation-detail save logs the reason (MJ#4791)', () => {
+    it('includes LatestResult.CompleteMessage when the Error-status save is refused', async () => {
+        const { resolver } = makeResolver();
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = {
+            Status: 'In-Progress',
+            LatestResult: { CompleteMessage: 'You do not have access to this conversation.' },
+            Load: vi.fn().mockResolvedValue(true),
+            EnsureSaveComplete: vi.fn().mockResolvedValue(undefined),
+            Save: vi.fn().mockResolvedValue(false),
+        };
+        const provider = { GetEntityObject: vi.fn().mockResolvedValue(detail) };
+        const persist = (resolver as unknown as {
+            persistInFlightAgentFailure(...args: unknown[]): Promise<void>;
+        }).persistInFlightAgentFailure.bind(resolver);
+
+        await persist(provider, { sessionId: 'session-1', userRecord: USER }, null, 'detail-1', 'agent threw');
+
+        const lines = errSpy.mock.calls.map((call) => String(call[0]));
+        const line = lines.find((l) => l.includes('Failed to persist Error on conversation detail detail-1'));
+        expect(line).toBeDefined();
+        expect(line).toContain('You do not have access to this conversation.');
+    });
+});

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

@@ -29,31 +29,27 @@ vi.mock('type-graphql', () => {
 });
 import type { AgentExecutionStreamingCallback } from '@memberjunction/ai-core-plus';
 
-import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import { AgentRunStatusPublisher } from '../resolvers/AgentRunStatusPublisher.js';
 import type { UserPayload } from '../types.js';
 
-/** Access the private factory without widening the class's public API. */
-interface StreamingCallbackFactory {
-    createStreamingCallback(
-        pubSub: PubSubEngine,
-        sessionId: string,
-        userPayload: UserPayload,
-        agentRunRef: { current: unknown }
-    ): AgentExecutionStreamingCallback;
-}
+const agentRun = {
+    ID: 'run-1',
+    GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
+};
 
 function buildHarness() {
     const publish = vi.fn().mockResolvedValue(undefined);
     const pubSub = { publish } as unknown as PubSubEngine;
-    const userPayload = { sessionId: 'session-1' } as UserPayload;
-    const agentRunRef = {
-        current: {
-            ID: 'run-1',
-            GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
-        },
-    };
-    const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
-    const callback = resolver.createStreamingCallback(pubSub, 'session-1', userPayload, agentRunRef);
+    const userPayload = { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload;
+    const publisher = new AgentRunStatusPublisher(pubSub, userPayload, 'session-1');
+    // A progress event, even a noise step, is how the publisher learns the run.
+    publisher.OnProgress({
+        step: 'initialization',
+        message: 'starting',
+        metadata: { agentRun },
+    });
+    publish.mockClear();
+    const callback: AgentExecutionStreamingCallback = publisher.OnStreaming;
     return { publish, callback };
 }
 
@@ -67,7 +63,7 @@ function publishedData(publish: ReturnType<typeof vi.fn>): Record<string, unknow
     return parsed.data as Record<string, unknown>;
 }
 
-describe('RunAIAgentResolver.createStreamingCallback', () => {
+describe('AgentRunStatusPublisher streaming wire shape', () => {
     it('publishes the streaming wire shape the conversation client parses', () => {
         const { publish, callback } = buildHarness();
 
@@ -110,13 +106,8 @@ describe('RunAIAgentResolver.createStreamingCallback', () => {
     it('does not publish when no agent run is available yet', () => {
         const publish = vi.fn();
         const pubSub = { publish } as unknown as PubSubEngine;
-        const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
-        const callback = resolver.createStreamingCallback(
-            pubSub,
-            'session-1',
-            { sessionId: 'session-1' } as UserPayload,
-            { current: null }
-        );
+        const publisher = new AgentRunStatusPublisher(pubSub, { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload, 'session-1');
+        const callback = publisher.OnStreaming;
         const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
         try {
             callback({ content: 'early', isComplete: false });