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

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

@@ -82,7 +82,9 @@ describe('TaskGraphActionRunner — durable payload round-trips by param name (#
     beforeEach(() => {
         // vitest's `restoreMocks: true` clears mock implementations before every test, including
         // the ones assigned inside the `vi.mock` factory above — so the return value is (re)armed here.
+        // Call history on a vi.fn created inside vi.mock survives that restore, so clear it too.
         vi.mocked(ActionEngineServer.Instance.Config).mockResolvedValue(undefined);
+        vi.mocked(ActionEngineServer.Instance.RunAction, { partial: true }).mockClear();
         vi.mocked(ActionEngineServer.Instance.RunAction, { partial: true }).mockResolvedValue({
             Success: true,
             Params: [],
@@ -127,3 +129,44 @@ describe('TaskGraphActionRunner — durable payload round-trips by param name (#
         expect(sentParams.map((p) => p.Name).sort()).toEqual(['EntityName', 'Record']);
     });
 });
+
+/**
+ * A durable step's Output is stored on the Task row as JSON. An action that hands back an output
+ * param holding a live object (an entity, an observable) used to surface much later, from the
+ * dispatcher, as a bare "Converting circular structure to JSON" with no hint of WHICH action or
+ * param — seen live with Execute Agent's AgentResult. The runner is the boundary that knows both
+ * names, so it refuses the output there and says which param it was.
+ */
+describe('TaskGraphActionRunner: outputs must be storable', () => {
+    beforeEach(() => vi.mocked(ActionEngineServer.Instance.RunAction).mockReset());
+
+    it('fails the step, naming the action and the param, when an output param cannot be serialized', async () => {
+        const cyclic: Record<string, unknown> = { kind: 'OperatorSubscriber' };
+        cyclic.self = cyclic;
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: 'started',
+            Params: [{ Name: 'AgentRunID', Type: 'Output', Value: 'RUN-1' }, { Name: 'AgentResult', Type: 'Output', Value: cyclic }],
+            LogEntry: { ID: 'LOG-1' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({}));
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/Log Activity.*AgentResult.*cannot be stored/i);
+        expect(result.ActionLogID).toBe('LOG-1');
+    });
+
+    it('passes plain outputs through unchanged', async () => {
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: 'ok',
+            Params: [{ Name: 'AgentRunID', Type: 'Output', Value: 'RUN-1' }],
+            LogEntry: { ID: 'LOG-2' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({}));
+
+        expect(result).toMatchObject({ Success: true, Output: { AgentRunID: 'RUN-1' }, ActionLogID: 'LOG-2' });
+    });
+});

package/src/__tests__/VectorizeEntityResolver.test.ts

@@ -0,0 +1,106 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DatabaseProviderBase, UserInfo, type IMetadataProvider } from '@memberjunction/core';
+import sql from 'mssql';
+import { VectorizeEntityResolver } from '../resolvers/VectorizeEntityResolver.js';
+import type { AppContext, ProviderInfo } from '../types.js';
+
+const mockSyncerConstructedWith: (IMetadataProvider | undefined)[] = [];
+
+vi.mock('@memberjunction/ai-vector-sync', () => {
+    return {
+        EntityVectorSyncer: class {
+            constructor(provider?: IMetadataProvider) {
+                mockSyncerConstructedWith.push(provider);
+            }
+            Config() {
+                return Promise.resolve(undefined);
+            }
+            VectorizeEntity() {
+                return Promise.resolve({ success: true, status: 'Completed' });
+            }
+        },
+    };
+});
+
+vi.mock('../generic/PubSubManager.js', () => ({
+    PubSubManager: {
+        Instance: {
+            Publish: vi.fn(),
+        },
+    },
+}));
+
+function createAppContext(providers?: ProviderInfo[]): AppContext {
+    return {
+        dataSource: Object.create(sql.ConnectionPool.prototype) as sql.ConnectionPool,
+        dataSources: [],
+        providers: providers ?? [],
+        userPayload: {
+            email: 'test@example.com',
+            sessionId: 'test-session',
+            userRecord: new UserInfo(),
+        },
+    };
+}
+
+describe('VectorizeEntityResolver — provider propagation', () => {
+    beforeEach(() => {
+        mockSyncerConstructedWith.length = 0;
+    });
+
+    it('passes request-scoped Read-Write provider from AppContext to EntityVectorSyncer', async () => {
+        const mockProvider = Object.create(DatabaseProviderBase.prototype) as DatabaseProviderBase;
+        const providerInfo: ProviderInfo = {
+            provider: mockProvider,
+            type: 'Read-Write',
+        };
+
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-1',
+            'entity-1',
+            10,
+            createAppContext([providerInfo])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(result.Status).toBe('Started');
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBe(mockProvider);
+    });
+
+    it('falls back to Read-Only provider when no Read-Write provider exists', async () => {
+        const readOnlyProvider = Object.create(DatabaseProviderBase.prototype) as DatabaseProviderBase;
+        const providerInfo: ProviderInfo = {
+            provider: readOnlyProvider,
+            type: 'Read-Only',
+        };
+
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-2',
+            'entity-2',
+            10,
+            createAppContext([providerInfo])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBe(readOnlyProvider);
+    });
+
+    it('passes undefined provider to EntityVectorSyncer when no providers in AppContext', async () => {
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-3',
+            'entity-3',
+            10,
+            createAppContext([])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBeUndefined();
+    });
+});

package/src/__tests__/WorkQueueHostService.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// TaskGraphProviderFactory imports config.ts (which validates DB env at module load); UserCache needs a live
+// provider. Both are replaced; the tests pass explicit dependencies.
+vi.mock('../config.js', () => ({ configInfo: {}, mj_core_schema: '__mj' }));
+vi.mock('@memberjunction/generic-database-provider', async (importOriginal) => ({
+    ...(await importOriginal<typeof import('@memberjunction/generic-database-provider')>()),
+    UserCache: { get Users() { return []; } },
+}));
+
+import type { DatabaseProviderBase, IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { WorkQueueEngine, WorkQueueHostConfig, WorkQueueProviderSource } from '@memberjunction/work-queue-engine';
+import { WorkQueueSchema } from '../services/workQueueConfig.js';
+import type { WorkQueueConfig } from '../services/workQueueConfig.js';
+import {
+    BuildWorkQueueHostConfig, CreateWorkQueueInstanceID, IsWorkQueueHostDisabledByEnv, MJServerWorkQueueProviderSource,
+    StartWorkQueueHost, WORK_QUEUE_DISABLE_ENV,
+} from '../services/WorkQueueHostService.js';
+import type { WorkQueueHostStartDependencies } from '../services/WorkQueueHostService.js';
+
+const PROVIDER = { Name: 'server-provider' } as unknown as DatabaseProviderBase;
+const SYSTEM_USER = { ID: 'AAAAAAAA-1111-4111-8111-000000000001', Email: 'system@memberjunction.org' } as UserInfo;
+const ENGINE = { Name: 'engine' } as unknown as WorkQueueEngine;
+const PROVIDER_SOURCE: WorkQueueProviderSource = { CreateProvider: async (): Promise<IMetadataProvider> => PROVIDER };
+
+interface Recorder {
+    Dependencies: WorkQueueHostStartDependencies;
+    Started: WorkQueueHostConfig[];
+    EngineCalls: number;
+}
+
+function recorder(users: UserInfo[] = [SYSTEM_USER], env: Record<string, string | undefined> = {}): Recorder {
+    const result: Recorder = {
+        Started: [],
+        EngineCalls: 0,
+        Dependencies: {
+            Env: env,
+            FindUserByEmail: email => users.find(user => user.Email === email),
+            ConfigureEngine: async (user, provider) => {
+                expect(user).toBe(SYSTEM_USER);
+                expect(provider).toBe(PROVIDER);
+                result.EngineCalls++;
+                return ENGINE;
+            },
+            CreateHost: (config, engine, user, provider, source) => {
+                expect([engine, user, provider, source]).toEqual([ENGINE, SYSTEM_USER, PROVIDER, PROVIDER_SOURCE]);
+                return { Start: async () => { result.Started.push(config); } };
+            },
+        },
+    };
+    return result;
+}
+
+function enabled(overrides: Partial<WorkQueueConfig> = {}): WorkQueueConfig {
+    return { ...WorkQueueSchema.parse({ enabled: true }), ...overrides };
+}
+
+describe('workQueue configuration', () => {
+    it('defaults to disabled, running every MJWorker subscription once enabled', () => {
+        expect(WorkQueueSchema.parse({})).toEqual({
+            enabled: false, systemUserEmail: 'system@memberjunction.org', subscriptions: [{ name: '*', concurrency: 4 }],
+            idlePollMinMs: 250, idlePollMaxMs: 5000, shutdownDrainMs: 8000, sweeperEnabled: true, sweeperIntervalMs: 60000,
+            reconcileIntervalMs: 30000,
+        });
+    });
+
+    it('rejects an idle poll maximum below the minimum', () => {
+        expect(WorkQueueSchema.safeParse({ idlePollMinMs: 1000, idlePollMaxMs: 500 }).success).toBe(false);
+    });
+});
+
+describe('host configuration helpers', () => {
+    it('maps the section to a host config and disables the sweeper when asked', () => {
+        const config = enabled({ subscriptions: [{ name: 'email.unsubscribe', concurrency: 8 }], sweeperEnabled: false });
+        expect(BuildWorkQueueHostConfig(config, 'api-1')).toEqual({
+            InstanceID: 'api-1', Subscriptions: [{ Name: 'email.unsubscribe', Concurrency: 8 }], IdlePollMinMs: 250,
+            IdlePollMaxMs: 5000, ShutdownDrainMs: 8000, SweeperIntervalMs: 0, ReconcileIntervalMs: 30000,
+        });
+    });
+
+    it('builds a unique instance ID from host, pid and random entropy', () => {
+        const first = CreateWorkQueueInstanceID({ HOSTNAME: 'api-7' });
+        expect(first).toMatch(new RegExp(`^api-7-${process.pid}-[0-9a-f]{8}$`));
+        expect(CreateWorkQueueInstanceID({ HOSTNAME: 'api-7' })).not.toBe(first);
+    });
+
+    it(`treats only ${WORK_QUEUE_DISABLE_ENV}=1 as the kill switch`, () => {
+        expect(IsWorkQueueHostDisabledByEnv({ [WORK_QUEUE_DISABLE_ENV]: '1' })).toBe(true);
+        expect(IsWorkQueueHostDisabledByEnv({ [WORK_QUEUE_DISABLE_ENV]: 'true' })).toBe(false);
+        expect(IsWorkQueueHostDisabledByEnv({})).toBe(false);
+    });
+});
+
+describe('StartWorkQueueHost', () => {
+    it('starts nothing when the section is disabled', async () => {
+        const rec = recorder();
+        expect(await StartWorkQueueHost(WorkQueueSchema.parse({}), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).toBeNull();
+        expect(rec.EngineCalls).toBe(0);
+    });
+
+    it('starts nothing when the kill switch is set', async () => {
+        const rec = recorder([SYSTEM_USER], { [WORK_QUEUE_DISABLE_ENV]: '1' });
+        expect(await StartWorkQueueHost(enabled(), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).toBeNull();
+        expect(rec.EngineCalls).toBe(0);
+    });
+
+    it('refuses to start without the system user', async () => {
+        const rec = recorder([]);
+        await expect(StartWorkQueueHost(enabled(), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).rejects.toThrow('System user not found with email: system@memberjunction.org');
+    });
+
+    it('names the setting to fix when the placeholder email from DEFAULT_SERVER_CONFIG is still in effect', async () => {
+        const rec = recorder();
+        await expect(StartWorkQueueHost(enabled({ systemUserEmail: 'not.set@nowhere.com' }), PROVIDER, PROVIDER_SOURCE, rec.Dependencies))
+            .rejects.toThrow('set workQueue.systemUserEmail');
+    });
+
+    it('configures the engine, then creates and starts the host', async () => {
+        const rec = recorder();
+        const host = await StartWorkQueueHost(enabled(), PROVIDER, PROVIDER_SOURCE, rec.Dependencies);
+        expect(host).not.toBeNull();
+        expect(rec.EngineCalls).toBe(1);
+        expect(rec.Started).toHaveLength(1);
+        expect(rec.Started[0]).toMatchObject({ Subscriptions: [{ Name: '*', Concurrency: 4 }], SweeperIntervalMs: 60000 });
+    });
+});
+
+describe('MJServerWorkQueueProviderSource', () => {
+    it('falls back to the shared server provider when there is no SQL Server pool', async () => {
+        const source = new MJServerWorkQueueProviderSource(null, PROVIDER);
+        expect(await source.CreateProvider()).toBe(PROVIDER);
+    });
+});

package/src/__tests__/adhocTimeoutClamp.test.ts

@@ -0,0 +1,26 @@
+/**
+ * An ad-hoc query's timeout never exceeds the server's requestTimeout, so a caller cannot hold a
+ * read-only connection longer than any other request may.
+ */
+import { describe, it, expect } from 'vitest';
+import { ClampAdhocTimeoutSeconds } from '../resolvers/adhocTimeout';
+
+describe('ClampAdhocTimeoutSeconds', () => {
+    it('caps a longer request at requestTimeout', () => {
+        expect(ClampAdhocTimeoutSeconds(600, 30000)).toBe(30);
+    });
+
+    it('keeps a shorter request', () => {
+        expect(ClampAdhocTimeoutSeconds(5, 30000)).toBe(5);
+    });
+
+    it('uses 30 seconds when the caller names none, within the cap', () => {
+        expect(ClampAdhocTimeoutSeconds(undefined, 30000)).toBe(30);
+        expect(ClampAdhocTimeoutSeconds(undefined, 10000)).toBe(10);
+        expect(ClampAdhocTimeoutSeconds(0, 30000)).toBe(30);
+    });
+
+    it('leaves the request alone when the server sets no limit', () => {
+        expect(ClampAdhocTimeoutSeconds(600, 0)).toBe(600);
+    });
+});