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

package/src/__tests__/backgroundSweepConfigUnits.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Config contract for the two background sweeps an idle MJAPI runs against its database: the AI
+ * Agent Session janitor (`agentSessions.janitor`) and the agent-run watchdog (`agentRunWatchdog`).
+ *
+ * Pins three things: the shipped defaults are exactly the values MJAPI always ran with (so existing
+ * deployments see no change), each sweep can be turned off the documented way, and the env-var
+ * readers that feed `DEFAULT_SERVER_CONFIG` reject typos instead of silently running a default or
+ * a zero-delay timer.
+ */
+import { describe, it, expect } from 'vitest';
+import {
+    AgentRunWatchdogDefaultsFromEnv,
+    AgentRunWatchdogSchema,
+    AgentSessionsDefaultsFromEnv,
+    AgentSessionsSchema,
+    ConversationDetailReconcilerDefaultsFromEnv,
+    ConversationDetailReconcilerSchema,
+    EnabledFromEnv,
+    IntervalMsFromEnv,
+} from '../backgroundSweepConfigUnits.js';
+
+describe('agentSessions.janitor schema', () => {
+    it('defaults to what MJAPI has always run: janitor on every 60s (15-minute idle close), bridge reconcile on every 10 min', () => {
+        expect(AgentSessionsSchema.parse({})).toEqual({
+            janitor: { enabled: true, sweepIntervalMs: 60_000, closeThresholdMinutes: 15 },
+            bridgeReconciler: { enabled: true, sweepIntervalMs: 600_000 },
+            handoffOfferExpiry: { enabled: true, sweepIntervalMs: 15_000 },
+        });
+    });
+
+    it('accepts enabled: false and a longer interval', () => {
+        const parsed = AgentSessionsSchema.parse({ janitor: { enabled: false, sweepIntervalMs: 3_600_000 }, bridgeReconciler: { enabled: false } });
+        expect(parsed.janitor).toEqual({ enabled: false, sweepIntervalMs: 3_600_000, closeThresholdMinutes: 15 });
+        expect(parsed.bridgeReconciler).toEqual({ enabled: false, sweepIntervalMs: 600_000 });
+    });
+
+    it('rejects a zero or negative interval (turn the tick off with enabled: false instead)', () => {
+        expect(AgentSessionsSchema.safeParse({ janitor: { sweepIntervalMs: 0 } }).success).toBe(false);
+        expect(AgentSessionsSchema.safeParse({ janitor: { closeThresholdMinutes: -1 } }).success).toBe(false);
+        expect(AgentSessionsSchema.safeParse({ bridgeReconciler: { sweepIntervalMs: 0 } }).success).toBe(false);
+    });
+});
+
+describe('conversationDetailReconciler schema', () => {
+    it('defaults to what MJAPI has always run: on, every 5 minutes', () => {
+        expect(ConversationDetailReconcilerSchema.parse({})).toEqual({ enabled: true, sweepIntervalMs: 300_000 });
+    });
+
+    it('accepts enabled: false and rejects a zero interval', () => {
+        expect(ConversationDetailReconcilerSchema.parse({ enabled: false }).enabled).toBe(false);
+        expect(ConversationDetailReconcilerSchema.safeParse({ sweepIntervalMs: 0 }).success).toBe(false);
+    });
+});
+
+describe('DEFAULT_SERVER_CONFIG blocks from the environment', () => {
+    it('an empty environment gives exactly the shipped defaults', () => {
+        expect(AgentSessionsDefaultsFromEnv({})).toEqual(AgentSessionsSchema.parse({}));
+        expect(ConversationDetailReconcilerDefaultsFromEnv({})).toEqual(ConversationDetailReconcilerSchema.parse({}));
+        expect(AgentRunWatchdogDefaultsFromEnv({})).toEqual(AgentRunWatchdogSchema.parse({}));
+    });
+
+    it('reads every documented variable', () => {
+        const env = {
+            MJ_SESSION_JANITOR_ENABLED: 'false',
+            MJ_SESSION_JANITOR_SWEEP_INTERVAL_MS: '120000',
+            MJ_BRIDGE_RECONCILER_ENABLED: 'off',
+            MJ_BRIDGE_RECONCILER_SWEEP_INTERVAL_MS: '1200000',
+            MJ_CONVERSATION_DETAIL_RECONCILER_ENABLED: '0',
+            MJ_CONVERSATION_DETAIL_RECONCILER_SWEEP_INTERVAL_MS: '900000',
+            MJ_HANDOFF_OFFER_EXPIRY_ENABLED: 'no',
+            MJ_HANDOFF_OFFER_EXPIRY_SWEEP_INTERVAL_MS: '60000',
+            MJ_AGENT_RUN_WATCHDOG_SWEEP_INTERVAL_MS: '0',
+        };
+        expect(AgentSessionsDefaultsFromEnv(env)).toEqual({
+            janitor: { enabled: false, sweepIntervalMs: 120_000, closeThresholdMinutes: 15 },
+            bridgeReconciler: { enabled: false, sweepIntervalMs: 1_200_000 },
+            handoffOfferExpiry: { enabled: false, sweepIntervalMs: 60_000 },
+        });
+        expect(ConversationDetailReconcilerDefaultsFromEnv(env)).toEqual({ enabled: false, sweepIntervalMs: 900_000 });
+        expect(AgentRunWatchdogDefaultsFromEnv(env).sweepIntervalMs).toBe(0);
+    });
+
+    it('a bad value fails, naming the variable', () => {
+        expect(() => AgentSessionsDefaultsFromEnv({ MJ_BRIDGE_RECONCILER_ENABLED: 'nope' }))
+            .toThrow('Invalid MJ_BRIDGE_RECONCILER_ENABLED "nope". Expected true or false.');
+        expect(() => ConversationDetailReconcilerDefaultsFromEnv({ MJ_CONVERSATION_DETAIL_RECONCILER_SWEEP_INTERVAL_MS: '0' }))
+            .toThrow(/Invalid MJ_CONVERSATION_DETAIL_RECONCILER_SWEEP_INTERVAL_MS "0"/);
+    });
+});
+
+describe('agentRunWatchdog schema', () => {
+    it('defaults to the watchdog MJAPI has always run: 5-min sweep, 30s heartbeat, 5-min stale threshold', () => {
+        expect(AgentRunWatchdogSchema.parse({})).toEqual({
+            sweepIntervalMs: 300_000,
+            heartbeatIntervalMs: 30_000,
+            staleThresholdMinutes: 5,
+        });
+    });
+
+    it('accepts sweepIntervalMs: 0 (startup sweep only)', () => {
+        expect(AgentRunWatchdogSchema.parse({ sweepIntervalMs: 0 }).sweepIntervalMs).toBe(0);
+    });
+
+    it('rejects a zero heartbeat (other instances would force-fail this one\'s runs) and negative values', () => {
+        expect(AgentRunWatchdogSchema.safeParse({ heartbeatIntervalMs: 0 }).success).toBe(false);
+        expect(AgentRunWatchdogSchema.safeParse({ staleThresholdMinutes: 0 }).success).toBe(false);
+        expect(AgentRunWatchdogSchema.safeParse({ sweepIntervalMs: -1 }).success).toBe(false);
+    });
+});
+
+describe('EnabledFromEnv', () => {
+    it('returns the fallback when the variable is unset or blank', () => {
+        expect(EnabledFromEnv('X', undefined, true)).toBe(true);
+        expect(EnabledFromEnv('X', null, false)).toBe(false);
+        expect(EnabledFromEnv('X', '  ', true)).toBe(true);
+    });
+
+    it.each(['false', 'FALSE', '0', 'no', 'off', 'n', 'f'])('%j turns the switch off', value => {
+        expect(EnabledFromEnv('X', value, true)).toBe(false);
+    });
+
+    it.each(['true', '1', 'yes', 'on', 'Y', 't'])('%j turns it on', value => {
+        expect(EnabledFromEnv('X', value, false)).toBe(true);
+    });
+
+    it('fails fast on anything else, naming the variable (a typo must not silently turn a sweep off)', () => {
+        expect(() => EnabledFromEnv('MJ_SESSION_JANITOR_ENABLED', 'flase', true))
+            .toThrow('Invalid MJ_SESSION_JANITOR_ENABLED "flase". Expected true or false.');
+    });
+});
+
+describe('IntervalMsFromEnv', () => {
+    it('returns the fallback when the variable is unset or blank', () => {
+        expect(IntervalMsFromEnv('X', undefined, 60_000, false)).toBe(60_000);
+        expect(IntervalMsFromEnv('X', '', 60_000, false)).toBe(60_000);
+    });
+
+    it('reads a number of milliseconds', () => {
+        expect(IntervalMsFromEnv('X', ' 3600000 ', 60_000, false)).toBe(3_600_000);
+    });
+
+    it('accepts 0 only where 0 means off', () => {
+        expect(IntervalMsFromEnv('MJ_AGENT_RUN_WATCHDOG_SWEEP_INTERVAL_MS', '0', 300_000, true)).toBe(0);
+        expect(() => IntervalMsFromEnv('MJ_SESSION_JANITOR_SWEEP_INTERVAL_MS', '0', 60_000, false))
+            .toThrow('Invalid MJ_SESSION_JANITOR_SWEEP_INTERVAL_MS "0". Expected a number of milliseconds greater than 0.');
+    });
+
+    it('fails fast on a typo, naming the variable', () => {
+        expect(() => IntervalMsFromEnv('MJ_AGENT_RUN_WATCHDOG_SWEEP_INTERVAL_MS', '5m', 300_000, true))
+            .toThrow('Invalid MJ_AGENT_RUN_WATCHDOG_SWEEP_INTERVAL_MS "5m". Expected a number of milliseconds, 0 or greater.');
+        expect(() => IntervalMsFromEnv('X', '-5', 60_000, true)).toThrow(/Invalid X/);
+    });
+});

package/src/__tests__/contextRequestOrigin.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests that ContextFunction surfaces the request's normalized Origin header on AppContext as
+ * `RequestOrigin`. Database-facing dependencies are mocked; no connection is opened.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BehaviorSubject } from 'rxjs';
+
+const { mockProviderConfig } = vi.hoisted(() => ({
+  mockProviderConfig: vi.fn(),
+}));
+
+vi.mock('../util.js', () => ({
+  GetReadOnlyDataSource: vi.fn(() => undefined),
+  GetReadWriteDataSource: vi.fn(() => undefined),
+}));
+
+vi.mock('../config.js', () => ({
+  configInfo: { databaseSettings: { metadataCacheRefreshInterval: 0 } },
+  userEmailMap: {},
+  apiKey: 'test-api-key',
+  mj_core_schema: '__mj',
+}));
+
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({
+  SQLServerDataProvider: class {
+    Config = mockProviderConfig;
+  },
+  SQLServerProviderConfigData: class {},
+}));
+
+vi.mock('@memberjunction/postgresql-dataprovider', () => ({
+  PostgreSQLDataProvider: class {
+    Config = mockProviderConfig;
+  },
+  PostgreSQLProviderConfigData: class {},
+}));
+
+vi.mock('@memberjunction/generic-database-provider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@memberjunction/generic-database-provider')>();
+  return {
+    ...actual,
+    resolveDbPlatformFromEnv: () => 'sqlserver' as const,
+    UserCache: { Instance: {} } as typeof actual.UserCache,
+  };
+});
+
+vi.mock('@memberjunction/api-keys', () => ({
+  GetAPIKeyEngine: vi.fn(),
+}));
+
+vi.mock('@memberjunction/core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@memberjunction/core')>();
+  return { ...actual, Metadata: { Provider: { Entities: [{}] } } };
+});
+
+import { ContextFunction } from '../context.js';
+import type { IncomingMessage } from 'http';
+import type { ConnectionPool } from 'mssql';
+import type { UserPayload } from '../types.js';
+
+const MOCK_POOL = {} as ConnectionPool;
+const MOCK_PAYLOAD = { email: 'user@example.com' } as UserPayload;
+
+function makeReq(headers: IncomingMessage['headers']): IncomingMessage {
+  return { headers, body: {}, ip: '127.0.0.1', userPayload: MOCK_PAYLOAD } as unknown as IncomingMessage;
+}
+
+async function contextFor(headers: IncomingMessage['headers']) {
+  const build = ContextFunction({ setupComplete$: new BehaviorSubject<unknown>(true), dataSource: MOCK_POOL, dataSources: [] });
+  return build({ req: makeReq(headers) });
+}
+
+describe('ContextFunction RequestOrigin', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockProviderConfig.mockResolvedValue(true);
+  });
+
+  it('carries the normalized Origin header', async () => {
+    const ctx = await contextFor({ origin: 'https://Embed.Example.com/' });
+    expect(ctx.RequestOrigin).toBe('https://embed.example.com');
+  });
+
+  it('keeps an explicit port', async () => {
+    const ctx = await contextFor({ origin: 'http://localhost:4200' });
+    expect(ctx.RequestOrigin).toBe('http://localhost:4200');
+  });
+
+  it('is undefined when the request sent no Origin header', async () => {
+    const ctx = await contextFor({});
+    expect(ctx.RequestOrigin).toBeUndefined();
+  });
+
+  it('is undefined for a malformed or opaque Origin header', async () => {
+    expect((await contextFor({ origin: 'null' })).RequestOrigin).toBeUndefined();
+    expect((await contextFor({ origin: 'https://a.com/path' })).RequestOrigin).toBeUndefined();
+  });
+
+  it('leaves the existing context fields in place', async () => {
+    const ctx = await contextFor({ origin: 'https://a.com' });
+    expect(ctx.userPayload).toBe(MOCK_PAYLOAD);
+    expect(ctx.ClientIp).toBe('127.0.0.1');
+    expect(ctx.providers).toHaveLength(1);
+  });
+});

package/src/__tests__/conversationBrowsers.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+
+const endSession = vi.fn(async (_id: string) => true);
+vi.mock('@memberjunction/remote-browser-server', () => ({
+  RemoteBrowserEngine: { Instance: { EndSessionForAgentSession: (id: string) => endSession(id) } },
+}));
+
+import { GetGlobalObjectStore, ShutdownRegistry } from '@memberjunction/global';
+import { ConversationBrowserLedger, RemoteBrowserRefusedError } from '../agentSessions/conversationBrowsers.js';
+
+const USER = { Key: 'user:a1a1a1a1-0000-4000-8000-000000000001', Anonymous: false };
+const LIMITS = { maxPerUser: 2, maxAnonymousTotal: 4, idleMinutes: 15 };
+const guest = (scope: string) => ({ Key: `scope:${scope}`, Anonymous: true });
+const ledger = ConversationBrowserLedger.Instance;
+
+afterEach(() => {
+  for (const id of ['conv-idle', 'conv-used', 'conv-third', 'g1-a', 'g1-b', 'g2-a']) {
+    ledger.Release(id);
+  }
+  vi.useRealTimers();
+});
+
+describe('ConversationBrowserLedger', () => {
+  it('is one process-wide instance, held in the global object store so every copy of the module shares it', () => {
+    expect(ConversationBrowserLedger.Instance).toBe(ledger);
+    expect(GetGlobalObjectStore()?.[ledger.GlobalKey]).toBe(ledger);
+  });
+
+  it('ends a browser nobody used for its idle limit, keeps a used one, and frees the owner\'s slot', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] });
+    vi.setSystemTime(0);
+    ledger.Claim('conv-idle', USER, LIMITS);
+    ledger.Claim('conv-used', USER, LIMITS);
+    expect(() => ledger.Claim('conv-third', USER, LIMITS)).toThrow(RemoteBrowserRefusedError);
+
+    vi.setSystemTime(10 * 60_000);
+    ledger.Touch('conv-used');
+    vi.setSystemTime(16 * 60_000);
+    expect(await ledger.ReapIdle()).toBe(1);
+    expect(endSession).toHaveBeenCalledWith('conv-idle');
+    expect(endSession).not.toHaveBeenCalledWith('conv-used');
+    expect(() => ledger.Claim('conv-third', USER, LIMITS)).not.toThrow();
+  });
+
+  it('joins the graceful shutdown with its first browser, and ends every browser it holds there', async () => {
+    endSession.mockClear();
+    ledger.Claim('conv-idle', USER, LIMITS);
+    ledger.Claim('conv-used', USER, LIMITS);
+    expect(ShutdownRegistry.Instance.List()).toContain(ledger);
+
+    await ledger.Shutdown();
+    expect(endSession.mock.calls.map((c) => c[0]).sort()).toEqual(['conv-idle', 'conv-used']);
+    expect(await ledger.ReapIdle()).toBe(0);
+  });
+
+  it('counts each owner key on its own, so one anonymous guest cannot use up another\'s cap', () => {
+    const one = { ...LIMITS, maxPerUser: 1 };
+    ledger.Claim('g1-a', guest('visitor-1'), one);
+    expect(() => ledger.Claim('g1-b', guest('visitor-1'), one)).toThrow(RemoteBrowserRefusedError);
+    expect(() => ledger.Claim('g2-a', guest('visitor-2'), one)).not.toThrow();
+  });
+});

package/src/__tests__/globalCors.test.ts

@@ -215,3 +215,15 @@ describe('X-Powered-By', () => {
         expect(src.match(/app\.disable\('x-powered-by'\)/g)?.length ?? 0).toBeGreaterThanOrEqual(2);
     });
 });
+
+describe('X-MJ-Diagnostic-Trigger', () => {
+    it('is exposed to the browser by the global CORS and by the GraphQL CORS', async () => {
+        const base = await startApp([]);
+        const res = await fetch(`${base}/core`, { headers: { Origin: OTHER_ORIGIN } });
+        expect(res.headers.get('access-control-expose-headers')).toContain('X-MJ-Diagnostic-Trigger');
+
+        const src = readFileSync(new URL('../index.ts', import.meta.url), 'utf8');
+        const graphqlCors = src.match(/app\.use\(\s*graphqlRootPath,\s*cors<cors\.CorsRequest>\(\{\s*exposedHeaders: \[([^\]]*)\]/);
+        expect(graphqlCors?.[1]).toContain('X-MJ-Diagnostic-Trigger');
+    });
+});