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

package/src/__tests__/AdhocQueryResolver.dialect.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Regression suite for the ad-hoc read-only execution path being SQL-Server-shaped.
+ *
+ * The bug — `ExecuteAdhocQuery` opened with
+ * `GetReadOnlyDataSource(context.dataSources, …)`, which looks for an **mssql
+ * `ConnectionPool`**. A PostgreSQL provider never populates `context.dataSources`
+ * with one, so every ad-hoc query on PostgreSQL returned
+ * "No read-only data source available for ad-hoc query execution".
+ *
+ * `next` fixed the execution path (R31): the resolver now hands the SQL to the
+ * read-only PROVIDER's `RunQuery`, and renders it for that provider's platform.
+ * This suite pins the dialect half of that contract — the platform comes from the
+ * provider the SQL runs on, never from a literal, and nothing reaches for mssql —
+ * and drives the resolver against a PostgreSQL provider with no mssql pool at all.
+ * Paging, the timeout clamp and the read authorizer have their own suites.
+ */
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// `RunQueryResultType` is a type-graphql object type whose fields rely on
+// `emitDecoratorMetadata`. esbuild (what vitest transforms with) cannot emit it,
+// so importing QueryResolver for real fails at decoration time. The resolver only
+// uses the class as the @Query return marker, so a bare stand-in is enough and
+// keeps the REAL AdhocQueryResolver under test.
+vi.mock('../resolvers/QueryResolver.js', () => ({
+    RunQueryResultType: class RunQueryResultType {},
+}));
+
+// The server config is read from mj.config at import; only the timeout cap is used here.
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+import { AdhocQueryResolver } from '../resolvers/AdhocQueryResolver.js';
+import type { AppContext } from '../types.js';
+
+const ADHOC_RESOLVER_PATH = resolve(__dirname, '../resolvers/AdhocQueryResolver.ts');
+
+function readResolverSource(): string {
+    return readFileSync(ADHOC_RESOLVER_PATH, 'utf8');
+}
+
+type RunQueryCall = { SQL: string; MaxRows?: number; StartRow?: number };
+
+function postgresContext(calls: RunQueryCall[], rows: Record<string, unknown>[]): AppContext {
+    const provider = {
+        PlatformKey: 'postgresql',
+        RunQuery: async (params: RunQueryCall) => {
+            calls.push(params);
+            return { Success: true, Results: rows, RowCount: rows.length, TotalRowCount: rows.length };
+        },
+    };
+    return {
+        // Deliberately EMPTY: a PostgreSQL tenant has no mssql ConnectionPool here.
+        // If the resolver still reaches for one, these tests fail.
+        dataSources: [],
+        providers: [{ type: 'Read-Only', provider }],
+        userPayload: { userRecord: { ID: 'u-1', Name: 'Tester' } },
+    } as unknown as AppContext;
+}
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('AdhocQueryResolver dialect source-shape contract', () => {
+    it('must NOT gate execution on a SQL-Server-only read-only data source', () => {
+        expect(readResolverSource()).not.toContain('GetReadOnlyDataSource');
+    });
+
+    it('must NOT depend on the mssql driver', () => {
+        const src = readResolverSource();
+        expect(src).not.toMatch(/^import .* from 'mssql';$/m);
+        expect(src).not.toContain('new sql.Request(');
+        expect(src).not.toContain('sql.ConnectionPool');
+    });
+
+    it('renders for the platform of the read-only provider the SQL runs on, not a literal', () => {
+        const src = readResolverSource();
+        expect(src).toContain('GetReadOnlyProvider(context.providers');
+        expect(src).toContain('Platform: provider.PlatformKey');
+        expect(src).not.toMatch(/platform\s*(:\s*DatabasePlatform\s*)?=\s*'sqlserver'/);
+        expect(src).not.toMatch(/Platform:\s*'sqlserver'/);
+    });
+});
+
+describe('ExecuteAdhocQuery on a PostgreSQL tenant', () => {
+    it('runs on the read-only provider instead of refusing for want of an mssql pool', async () => {
+        const resolver = new AdhocQueryResolver();
+        const authorize = vi.spyOn(resolver, 'AuthorizeRenderedSQL').mockReturnValue(null);
+        const calls: RunQueryCall[] = [];
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            postgresContext(calls, [{ ID: '1' }, { ID: '2' }]),
+        );
+
+        expect(result.ErrorMessage).not.toContain('No read-only data source');
+        expect(result.Success).toBe(true);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].SQL).toBe('SELECT ID FROM __mj.vwUsers');
+        expect(JSON.parse(result.Results)).toEqual([{ ID: '1' }, { ID: '2' }]);
+        // The SQL is authorized (and so rendered) against the same PostgreSQL provider it runs on.
+        expect((authorize.mock.calls[0][1] as { PlatformKey: string }).PlatformKey).toBe('postgresql');
+    });
+});
+
+describe('ExecuteAdhocQuery refusal path', () => {
+    it('still refuses when there is no read-only provider at all', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            { dataSources: [], providers: [], userPayload: { userRecord: { ID: 'u-1' } } } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available for ad-hoc query execution');
+    });
+
+    it('does NOT fall back to a read-write provider', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            {
+                dataSources: [],
+                providers: [{ type: 'Read-Write', provider: { PlatformKey: 'postgresql', RunQuery: async () => ({ Success: true, Results: [] }) } }],
+                userPayload: { userRecord: { ID: 'u-1' } },
+            } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available');
+    });
+});

package/src/__tests__/AgentRunStatusPublisher.test.ts

@@ -29,6 +29,7 @@ vi.mock('@memberjunction/graphql-dataprovider', () => ({
 import type { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { ConversationStreaming, type IConversationsRuntimeContext } from '@memberjunction/conversations-runtime';
 import { AgentRunStatusPublisher } from '../resolvers/AgentRunStatusPublisher.js';
+import { StatusUpdatesFilter, type PushStatusNotificationPayload } from '../generic/PushStatusResolver.js';
 import type { UserPayload } from '../types.js';
 
 const run = {
@@ -56,6 +57,31 @@ function envelopes(publish: ReturnType<typeof vi.fn>): Array<Record<string, unkn
 }
 
 describe('AgentRunStatusPublisher', () => {
+    it('stamps the reply row on every message when it has one, so a reconnecting client can find its row', () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub = { publish } as unknown as PubSubEngine;
+        const userPayload = { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload;
+        const made = new AgentRunStatusPublisher(pubSub, userPayload, 'session-1', 'reply-7');
+        const runWithoutDetail = { ...run, ConversationDetailID: undefined, GetAll: () => ({ ID: 'run-1' }) };
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: runWithoutDetail } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+        made.PublishFinal({ success: true, agentRun: runWithoutDetail } as unknown as ExecuteAgentResult);
+
+        const details = envelopes(publish).map((row) => (row.data as { conversationDetailId?: string }).conversationDetailId);
+        expect(details).toEqual(['reply-7', 'reply-7', 'reply-7', 'reply-7']);
+    });
+
+    it('leaves progress and streaming messages without a reply row when it has none, as before', () => {
+        const { publish, made } = publisher();
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: run } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+
+        const sent = envelopes(publish).map((row) => row.data as Record<string, unknown>);
+        expect(sent.every((data) => !('conversationDetailId' in data))).toBe(true);
+    });
+
     it('publishes the resolver sequence: a significant step, streamed text, the partial result, then the completion', () => {
         const { publish, made } = publisher();
 
@@ -173,3 +199,26 @@ describe('AgentRunStatusPublisher', () => {
         expect(streaming.GetRecentCompletion('detail-1')?.agentRunId).toBe('run-1');
     });
 });
+
+describe('AgentRunStatusPublisher — a widget guest elevated to the system user (#4931)', () => {
+    const GUEST = { ID: 'anonymous-user', IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-a', MagicLinkScope: { ResourceID: 'sid-a' } };
+    const SYSTEM = { ID: 'system-user' };
+
+    it("stamps the guest (ElevatedFrom), not the elevated user, so the guest's own socket receives the run's events", () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const elevated = { sessionId: 'session-1', userRecord: SYSTEM, isSystemUser: true, ElevatedFrom: GUEST } as unknown as UserPayload;
+        const made = new AgentRunStatusPublisher({ publish } as unknown as PubSubEngine, elevated, 'session-1');
+
+        made.PublishFinal({ success: true, agentRun: run, payload: { text: 'Hello' } } as ExecuteAgentResult, 'detail-1', '{"text":"Hello"}');
+        made.PublishFailure('detail-1', 'boom');
+
+        const owners = publish.mock.calls.map((call) => (call[1] as { ownerUserId: string }).ownerUserId);
+        expect(owners.length).toBeGreaterThan(0);
+        // An anonymous visitor's owner key carries its scope identity, so another visitor cannot receive these events.
+        expect(owners.every((owner) => owner === 'anonymous-user|sid-a')).toBe(true);
+        const guestConnection = { userPayload: { sessionId: 'session-1', userRecord: GUEST } as unknown as UserPayload };
+        for (const call of publish.mock.calls) {
+            expect(StatusUpdatesFilter({ payload: call[1] as PushStatusNotificationPayload, args: { sessionId: 'session-1' }, context: guestConnection })).toBe(true);
+        }
+    });
+});

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

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { AppContext } from '../types.js';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator,
+        Mutation: noopDecorator,
+        Arg: noopDecorator,
+        Ctx: noopDecorator,
+        ObjectType: noopDecorator,
+        Field: noopDecorator,
+    };
+});
+
+vi.mock('../generic/ResolverBase.js', () => ({
+    ResolverBase: class {
+        protected GetUserFromPayload(payload?: { userRecord?: UserInfo }): UserInfo | undefined {
+            return payload?.userRecord;
+        }
+    },
+}));
+
+const closeSessionMock = vi.fn(async () => true);
+const heartbeatMock = vi.fn(async () => true);
+
+vi.mock('../agentSessions/index.js', () => ({
+    SessionManager: class {
+        CloseSession = closeSessionMock;
+        Heartbeat = heartbeatMock;
+    },
+    SessionAuthorizationError: class extends Error {},
+}));
+
+import { AgentSessionResolver } from '../resolvers/AgentSessionResolver.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'
+                ? { UserID: ANON, ConversationID: CONVERSATION, Load: vi.fn(async () => sessionFound) }
+                : { ExternalID: externalId, Load: vi.fn(async () => true) },
+        ),
+    } as unknown as IMetadataProvider;
+}
+
+function makeCtx(user: UserInfo, provider: IMetadataProvider): AppContext {
+    return {
+        userPayload: { email: 'anonymous@magic-link.local', sessionId: 's', userRecord: user },
+        providers: [{ provider, type: 'Read-Write' }],
+    } as unknown as AppContext;
+}
+
+describe('AgentSessionResolver anonymous visitor ownership', () => {
+    beforeEach(() => {
+        closeSessionMock.mockClear();
+        heartbeatMock.mockClear();
+    });
+
+    it('CloseAgentSession allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+    });
+
+    it('AgentSessionHeartbeat allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+    });
+
+    it('throws the expected not-found message when the session does not exist', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(false);
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+    });
+});
+
+describe('CloseAgentSession close reason (MJ#6013)', () => {
+    beforeEach(() => closeSessionMock.mockClear());
+
+    it('passes a client-reportable reason through, so a start that failed is recorded as an Error', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Error')).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Error');
+    });
+
+    it('defaults to Explicit when the client sends no reason (older clients)', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Explicit');
+    });
+
+    it('refuses a reason only the server may stamp', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Janitor')).rejects.toThrow(/close reason/i);
+        expect(closeSessionMock).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/CustomColumnPromoterOnePass.test.ts

@@ -14,10 +14,19 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 
 const runPipelineBatchMock = vi.fn();
+/**
+ * MJ-APPLY-6 — the BARE, non-retrying entry point. Bound separately so a regression back to it is
+ * an assertion failure rather than an invisible loss of the retry. Promotion runs unattended
+ * mid-sync; a transient pipeline step failing there drops the whole promotion silently.
+ */
+const runPipelineBatchBareMock = vi.fn();
 vi.mock('@memberjunction/schema-engine', () => ({
     RuntimeSchemaManager: {
         get Instance() {
-            return { RunPipelineBatch: runPipelineBatchMock };
+            return {
+                RunPipelineBatch: runPipelineBatchBareMock,
+                RunPipelineBatchWithRetry: runPipelineBatchMock,
+            };
         },
     },
 }));
@@ -104,6 +113,7 @@ function stubPromoter(
 
 beforeEach(() => {
     runPipelineBatchMock.mockReset();
+    runPipelineBatchBareMock.mockReset();
 });
 
 describe('PromoteForSync — one batched RSU pass', () => {
@@ -122,6 +132,10 @@ describe('PromoteForSync — one batched RSU pass', () => {
         const result = await promoter.PromoteForSync('ci-1', ['A', 'B', 'C']);
 
         expect(runPipelineBatchMock).toHaveBeenCalledTimes(1);
+        // MJ-APPLY-6 — the ONE pass has to be the RETRYING one. Promotion is unattended: a
+        // transient ExecuteMigration/RunCodeGen/Compile/Restart failure with no replay drops every
+        // accepted column back into overflow and nothing reruns it.
+        expect(runPipelineBatchBareMock).not.toHaveBeenCalled();
         expect(runPipelineBatchMock.mock.calls[0][0]).toHaveLength(3);
         expect(result.Promoted).toBe(true);
         expect(result.ColumnsAdded).toEqual([

package/src/__tests__/EntityCommunicationsResolver.actingUser.test.ts

@@ -0,0 +1,151 @@
+// The resolver module pulls in type-graphql decorators, which need the Reflect.metadata polyfill.
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { DatabaseProviderBase, UserInfo } from '@memberjunction/core';
+import type { EntityCommunicationParams } from '@memberjunction/entity-communications-base';
+
+/**
+ * `RunEntityCommunicationByViewID` with `previewOnly` + `includeProcessedMessages` returns the rows
+ * it read. It must hand the engine the authenticated caller as the acting user, and screen the
+ * view's client-supplied clauses the way a RunView request is screened, because this entry point
+ * does not pass through the RunView resolvers.
+ */
+
+const { captured } = vi.hoisted(() => ({ captured: { params: [] as EntityCommunicationParams[] } }));
+
+// The resolver's input types declare fields without explicit GraphQL types; the test runner emits no
+// decorator metadata, so the decorators are stubbed out.
+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,
+        Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+        createUnionType: () => class {},
+        AuthorizationError: class AuthorizationError extends Error {},
+        Float: class {}, Int: class {}, ID: class {},
+    };
+});
+
+vi.mock('@memberjunction/entity-communications-server', () => ({
+    EntityCommunicationsEngine: {
+        Instance: {
+            Config: vi.fn(),
+            RunEntityCommunication: vi.fn(async (params: EntityCommunicationParams) => {
+                captured.params.push(params);
+                return { Success: true, Results: [] };
+            }),
+        },
+    },
+}));
+
+vi.mock('@memberjunction/templates', () => ({
+    TemplateEngineServer: { Instance: { Config: vi.fn(), FindTemplate: vi.fn() } },
+}));
+
+import { ReportResolver } from '../resolvers/EntityCommunicationsResolver.js';
+import type { AppContext } from '../types.js';
+import type { RunViewByIDInput } from '../generic/RunViewResolver.js';
+import type { CommunicationMessageInput } from '../resolvers/EntityCommunicationsResolver.js';
+
+const SENDER = { ID: 'sender', Email: 'sender@example.com' } as UserInfo;
+
+/** Entity metadata the clause screen reads: one entity the sender can read, one it cannot. */
+function fakeProvider(): DatabaseProviderBase {
+    const entity = (name: string, view: string, canRead: boolean) => ({
+        ID: name,
+        Name: name,
+        SchemaName: '__mj',
+        BaseView: view,
+        BaseTable: view.replace(/^vw/, ''),
+        Fields: [{ Name: 'ID', NeedsQuotes: true }, { Name: 'Email', NeedsQuotes: true }],
+        GetUserPermisions: () => ({ CanRead: canRead }),
+        GetEffectiveRowFilterWhereClause: () => '',
+        GetDeniedReadFields: () => new Set<string>(),
+    });
+    return {
+        Entities: [entity('Customers', 'vwCustomers', true), entity('Salaries', 'vwSalaries', false)],
+        GetEntityObject: async () => fakeView(),
+    } as unknown as DatabaseProviderBase;
+}
+
+/** Saved views by ID, as the caller can load them: `view-1` is a Customers view, `view-salaries` is not. */
+const VIEWS: Record<string, { ID: string; EntityID: string }> = {
+    'view-1': { ID: 'view-1', EntityID: 'Customers' },
+    'view-salaries': { ID: 'view-salaries', EntityID: 'Salaries' },
+};
+
+function fakeView() {
+    const view = {
+        ID: undefined as string | undefined,
+        EntityID: undefined as string | undefined,
+        async Load(id: string) {
+            const found = VIEWS[id];
+            if (!found) return false;
+            Object.assign(view, found);
+            return true;
+        },
+    };
+    return view;
+}
+
+function context(): AppContext {
+    return {
+        userPayload: { email: SENDER.Email, userRecord: SENDER },
+        providers: [{ provider: fakeProvider(), type: 'Read-Write' }],
+    } as unknown as AppContext;
+}
+
+function run(extraFilter?: string, viewID = 'view-1') {
+    const viewInput = { ViewID: viewID, ExtraFilter: extraFilter } as RunViewByIDInput;
+    const message = { MessageType: {}, From: 'a@example.com', To: '' } as unknown as CommunicationMessageInput;
+    return new ReportResolver().RunEntityCommunicationByViewID('Customers', viewInput, 'SendGrid', 'Email', message, true, true, context());
+}
+
+describe('RunEntityCommunicationByViewID — runs as the caller', () => {
+    beforeEach(() => {
+        captured.params = [];
+    });
+
+    it('passes the authenticated caller to the engine as the acting user', async () => {
+        const result = await run();
+        expect(result.Success).toBe(true);
+        expect(captured.params).toHaveLength(1);
+        expect(captured.params[0].ContextUser).toBe(SENDER);
+    });
+
+    it('refuses an ExtraFilter whose subquery reads an entity the caller cannot read, before the engine runs', async () => {
+        const result = await run("ID IN (SELECT ID FROM __mj.vwSalaries WHERE Amount > 100000)");
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/ExtraFilter/);
+        expect(captured.params).toHaveLength(0);
+    });
+
+    it('refuses an ExtraFilter that carries a second statement', async () => {
+        const result = await run("1=1; SELECT 1");
+        expect(result.Success).toBe(false);
+        expect(captured.params).toHaveLength(0);
+    });
+});
+
+describe('RunEntityCommunicationByViewID — the view must belong to the entity', () => {
+    beforeEach(() => {
+        captured.params = [];
+    });
+
+    it('refuses a view of a different entity, before the engine runs', async () => {
+        const result = await run(undefined, 'view-salaries');
+        expect(result.Success).toBe(false);
+        expect(captured.params).toHaveLength(0);
+    });
+
+    it('gives the same error for a view of another entity as for a view that does not exist', async () => {
+        const mismatched = await run(undefined, 'view-salaries');
+        const missing = await run(undefined, 'view-missing');
+        expect(missing.Success).toBe(false);
+        expect(mismatched.ErrorMessage).toBe(missing.ErrorMessage);
+        expect(mismatched.ErrorMessage).toMatch(/does not exist or you do not have access/);
+        expect(captured.params).toHaveLength(0);
+    });
+});

package/src/__tests__/EvolutionActsOnWhatItDetects.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Two ways the schema-evolution path stopped short of acting on what it already knew.
+ *
+ *  - MJ-RUN-37: the persist layer has always recorded an `IncrementalWatermarkField` change and
+ *    nothing consumed the record. `changedObjects` — the sole input to `ResetPullWatermarks` — was
+ *    built from a physical column diff and a field-map add/disable, and a cursor swap produces
+ *    neither. The stale Pull watermark then became a lower bound on a DIFFERENT column, and where
+ *    the new column sorts later, every row below it was filtered out at the source, permanently and
+ *    invisibly (an incremental's fetched-vs-expected check agrees, because the source counts
+ *    against the filter it was handed).
+ *
+ *  - MJ-APPLY-6 residual: `RunPipelineBatchWithRetry` existed and two of the six pipeline call
+ *    sites used it. `SchemaBuilder.RunSchemaPipeline` states the reason plainly — the middle steps
+ *    fail transiently and "the callers simply never used it".
+ *
+ * The evolution mutation needs a provider, a connector, a SchemaBuilder and an RSU pipeline to
+ * invoke, and the properties here are wiring, not behaviour worth standing all that up to observe.
+ * Read from source, the convention this directory already uses for this method. The DECISION the
+ * wiring feeds is unit-tested for real in the integration-engine package
+ * (WatermarkFieldChangeIsAChange.test.ts) — these pin that the resolver calls it, feeds it the
+ * right input, and does so before the watermark reset.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+const PROMOTER = readFileSync(join(__dirname, '..', 'integration', 'CustomColumnPromoter.ts'), 'utf-8');
+const RSU_RESOLVER = readFileSync(join(__dirname, '..', 'resolvers', 'RSUResolver.ts'), 'utf-8');
+
+/** The body of a named resolver method, up to the next @Query/@Mutation at the same indent. */
+function methodBody(src: string, name: string): string {
+  const start = src.indexOf(`async ${name}(`);
+  expect(start, `${name} not found`).toBeGreaterThan(-1);
+  const rest = src.slice(start);
+  const end = rest.search(/\n    @(Query|Mutation)\(/);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+describe('MJ-RUN-37 — a watermark-field change reaches ResetPullWatermarks', () => {
+  const body = () => methodBody(SRC, 'IntegrationSchemaEvolution');
+
+  it('consumes the persist layer\'s detection rather than re-deriving it', () => {
+    // The whole defect was that this signal existed and had no consumer. It must come from the
+    // refresh's OWN PersistResult — re-reading the catalog afterwards cannot tell a changed
+    // watermark field from one that was always that way.
+    expect(body()).toMatch(/ObjectsWithWatermarkFieldChange\(\s*refresh\.PersistResult\?\.ObjectMergeLog \?\? \[\]/);
+  });
+
+  it('imports it from the engine that produces it', () => {
+    expect(SRC).toMatch(/ObjectsWithWatermarkFieldChange[\s\S]{0,200}?from "@memberjunction\/integration-engine"/);
+  });
+
+  it('scopes it to the CONTINUING maps, so it cannot report what nothing can reset', () => {
+    expect(body()).toMatch(/continuingMaps\.map\(m => m\.ExternalObjectName \?\? ''\)/);
+  });
+
+  it('folds the result into changedObjects — the only input ResetPullWatermarks has', () => {
+    const b = body();
+    const push = b.search(/if \(!changedObjects\.some\(n => n\.toLowerCase\(\) === name\.toLowerCase\(\)\)\) changedObjects\.push\(name\)/);
+    const reset = b.indexOf('ResetPullWatermarks(');
+    expect(push, 'the watermark-changed names are never pushed onto changedObjects').toBeGreaterThan(-1);
+    expect(reset).toBeGreaterThan(-1);
+    expect(push, 'the push must happen BEFORE the reset, or it changes nothing').toBeLessThan(reset);
+  });
+
+  it('does not push unconditionally — an unchanged run must not re-full-sync the connection', () => {
+    // The guard is the expensive half. `changedObjects` drives ResetPullWatermarks AND HasChanges,
+    // so a rule that fires when no cursor moved turns every refresh into a full re-fetch of
+    // everything. The emptiness of the detection is what has to carry that, never a bare loop.
+    const b = body();
+    const i = b.indexOf('ObjectsWithWatermarkFieldChange(');
+    const after = b.slice(i, i + 600);
+    expect(after).toMatch(/for \(const name of watermarkFieldChanged\)/);
+    expect(after).not.toMatch(/changedObjects\.push\(\.\.\./);
+  });
+});
+
+describe('MJ-APPLY-6 residual — the bare pipeline calls that should retry', () => {
+  it('IntegrationApplySchemaBatch retries, matching its single-connector sibling', () => {
+    // IntegrationApplySchema retries via SchemaBuilder.RunSchemaPipeline. Same install path, same
+    // generated DDL, same four transient steps — the batch simply never used the wrapper.
+    const b = methodBody(SRC, 'IntegrationApplySchemaBatch');
+    expect(b).toMatch(/rsm\.RunPipelineBatchWithRetry\(pipelineInputs\)/);
+    expect(b).not.toMatch(/rsm\.RunPipelineBatch\(/);
+  });
+
+  it('IntegrationSchemaEvolution retries', () => {
+    const b = methodBody(SRC, 'IntegrationSchemaEvolution');
+    expect(b).toMatch(/rsm\.RunPipelineBatchWithRetry\(/);
+    expect(b).not.toMatch(/rsm\.RunPipelineBatch\(/);
+  });
+
+  it('the custom-column promoter retries — it runs unattended, mid-sync', () => {
+    expect(PROMOTER).toMatch(/RuntimeSchemaManager\.Instance\.RunPipelineBatchWithRetry\(batchInputs\)/);
+    expect(PROMOTER).not.toMatch(/RuntimeSchemaManager\.Instance\.RunPipelineBatch\(/);
+  });
+
+  it('no bare RunPipelineBatch survives in the integration resolver', () => {
+    // A regression here is invisible at runtime: the pipeline still works, it just stops
+    // absorbing the hiccup it was wrapped to absorb.
+    expect(SRC).not.toMatch(/RunPipelineBatch\((?!\w)/);
+  });
+
+  it('RunRuntimeSchemaUpdateBatch deliberately does NOT retry, and says why', () => {
+    // The one exception, kept explicit so it reads as a decision rather than an oversight: this
+    // mutation replays CALLER-AUTHORED SQL, and executeMigration is not transactional.
+    const b = methodBody(RSU_RESOLVER, 'RunRuntimeSchemaUpdateBatch');
+    expect(b).toMatch(/rsm\.RunPipelineBatch\(pipelineInputs\)/);
+    expect(b).toMatch(/deliberately the BARE call/);
+    expect(b).toMatch(/NOT transactional/);
+  });
+});