@memberjunction/server 5.51.2 → 5.51.4

package/src/__tests__/GetDataContextDataResolver.sqlItems.test.ts

@@ -0,0 +1,416 @@
+// type-graphql decorators on the resolver need the Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+/**
+ * `GetDataContextItemData` and `GetDataContextData` run the SQL stored in `sql` Data Context Items.
+ * Before it runs, that SQL is held to the rules `ExecuteAdhocQuery` applies to caller-supplied SQL:
+ *   - the caller owns the data context, or is an administrator (Owner-type user);
+ *   - the caller is not a scope-limited (magic-link) session;
+ *   - it runs on the read-only provider only — never on the read-write pool, even when no read-only
+ *     database is configured;
+ *   - it is a single read statement that reads only entity base views the caller may read.
+ * Items of the other types load as before, for the calling user.
+ *
+ * The resolver runs for real against in-memory providers. `mssql` is replaced by a recorder so a
+ * test can see whether any SQL reached a raw connection pool.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EntityInfo, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import type {
+    DatabaseProviderBase,
+    IMetadataProvider,
+    IRunViewProvider,
+    RunQueryParams,
+    RunQueryResult,
+    RunViewParams,
+    RunViewResult,
+} from '@memberjunction/core';
+import type { MJDataContextEntity, MJDataContextItemEntity } from '@memberjunction/core-entities';
+import { RenderPipeline } from '@memberjunction/generic-database-provider';
+import type { AppContext } from '../types.js';
+
+/** Every SQL text that a raw mssql connection was asked to run, and the pool it was sent to. */
+const rawConnectionQueries: Array<{ Pool: string | undefined; SQL: string }> = [];
+
+vi.mock('mssql', () => {
+    class RecordingRequest {
+        private readonly pool: string | undefined;
+        constructor(parent?: { Name?: string }) {
+            this.pool = parent?.Name;
+        }
+        public input(): this {
+            return this;
+        }
+        public async query(sqlText: string): Promise<{ recordset: Array<Record<string, unknown>> }> {
+            rawConnectionQueries.push({ Pool: this.pool, SQL: sqlText });
+            return { recordset: [{ One: 1 }] };
+        }
+    }
+    class ConnectionPool {}
+    return {
+        default: { ConnectionPool, Request: RecordingRequest },
+        ConnectionPool,
+        Request: RecordingRequest,
+    };
+});
+
+// MJAPI registers the server-side Data Context Item class at startup; this import does the same.
+import '@memberjunction/data-context-server';
+import { GetDataContextDataResolver } from '../resolvers/GetDataContextDataResolver.js';
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const OWNER_ID = 'A0000000-0000-4000-8000-000000000001';
+const DATA_CONTEXT_ID = 'B0000000-0000-4000-8000-000000000001';
+const SQL_ITEM_ID = 'C0000000-0000-4000-8000-000000000001';
+const ENTITY_ITEM_ID = 'C0000000-0000-4000-8000-000000000002';
+const SECOND_SQL_ITEM_ID = 'C0000000-0000-4000-8000-000000000003';
+const NOTES_ENTITY_ID = 'E0000000-0000-4000-8000-000000000001';
+const READ_SQL = 'SELECT 1 AS One';
+
+type ItemRow = Pick<MJDataContextItemEntity,
+    'ID' | 'DataContextID' | 'Type' | 'SQL' | 'CodeName' | 'DataJSON' | 'EntityID' | 'ViewID' | 'QueryID' | 'RecordID'>;
+type ContextRow = Pick<MJDataContextEntity, 'ID' | 'Name' | 'UserID'>;
+
+function sqlItemRow(sqlText: string): ItemRow {
+    return {
+        ID: SQL_ITEM_ID, DataContextID: DATA_CONTEXT_ID, Type: 'sql', SQL: sqlText, CodeName: 'revenue',
+        DataJSON: null, EntityID: null, ViewID: null, QueryID: null, RecordID: null,
+    };
+}
+
+function entityItemRow(): ItemRow {
+    return {
+        ID: ENTITY_ITEM_ID, DataContextID: DATA_CONTEXT_ID, Type: 'full_entity', SQL: null, CodeName: 'notes',
+        DataJSON: null, EntityID: NOTES_ENTITY_ID, ViewID: null, QueryID: null, RecordID: null,
+    };
+}
+
+const DATA_CONTEXT: ContextRow = { ID: DATA_CONTEXT_ID, Name: 'Revenue review', UserID: OWNER_ID };
+
+function user(id: string, type: 'User' | 'Owner'): UserInfo {
+    const u = new UserInfo();
+    u.ID = id;
+    u.Email = `${id.slice(-4)}@example.com`;
+    u.Type = type;
+    return u;
+}
+
+const OWNER = user(OWNER_ID, 'User');
+const OTHER_USER = user('A0000000-0000-4000-8000-000000000002', 'User');
+const ADMINISTRATOR = user('A0000000-0000-4000-8000-000000000003', 'Owner');
+
+function scopeLimitedOwner(): UserInfo {
+    const u = user(OWNER_ID, 'User');
+    u.MagicLinkScope = { ResourceID: 'F0000000-0000-4000-8000-000000000001', ResourceType: 'Dashboards' };
+    return u;
+}
+
+const ENTITIES: EntityInfo[] = [
+    new EntityInfo({ ID: 'E0000000-0000-4000-8000-0000000000D1', Name: 'MJ: Data Contexts', SchemaName: '__mj', BaseView: 'vwDataContexts', BaseTable: 'DataContext' }),
+    new EntityInfo({ ID: 'E0000000-0000-4000-8000-0000000000D2', Name: 'MJ: Data Context Items', SchemaName: '__mj', BaseView: 'vwDataContextItems', BaseTable: 'DataContextItem' }),
+    new EntityInfo({
+        ID: NOTES_ENTITY_ID, Name: 'Notes', SchemaName: 'crm', BaseView: 'vwNotes', BaseTable: 'Note',
+        EntityFields: [{ ID: 'F0000000-0000-4000-8000-0000000000F1', Name: 'Body', Type: 'nvarchar', Sequence: 1, Length: 0, Precision: 0, Scale: 0 }],
+    }),
+];
+
+const NOTE_ROWS = [{ Body: 'Call back on Tuesday' }];
+
+/** The result shape a provider's ad-hoc path returns for a successful run. */
+const AD_HOC_SUCCESS: RunQueryResult = {
+    QueryID: '', QueryName: 'Ad-Hoc Query', Success: true, Results: [{ One: 1 }],
+    RowCount: 1, TotalRowCount: 1, ExecutionTime: 0, ErrorMessage: '',
+};
+
+interface QueryRun {
+    SQL: string | undefined;
+    User: UserInfo | undefined;
+}
+
+interface ViewRun {
+    Params: RunViewParams;
+    User: UserInfo | undefined;
+}
+
+/** An in-memory database provider holding one data context and its items. */
+class InMemoryProvider {
+    public readonly PlatformKey = 'sqlserver';
+    public readonly Entities = ENTITIES;
+    public readonly QueryRuns: QueryRun[] = [];
+    public readonly ViewRuns: ViewRun[] = [];
+    public readonly LoadedKeys: string[] = [];
+
+    constructor(private readonly items: ItemRow[]) {}
+
+    public async RunQuery(params: RunQueryParams, contextUser?: UserInfo): Promise<RunQueryResult> {
+        this.QueryRuns.push({ SQL: params.SQL, User: contextUser });
+        return AD_HOC_SUCCESS;
+    }
+
+    public async GetEntityObject<T>(entityName: string): Promise<T> {
+        const rows: Array<ItemRow | ContextRow> = entityName === 'MJ: Data Contexts' ? [DATA_CONTEXT] : this.items;
+        const record: Record<string, unknown> = {};
+        record.Load = async (key: string): Promise<boolean> => {
+            this.LoadedKeys.push(key);
+            const row = rows.find((r) => r.ID === key);
+            if (row) {
+                Object.assign(record, row);
+            }
+            return !!row;
+        };
+        return record as unknown as T;
+    }
+
+    public async RunView(params: RunViewParams, contextUser?: UserInfo): Promise<RunViewResult> {
+        this.ViewRuns.push({ Params: params, User: contextUser });
+        const results = params.EntityName === 'Notes'
+            ? NOTE_ROWS
+            : this.items.filter((row) => params.ExtraFilter === `DataContextID = '${row.DataContextID}'`);
+        return { Success: true, Results: results, RowCount: results.length, TotalRowCount: results.length, ExecutionTime: 0, ErrorMessage: '', UserViewRunID: '' };
+    }
+}
+
+const READ_WRITE_POOL = { Name: 'read-write connection pool' };
+const READ_ONLY_POOL = { Name: 'read-only connection pool' };
+
+interface Server {
+    ReadWrite: InMemoryProvider;
+    ReadOnly: InMemoryProvider | null;
+    Context: AppContext;
+}
+
+/** A request context the way MJAPI builds one: the read-only provider exists only with a read-only pool. */
+function server(caller: UserInfo, items: ItemRow[], withReadOnlyDatabase: boolean): Server {
+    const readWrite = new InMemoryProvider(items);
+    const readOnly = withReadOnlyDatabase ? new InMemoryProvider(items) : null;
+    const providers: Array<{ provider: InMemoryProvider; type: 'Read-Write' | 'Read-Only' }> = [{ provider: readWrite, type: 'Read-Write' }];
+    const dataSources: Array<{ dataSource: object; type: 'Read-Write' | 'Read-Only' }> = [{ dataSource: READ_WRITE_POOL, type: 'Read-Write' }];
+    if (readOnly) {
+        providers.push({ provider: readOnly, type: 'Read-Only' });
+        dataSources.push({ dataSource: READ_ONLY_POOL, type: 'Read-Only' });
+    }
+    // MJAPI's process-wide default provider is the read-write one.
+    vi.spyOn(Metadata, 'Provider', 'get').mockReturnValue(readWrite as unknown as IMetadataProvider);
+    vi.spyOn(RunView, 'Provider', 'get').mockReturnValue(readWrite as unknown as IRunViewProvider);
+    const context = { providers, dataSources, userPayload: { email: caller.Email, userRecord: caller, sessionId: 'test-session' } };
+    return { ReadWrite: readWrite, ReadOnly: readOnly, Context: context as unknown as AppContext };
+}
+
+/** Asserts that no SQL text reached any database: no raw connection, no provider ad-hoc run. */
+function expectNoSQLRan(s: Server): void {
+    expect(rawConnectionQueries).toEqual([]);
+    expect(s.ReadWrite.QueryRuns).toEqual([]);
+    expect(s.ReadOnly?.QueryRuns ?? []).toEqual([]);
+}
+
+const resolver = new GetDataContextDataResolver();
+
+beforeEach(() => {
+    rawConnectionQueries.length = 0;
+});
+
+// ─── GetDataContextItemData ──────────────────────────────────────────────────
+
+describe('GetDataContextItemData — sql items', () => {
+    it('runs the owner\'s SQL on the read-only provider, for the owner', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expect(result.Success).toBe(true);
+        expect(JSON.parse(result.Result ?? 'null')).toEqual([{ One: 1 }]);
+        expect(s.ReadOnly?.QueryRuns).toEqual([{ SQL: READ_SQL, User: OWNER }]);
+        expect(s.ReadWrite.QueryRuns).toEqual([]);
+        expect(rawConnectionQueries).toEqual([]);
+    });
+
+    it('refuses to run SQL when no read-only database is configured, instead of falling back to read-write', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], false);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/read-only/i);
+    });
+
+    it('refuses stacked statements before they reach a database', async () => {
+        const s = server(OWNER, [sqlItemRow('SELECT 1 AS One; SELECT 2 AS Two')], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/single read query/i);
+    });
+
+    it('refuses SQL that reads a table other than an entity base view', async () => {
+        const s = server(OWNER, [sqlItemRow('SELECT Email FROM __mj.[User]')], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/entity base view/i);
+    });
+
+    it('refuses to run another user\'s SQL', async () => {
+        const s = server(OTHER_USER, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/owner/i);
+    });
+
+    it('refuses to run SQL whose data context cannot be loaded, since its owner is unknown', async () => {
+        const orphan = { ...sqlItemRow(READ_SQL), DataContextID: 'B0000000-0000-4000-8000-000000000009' };
+        const s = server(OWNER, [orphan], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/owner/i);
+    });
+
+    it('refuses an item whose SQL check fails without a message', async () => {
+        vi.spyOn(RenderPipeline, 'Run').mockImplementation(() => {
+            throw new Error('');
+        });
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toBeTruthy();
+    });
+
+    it('lets an administrator (Owner-type user) run another user\'s SQL, on the read-only provider', async () => {
+        const s = server(ADMINISTRATOR, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expect(result.Success).toBe(true);
+        expect(s.ReadOnly?.QueryRuns).toEqual([{ SQL: READ_SQL, User: ADMINISTRATOR }]);
+        expect(rawConnectionQueries).toEqual([]);
+    });
+
+    it('refuses a scope-limited (magic-link) session, even for its own data context', async () => {
+        const caller = scopeLimitedOwner();
+        const s = server(caller, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextItemData(SQL_ITEM_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/scope-limited/i);
+    });
+});
+
+describe('GetDataContextItemData — other item types', () => {
+    it('loads an entity item for the calling user, with no ownership or read-only database needed', async () => {
+        const s = server(OTHER_USER, [entityItemRow()], false);
+
+        const result = await resolver.GetDataContextItemData(ENTITY_ITEM_ID, s.Context);
+
+        expect(result.Success).toBe(true);
+        expect(JSON.parse(result.Result ?? 'null')).toEqual(NOTE_ROWS);
+        const noteViewRuns = s.ReadWrite.ViewRuns.filter((run) => run.Params.EntityName === 'Notes');
+        expect(noteViewRuns.map((run) => run.User)).toEqual([OTHER_USER]);
+    });
+});
+
+// ─── GetDataContextData ──────────────────────────────────────────────────────
+
+describe('GetDataContextData — sql items', () => {
+    it('runs the owner\'s SQL items on the read-only provider', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expect(result.Success).toBe(true);
+        expect(result.ErrorMessages).toBeNull();
+        expect((result.Results ?? []).map((r) => JSON.parse(r ?? 'null'))).toEqual([[{ One: 1 }]]);
+        expect(s.ReadOnly?.QueryRuns).toEqual([{ SQL: READ_SQL, User: OWNER }]);
+        expect(rawConnectionQueries).toEqual([]);
+    });
+
+    it('refuses to run SQL items when no read-only database is configured', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], false);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect((result.ErrorMessages ?? []).join(' ')).toMatch(/read-only/i);
+    });
+
+    it('refuses to run another user\'s SQL items', async () => {
+        const s = server(OTHER_USER, [sqlItemRow(READ_SQL)], true);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect((result.ErrorMessages ?? []).join(' ')).toMatch(/owner/i);
+    });
+
+    it('refuses a DataContextID that is not a UUID before it reaches any query', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL)], true);
+        const notAnID = `${DATA_CONTEXT_ID}-1`;
+
+        const result = await resolver.GetDataContextData(notAnID, s.Context);
+
+        expect(result.Success).toBe(false);
+        const filters = [...s.ReadWrite.ViewRuns, ...(s.ReadOnly?.ViewRuns ?? [])].map((run) => run.Params.ExtraFilter ?? '');
+        const keys = [...s.ReadWrite.LoadedKeys, ...(s.ReadOnly?.LoadedKeys ?? [])];
+        expect([...filters, ...keys].filter((text) => text.includes(notAnID))).toEqual([]);
+        expectNoSQLRan(s);
+    });
+});
+
+describe('GetDataContextData — a SQL item that may not run does not stop the other items', () => {
+    it('loads the other items when no read-only database is configured', async () => {
+        const s = server(OWNER, [sqlItemRow(READ_SQL), entityItemRow()], false);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessages?.[0]).toMatch(/read-only/i);
+        expect(result.ErrorMessages?.[1]).toBeNull();
+        expect(result.Results?.[0]).toBeNull();
+        expect(JSON.parse(result.Results?.[1] ?? 'null')).toEqual(NOTE_ROWS);
+    });
+
+    it('loads the other items when the caller does not own the data context', async () => {
+        const s = server(OTHER_USER, [sqlItemRow(READ_SQL), entityItemRow()], true);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expectNoSQLRan(s);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessages?.[0]).toMatch(/owner/i);
+        expect(result.ErrorMessages?.[1]).toBeNull();
+        expect(result.Results?.[0]).toBeNull();
+        expect(JSON.parse(result.Results?.[1] ?? 'null')).toEqual(NOTE_ROWS);
+    });
+
+    it('screens each SQL item on its own and runs the ones that pass', async () => {
+        const stacked = { ...sqlItemRow('SELECT 1 AS One; SELECT 2 AS Two'), ID: SECOND_SQL_ITEM_ID };
+        const s = server(OWNER, [sqlItemRow(READ_SQL), stacked], true);
+
+        const result = await resolver.GetDataContextData(DATA_CONTEXT_ID, s.Context);
+
+        expect(rawConnectionQueries).toEqual([]);
+        expect(s.ReadOnly?.QueryRuns).toEqual([{ SQL: READ_SQL, User: OWNER }]);
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessages?.[0]).toBeNull();
+        expect(result.ErrorMessages?.[1]).toMatch(/single read query/i);
+        expect(JSON.parse(result.Results?.[0] ?? 'null')).toEqual([{ One: 1 }]);
+        expect(result.Results?.[1]).toBeNull();
+    });
+});

package/src/__tests__/ListOperationsResolver.adhocScreen.test.ts

@@ -0,0 +1,136 @@
+// type-graphql decorators need the Reflect.metadata polyfill before the resolver module loads.
+import 'reflect-metadata';
+import { describe, it, expect, beforeAll } from 'vitest';
+
+/**
+ * `PreviewListDelta` and `ComposeLists` accept `ListSourceInput{Kind:'adhoc'}`, whose `ExtraFilter`
+ * is client text that `ListOperations` hands to `RunView`. These tests drive the real resolver and
+ * the real `ListOperations` over a provider double, and pin that the filter passes the same
+ * base-view AST screen as `RunDynamicView` before any query runs. Payloads are harmless (stacked
+ * `SELECT`s); the point is only whether they reach `RunView`.
+ */
+
+import type { DatabaseProviderBase, EntityInfo, RunViewParams, RunViewResult, UserInfo } from '@memberjunction/core';
+import { GenericDatabaseProvider } from '@memberjunction/generic-database-provider';
+import { SQLServerDialect } from '@memberjunction/sql-dialect';
+import { SetDeltaTokenSecret } from '@memberjunction/lists';
+import { ComposeListsInput, ComputeDeltaInput, ListOperationsResolver, ListSourceInput } from '../resolvers/ListOperationsResolver.js';
+import type { AppContext } from '../types.js';
+
+const BRACKET_STACKED =
+    "1 = (SELECT 1 AS [a'])) ; SELECT 1 AS [x] ; SELECT * FROM crm.vwContacts WHERE (1 = (SELECT 1 AS [b'])";
+
+const USER = { ID: 'user-1', Email: 'reader@example.com', Name: 'Reader' } as UserInfo;
+
+/**
+ * Provider double: entity metadata for the screen and ListOperations, a RunView that records its
+ * params, and one snapshot-mode list whose stored `SourceFilterSnapshot` carries `snapshotWhere`.
+ */
+function fakeProvider(snapshotWhere = `Status = 'Active'`) {
+    const calls: RunViewParams[] = [];
+    const contacts = {
+        ID: '6c6a8bb6-0000-4000-8000-000000000001',
+        Name: 'Contacts',
+        SchemaName: 'crm',
+        BaseView: 'vwContacts',
+        PrimaryKeys: [{ Name: 'ID' }],
+        GetUserPermisions: () => ({ CanRead: true }),
+        GetUserRowLevelSecurityWhereClause: () => '',
+    } as unknown as EntityInfo;
+    const snapshotList = {
+        ID: 'list-1',
+        EntityID: contacts.ID,
+        SourceViewID: 'view-1',
+        UseSnapshot: true,
+        SourceFilterSnapshot: JSON.stringify({ v: 1, whereClause: snapshotWhere }),
+        Load: async () => true,
+    };
+    const provider = {
+        Entities: [contacts],
+        Dialect: new SQLServerDialect(),
+        TransformExternalSQLClause: (clause: string) => clause,
+        // The real provider screen, run against this double's entities and dialect.
+        ScreenClientClause(...args: Parameters<GenericDatabaseProvider['ScreenClientClause']>): void {
+            GenericDatabaseProvider.prototype.ScreenClientClause.apply(this as unknown as GenericDatabaseProvider, args);
+        },
+        EntityByName: (name: string) => (name.trim().toLowerCase() === 'contacts' ? contacts : undefined),
+        EntityByID: (id: string) => (id === contacts.ID ? contacts : undefined),
+        GetEntityObject: async () => snapshotList,
+        RunView: async (params: RunViewParams): Promise<RunViewResult> => {
+            calls.push(params);
+            return { Success: true, Results: [{ ID: 'r1' }], RowCount: 1, TotalRowCount: 1, ErrorMessage: '' } as RunViewResult;
+        },
+    };
+    return { provider: provider as unknown as DatabaseProviderBase, calls };
+}
+
+function context(provider: DatabaseProviderBase): AppContext {
+    return {
+        providers: [{ type: 'Read-Write', provider }],
+        userPayload: { email: USER.Email, userRecord: USER },
+    } as unknown as AppContext;
+}
+
+function adhoc(extraFilter: string): ListSourceInput {
+    return Object.assign(new ListSourceInput(), { Kind: 'adhoc', EntityName: 'Contacts', ExtraFilter: extraFilter });
+}
+
+function previewInput(source: ListSourceInput): ComputeDeltaInput {
+    return Object.assign(new ComputeDeltaInput(), { Target: 'new', Source: source, Mode: 'Additive' });
+}
+
+describe('ListOperationsResolver — ad-hoc source filters pass the clause screen', () => {
+    beforeAll(() => {
+        SetDeltaTokenSecret('unit-test-secret');
+    });
+
+    it('PreviewListDelta refuses a stacked statement hidden behind a bracket identifier, before RunView', async () => {
+        const { provider, calls } = fakeProvider();
+
+        await expect(
+            new ListOperationsResolver().PreviewListDelta(previewInput(adhoc(BRACKET_STACKED)), context(provider)),
+        ).rejects.toThrow(/Invalid ExtraFilter: multiple statements/);
+        expect(calls).toHaveLength(0);
+    });
+
+    it('PreviewListDelta refuses a subquery against a base table', async () => {
+        const { provider, calls } = fakeProvider();
+
+        await expect(
+            new ListOperationsResolver().PreviewListDelta(
+                previewInput(adhoc(`EXISTS (SELECT 1 FROM __mj.[User] WHERE [Type] = 'Owner')`)),
+                context(provider),
+            ),
+        ).rejects.toThrow(/entity base view/);
+        expect(calls).toHaveLength(0);
+    });
+
+    it('ComposeLists never runs the refused filter', async () => {
+        const { provider, calls } = fakeProvider();
+        const input = Object.assign(new ComposeListsInput(), { Op: 'union', Inputs: [adhoc(BRACKET_STACKED), adhoc(BRACKET_STACKED)] });
+
+        await expect(new ListOperationsResolver().ComposeLists(input, context(provider))).rejects.toThrow(/multiple statements/);
+        expect(calls.map((c) => c.ExtraFilter)).not.toContain(BRACKET_STACKED);
+    });
+
+    it('RefreshListFromSource screens a filter rebuilt from a stored snapshot', async () => {
+        const { provider, calls } = fakeProvider(BRACKET_STACKED);
+
+        const result = await new ListOperationsResolver().RefreshListFromSource('list-1', 'Additive', false, context(provider));
+
+        expect(calls.map((c) => c.ExtraFilter)).not.toContain(BRACKET_STACKED);
+        expect(result.Success).toBe(false);
+        expect(result.Message).toMatch(/multiple statements/);
+    });
+
+    it('still runs an ordinary ad-hoc filter', async () => {
+        const { provider, calls } = fakeProvider();
+        const filter = `Status = 'Active' AND ID IN (SELECT ID FROM crm.vwContacts WHERE Name LIKE 'O''B%')`;
+
+        const delta = await new ListOperationsResolver().PreviewListDelta(previewInput(adhoc(filter)), context(provider));
+
+        expect(calls).toHaveLength(1);
+        expect(calls[0].ExtraFilter).toBe(filter);
+        expect(delta.ToAdd).toEqual(['r1']);
+    });
+});