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

package/src/__tests__/SyncRolesUsersResolver.userRoles.test.ts

@@ -0,0 +1,97 @@
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { runViewResults } = vi.hoisted(() => ({
+    runViewResults: new Map<string, unknown[]>(),
+}));
+
+// vitest's esbuild transform does not apply `emitDecoratorMetadata`, so the decorators are no-ops
+// and the resolver runs as a plain class.
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, ObjectType: noopDecorator,
+        InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator, Ctx: noopDecorator,
+        Directive: noopDecorator, registerEnumType: () => undefined,
+    };
+});
+
+vi.mock('../directives/RequireSystemUser.js', () => ({ RequireSystemUser: () => () => undefined }));
+vi.mock('../util.js', () => ({ GetReadWriteProvider: () => undefined }));
+vi.mock('@memberjunction/generic-database-provider', () => ({ UserCache: { Instance: {} } }));
+
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>();
+    return {
+        ...actual,
+        RunView: class {
+            async RunView(params: { EntityName: string }) {
+                return { Success: true, Results: runViewResults.get(params.EntityName) ?? [] };
+            }
+        },
+    };
+});
+
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { SyncRolesAndUsersResolver, type UserInputType } from '../resolvers/SyncRolesUsersResolver.js';
+import type { UserPayload } from '../types.js';
+
+/** Exposes the protected step under test. */
+class TestResolver extends SyncRolesAndUsersResolver {
+    public Sync(users: UserInputType[], provider: IMetadataProvider) {
+        return this.SyncUserRoles(users, {} as UserInfo, {} as UserPayload, provider);
+    }
+}
+
+const ALICE = 'aaaaaaaa-0000-0000-0000-000000000001';
+const BOB = 'bbbbbbbb-0000-0000-0000-000000000002';
+const ADMIN = 'cccccccc-0000-0000-0000-000000000003';
+const EDITOR = 'dddddddd-0000-0000-0000-000000000004';
+const UI = 'eeeeeeee-0000-0000-0000-000000000005';
+
+const deleted: string[] = [];
+const created: Array<{ UserID: string; RoleID: string }> = [];
+
+function userRole(ID: string, UserID: string, RoleID: string, Role: string) {
+    return { ID, UserID, RoleID, Role, Delete: vi.fn(async () => { deleted.push(ID); return true; }) };
+}
+
+const provider = {
+    GetEntityObject: async () => {
+        const row = { UserID: '', RoleID: '', Save: async () => { created.push({ UserID: row.UserID, RoleID: row.RoleID }); return true; } };
+        return row;
+    },
+} as unknown as IMetadataProvider;
+
+const input = (Email: string, roles: string[]) => ({ Email, Roles: roles.map(Name => ({ Name })) }) as unknown as UserInputType;
+
+beforeEach(() => {
+    deleted.length = 0;
+    created.length = 0;
+    runViewResults.set('MJ: Users', [{ ID: ALICE, Email: 'Alice@Example.com' }, { ID: BOB, Email: 'bob@example.com' }]);
+    runViewResults.set('MJ: Roles', [{ ID: ADMIN.toUpperCase(), Name: 'Admin' }, { ID: EDITOR, Name: 'Editor' }, { ID: UI, Name: 'UI' }]);
+    runViewResults.set('MJ: User Roles', [
+        userRole('alice-editor', ALICE.toUpperCase(), EDITOR.toUpperCase(), 'Editor'),
+        userRole('alice-ui', ALICE, UI, 'UI'),
+        userRole('bob-admin', BOB, ADMIN, 'Admin'),
+    ]);
+});
+
+describe('SyncRolesAndUsersResolver.SyncUserRoles', () => {
+    it('adds missing assignments and removes dropped ones, matching IDs in any case', async () => {
+        await new TestResolver().Sync([
+            input(' alice@example.com ', ['Admin', ' editor ', 'Ghost']),
+            input('bob@example.com', []),
+            input('carol@example.com', ['Admin']),
+        ], provider);
+
+        // Alice gains Admin; Editor already exists under an upper-case UserID/RoleID; Ghost is not a role.
+        expect(created).toEqual([{ UserID: ALICE, RoleID: ADMIN.toUpperCase() }]);
+        // Bob loses Admin. Alice keeps Editor (still requested) and UI (a standard role is never removed).
+        // Carol is not a database user, so nothing happens for her.
+        expect(deleted).toEqual(['bob-admin']);
+    });
+});

package/src/__tests__/TaskGraphActionRunner.durablePayload.test.ts

@@ -169,4 +169,29 @@ describe('TaskGraphActionRunner: outputs must be storable', () => {
 
         expect(result).toMatchObject({ Success: true, Output: { AgentRunID: 'RUN-1' }, ActionLogID: 'LOG-2' });
     });
+
+    it('merges structured JSON Message properties into Output and aliases handle/Handle', async () => {
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: JSON.stringify({
+                message: 'Created new PDF document.',
+                handle: 'doc-handle-99',
+                documentType: 'pdf',
+                fileName: 'Sales_Demo_Report.pdf',
+            }),
+            Params: [],
+            LogEntry: { ID: 'LOG-3' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({ DocumentType: 'pdf' }));
+
+        expect(result.Success).toBe(true);
+        expect(result.Output).toMatchObject({
+            handle: 'doc-handle-99',
+            Handle: 'doc-handle-99',
+            documentType: 'pdf',
+            fileName: 'Sales_Demo_Report.pdf',
+        });
+    });
 });
+

package/src/__tests__/TaskGraphAgentRunner.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Tests for `TaskGraphAgentRunner`.
+ *
+ * Verifies that when a task node in a durable task graph executes a specialist agent
+ * (such as Query Builder or Research Report Writer) and finishes with a payload,
+ * the runner resolves the originating `ConversationDetailID` and persists artifacts
+ * via `AgentRunner.ProcessAgentArtifacts`.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@memberjunction/core', () => ({
+    LogError: vi.fn(),
+    LogStatus: vi.fn(),
+}));
+
+vi.mock('@memberjunction/generic-database-provider', () => ({
+    UserCache: {
+        Instance: { Users: [] },
+        Users: [],
+    },
+}));
+
+vi.mock('@memberjunction/core-entities', () => ({
+    MJTaskEntity: class {},
+}));
+
+vi.mock('@memberjunction/ai-core-plus', () => ({
+    MJAIAgentEntityExtended: class {},
+    MJAIAgentRunEntityExtended: class {},
+}));
+vi.mock('@memberjunction/ai', () => ({ ChatMessageRole: { user: 'user' } }));
+
+const { runAgent, processAgentArtifacts, canUserRunAgent, mockEngineAgents } = vi.hoisted(() => ({
+    runAgent: vi.fn(),
+    processAgentArtifacts: vi.fn(),
+    canUserRunAgent: vi.fn().mockResolvedValue(true),
+    mockEngineAgents: [{ ID: 'qb-agent' }, { ID: 'writer-agent' }] as Array<{ ID: string }>,
+}));
+vi.mock('@memberjunction/ai-agents', () => ({
+    AgentRunner: class {
+        RunAgent = runAgent;
+        ProcessAgentArtifacts = processAgentArtifacts;
+    },
+}));
+vi.mock('@memberjunction/aiengine', () => ({
+    AIEngine: {
+        get Instance() {
+            return {
+                Agents: mockEngineAgents,
+                CanUserRunAgent: canUserRunAgent,
+            };
+        },
+    },
+}));
+
+import { TaskGraphAgentRunner } from '../services/TaskGraphAgentRunner';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+describe('TaskGraphAgentRunner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: { queryName: 'Top Users', sql: 'SELECT TOP 10 * FROM Users' },
+            agentRun: { ID: 'step-run-1', Message: 'Built Top Users query' },
+        });
+        processAgentArtifacts.mockResolvedValue(undefined);
+    });
+
+    it('resolves ConversationDetailID from the submitting parent run and persists specialist agent artifacts', async () => {
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Query Builder', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: AI Agent Runs') {
+                    return {
+                        ID: 'parent-run-1',
+                        ConversationID: 'conv-1',
+                        ConversationDetailID: 'origin-detail-1',
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: 'parent-run-1',
+            InputPayload: { goal: 'Top 10 users' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(outcome.AgentRunID).toBe('step-run-1');
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        expect(runAgent.mock.calls[0][0].inputArtifacts).toEqual([]);
+        expect(processAgentArtifacts).toHaveBeenCalledTimes(1);
+        expect(processAgentArtifacts.mock.calls[0][0].artifactDirective?.behavior).toBe('create-new');
+        expect(processAgentArtifacts.mock.calls[0][1]).toBe('origin-detail-1');
+    });
+
+    it('falls back to resolving ConversationDetailID from the task hierarchy when SubmittingAgentRunID has none', async () => {
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'writer-agent', Name: 'Research Report Writer', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: Tasks') {
+                    return {
+                        ID: 'task-step-2',
+                        ConversationDetailID: 'task-detail-2',
+                        ParentID: 'parent-task-1',
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-2',
+            AgentID: 'writer-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: { topic: 'Executive summary' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(processAgentArtifacts).toHaveBeenCalledTimes(1);
+        expect(processAgentArtifacts.mock.calls[0][0].artifactDirective?.behavior).toBe('create-new');
+        expect(processAgentArtifacts.mock.calls[0][1]).toBe('task-detail-2');
+    });
+
+    it('refuses execution when the acting user lacks run permission on the target agent', async () => {
+        canUserRunAgent.mockResolvedValue(false);
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'restricted-agent', Name: 'Restricted Agent', Load: vi.fn().mockResolvedValue(true) };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-restricted',
+            AgentID: 'restricted-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: {},
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-no-perm' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(false);
+        expect(outcome.ErrorMessage).toContain('User does not have permission to run agent "Restricted Agent"');
+        expect(runAgent).not.toHaveBeenCalled();
+    });
+
+    it('includes task Name and Description in prompt and preserves agentRun.Message when object payload lacks message/summary', async () => {
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: {},
+            agentRun: {
+                ID: 'fb-run-1',
+                Message: 'Which entity would you like me to customize a form for?',
+                FinalStep: 'Chat',
+            },
+        });
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Form Builder', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: Tasks') {
+                    return {
+                        ID: 'task-fb-1',
+                        Name: 'Customize Orders Form',
+                        Description: 'Add a collapsible Customer Details section to the Orders form.',
+                        ConversationDetailID: 'detail-fb-1',
+                        ParentID: null,
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-fb-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: { entityName: 'Orders' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        const promptSent = runAgent.mock.calls[0][0].conversationMessages[0].content as string;
+        expect(promptSent).toContain('## Task: Customize Orders Form');
+        expect(promptSent).toContain('Add a collapsible Customer Details section to the Orders form.');
+        expect(outcome.Output).toEqual({
+            message: 'Which entity would you like me to customize a form for?',
+            finalStep: 'Chat',
+        });
+    });
+
+    it('normalizes results/result, lifts nested results fields to top level, and populates succeeded on completed agent steps', async () => {
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: {
+                code: 'output = { totalSales: 2703745, summary: "Sales exceeded $1M" };',
+                results: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+                iterations: 1,
+            },
+            agentRun: {
+                ID: 'cs-run-1',
+                Message: 'Calculated total sales across 19 quarters.',
+                FinalStep: 'Success',
+            },
+        });
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Codesmith Agent', Load: vi.fn().mockResolvedValue(true) };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-cs-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: {},
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(outcome.Output).toMatchObject({
+            totalSales: 2703745,
+            summary: 'Sales exceeded $1M',
+            results: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+            result: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+            succeeded: true,
+        });
+    });
+});
+