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

package/src/__tests__/MJStorageBlobStore.storageGate.test.ts

@@ -0,0 +1,63 @@
+/**
+ * MJStorageBlobStore (the conversation-attachment blob seam) goes from a file ID to bytes, a signed URL or a delete. The
+ * `MJ: Files` row names only a storage PROVIDER, so each path resolves through `FileStorageEngine.ResolveFileObject` —
+ * the storage gate (the caller's access on the account, and the tracked-file rule). These tests pin that download and
+ * URL ask for Read, delete asks for Write, and a refusal reads, signs and deletes nothing (the seam never throws).
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { resolveFileObject, getObject, createUrl, deleteObject } = vi.hoisted(() => ({
+    resolveFileObject: vi.fn(),
+    getObject: vi.fn(async () => Buffer.from('bytes')),
+    createUrl: vi.fn(async () => 'https://signed.example/x'),
+    deleteObject: vi.fn(async () => true),
+}));
+
+vi.mock('@memberjunction/storage', () => ({
+    FileStorageEngine: { Instance: { ResolveFileObject: resolveFileObject } },
+    StorageAccessEvaluator: { Instance: { AssertTrackedObjectsReadable: vi.fn() } },
+    FileStorageBase: class {},
+}));
+
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { MJStorageBlobStore } from '../services/MJStorageBlobStore.js';
+
+const caller = { ID: 'user-1', UserRoles: [] } as unknown as UserInfo;
+const fileRow = {
+    ID: 'file-1', ProviderID: 'prov-1', ProviderKey: 'conversation-attachments/a.png', Name: 'a.png',
+    Load: async () => true, Delete: vi.fn(async () => true),
+};
+const provider = { GetEntityObject: async () => fileRow } as unknown as IMetadataProvider;
+const driver = { GetObject: getObject, CreatePreAuthDownloadUrl: createUrl, DeleteObject: deleteObject };
+
+describe('MJStorageBlobStore — every path goes through the storage gate', () => {
+    const store = new MJStorageBlobStore();
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        resolveFileObject.mockResolvedValue({ Account: { ID: 'acct-1' }, Driver: driver, ObjectKey: fileRow.ProviderKey });
+    });
+
+    it('Download and GetDownloadUrl ask for Read, as the caller', async () => {
+        expect(await store.Download('file-1', caller, provider)).toBe(Buffer.from('bytes').toString('base64'));
+        expect(await store.GetDownloadUrl('file-1', caller, provider)).toBe('https://signed.example/x');
+        expect(resolveFileObject.mock.calls.map(c => c[2])).toEqual(['Read', 'Read']);
+        expect(resolveFileObject.mock.calls.every(c => c[1] === caller)).toBe(true);
+    });
+
+    it('Delete asks for Write', async () => {
+        expect(await store.Delete('file-1', caller, provider)).toBe(true);
+        expect(resolveFileObject.mock.calls[0][2]).toBe('Write');
+    });
+
+    it('a refusal reads, signs and deletes nothing — and the seam still does not throw', async () => {
+        resolveFileObject.mockRejectedValue(new Error('You do not have access to this file or it does not exist.'));
+        expect(await store.Download('file-1', caller, provider)).toBeNull();
+        expect(await store.GetDownloadUrl('file-1', caller, provider)).toBeNull();
+        expect(await store.Delete('file-1', caller, provider)).toBe(false);
+        expect(getObject).not.toHaveBeenCalled();
+        expect(createUrl).not.toHaveBeenCalled();
+        expect(deleteObject).not.toHaveBeenCalled();
+        expect(fileRow.Delete).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/RecordingAssemblyScheduler.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { logErrorMock, logStatusMock } = vi.hoisted(() => ({
+    logErrorMock: vi.fn(),
+    logStatusMock: vi.fn(),
+}));
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@memberjunction/core')>();
+    return { ...actual, LogError: logErrorMock, LogStatus: logStatusMock };
+});
+
+import type { DatabaseProviderBase, UserInfo } from '@memberjunction/core';
+import { ShutdownRegistry } from '@memberjunction/global';
+import type {
+    AssembleRealtimeRecordingInput, AssembleRealtimeRecordingOutcome, IRealtimeRecordingLedger,
+} from '@memberjunction/ai-agents';
+import { RecordingAssemblyScheduler } from '../realtimeSessions/RecordingAssemblyScheduler.js';
+
+const SESSION = '11111111-1111-4111-8111-111111111111';
+const OTHER = '22222222-2222-4222-8222-222222222222';
+const GRACE_MS = 90_000;
+const SYSTEM_USER = { ID: 'system-user' } as unknown as UserInfo;
+const PROVIDER = {} as unknown as DatabaseProviderBase;
+
+/** A ledger whose claim hands out increasing versions; only ClaimAssembly is used by the scheduler. */
+function makeLedger(claim: (sessionID: string) => Promise<number | null>): IRealtimeRecordingLedger {
+    return { ClaimAssembly: vi.fn(claim) } as unknown as IRealtimeRecordingLedger;
+}
+
+describe('RecordingAssemblyScheduler', () => {
+    let assemble: ReturnType<typeof vi.fn<(input: AssembleRealtimeRecordingInput) => Promise<AssembleRealtimeRecordingOutcome>>>;
+    let ledger: IRealtimeRecordingLedger;
+    let version: number;
+
+    function start(): void {
+        RecordingAssemblyScheduler.Instance.Start({
+            Provider: PROVIDER,
+            SystemUser: SYSTEM_USER,
+            GraceMs: () => GRACE_MS,
+            CreateLedger: () => ledger,
+            Assemble: assemble,
+        });
+    }
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        logErrorMock.mockReset();
+        logStatusMock.mockReset();
+        version = 0;
+        ledger = makeLedger(async () => ++version);
+        assemble = vi.fn(async () => 'Complete' as AssembleRealtimeRecordingOutcome);
+        start();
+    });
+
+    afterEach(async () => {
+        await RecordingAssemblyScheduler.Instance.Shutdown();
+        vi.useRealTimers();
+    });
+
+    it('claims and assembles when the timer fires, passing ForcePartial and the claimed version', async () => {
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, true);
+        await vi.advanceTimersByTimeAsync(999);
+        expect(assemble).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(1);
+        expect(ledger.ClaimAssembly).toHaveBeenCalledWith(SESSION, null);
+        expect(assemble).toHaveBeenCalledTimes(1);
+        expect(assemble.mock.calls[0][0]).toMatchObject({
+            SessionID: SESSION, Version: 1, Ledger: ledger, ContextUser: SYSTEM_USER, Provider: PROVIDER, ForcePartial: true,
+        });
+    });
+
+    it('keeps one timer per session: a sooner request replaces a later one, a later one is dropped', async () => {
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, GRACE_MS, true);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 5000, true);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).toHaveBeenCalledTimes(1);
+        expect(assemble.mock.calls[0][0].ForcePartial).toBe(false);
+
+        await vi.advanceTimersByTimeAsync(GRACE_MS * 2);
+        expect(assemble).toHaveBeenCalledTimes(1);
+    });
+
+    it('keeps the stronger ForcePartial when two requests fire at the same time', async () => {
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, false);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, true);
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(assemble).toHaveBeenCalledTimes(1);
+        expect(assemble.mock.calls[0][0].ForcePartial).toBe(true);
+    });
+
+    it('times sessions independently', async () => {
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, false);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(OTHER, 2000, false);
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(assemble.mock.calls.map(call => call[0].SessionID)).toEqual([SESSION, OTHER]);
+    });
+
+    it('re-schedules a Deferred assembly after the grace with ForcePartial', async () => {
+        assemble.mockResolvedValueOnce('Deferred');
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).toHaveBeenCalledTimes(1);
+
+        await vi.advanceTimersByTimeAsync(GRACE_MS - 1);
+        expect(assemble).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(assemble).toHaveBeenCalledTimes(2);
+        expect(assemble.mock.calls[1][0].ForcePartial).toBe(true);
+    });
+
+    it('does not assemble when the claim is lost, and logs it', async () => {
+        ledger = makeLedger(async () => null);
+        start();
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).not.toHaveBeenCalled();
+        expect(logStatusMock.mock.calls.some(call => String(call[0]).includes(SESSION))).toBe(true);
+    });
+
+    it('never runs the same session twice at once; a request during a run re-runs it afterwards', async () => {
+        let release: (outcome: AssembleRealtimeRecordingOutcome) => void = () => undefined;
+        assemble.mockImplementationOnce(() => new Promise(resolve => { release = resolve; }));
+
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).toHaveBeenCalledTimes(1);
+
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, true);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).toHaveBeenCalledTimes(1);
+
+        release('Complete');
+        await vi.advanceTimersByTimeAsync(0);
+        expect(assemble).toHaveBeenCalledTimes(2);
+        expect(assemble.mock.calls[1][0].ForcePartial).toBe(true);
+    });
+
+    it('logs Retry and claim failures with the session id', async () => {
+        assemble.mockResolvedValueOnce('Retry');
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(logErrorMock.mock.calls.some(call => String(call[0]).includes(SESSION))).toBe(true);
+
+        logErrorMock.mockReset();
+        ledger = makeLedger(async () => { throw new Error('db down'); });
+        start();
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(OTHER, 0, false);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(logErrorMock.mock.calls.some(call => String(call[0]).includes(OTHER) && String(call[0]).includes('db down'))).toBe(true);
+    });
+
+    it('unrefs its timers so they never keep the process alive', () => {
+        const unref = vi.fn();
+        const realSetTimeout = globalThis.setTimeout;
+        const spy = vi.spyOn(globalThis, 'setTimeout').mockImplementation(((callback: () => void, ms?: number) => {
+            const handle = realSetTimeout(callback, ms);
+            return Object.assign(handle, { unref: () => { unref(); return handle; } });
+        }) as typeof setTimeout);
+        try {
+            RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, false);
+            expect(unref).toHaveBeenCalledTimes(1);
+        } finally {
+            spy.mockRestore();
+        }
+    });
+
+    it('registers for shutdown and clears pending timers on Shutdown; later requests are logged and dropped', async () => {
+        expect(ShutdownRegistry.Instance.List()).toContain(RecordingAssemblyScheduler.Instance);
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(SESSION, 1000, false);
+        await RecordingAssemblyScheduler.Instance.Shutdown();
+        RecordingAssemblyScheduler.Instance.ScheduleAssembly(OTHER, 0, false);
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(assemble).not.toHaveBeenCalled();
+        expect(logErrorMock.mock.calls.some(call => String(call[0]).includes(OTHER))).toBe(true);
+    });
+});

package/src/__tests__/ResolverBase.adhocReadScope.test.ts

@@ -2,7 +2,8 @@
 // Reflect.metadata polyfill at import time.
 import 'reflect-metadata';
 import { describe, it, expect } from 'vitest';
-import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { DatabasePlatform, IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { RenderPipeline } from '@memberjunction/generic-database-provider';
 import { ResolverBase } from '../generic/ResolverBase.js';
 
 /**
@@ -25,8 +26,9 @@ type EntityShape = {
     deniedFields?: string[];
 };
 
-function fakeProvider(entities: EntityShape[]): IMetadataProvider {
+function fakeProvider(entities: EntityShape[], platform?: DatabasePlatform): IMetadataProvider {
     return {
+        PlatformKey: platform,
         Entities: entities.map((e) => ({
             Name: e.Name,
             SchemaName: e.SchemaName,
@@ -44,6 +46,12 @@ class Probe extends ResolverBase {
     public Screen(sql: string, provider: IMetadataProvider, user: UserInfo | undefined = USER) {
         return this.assertFullQueryUsesReadableEntityViews(sql, provider, user, 'ad-hoc SQL');
     }
+
+    /** Renders the SQL the way `ExecuteAdhocQuery` does, then screens the rendered text. */
+    public ScreenRendered(sql: string, platform: DatabasePlatform, provider: IMetadataProvider) {
+        const rendered = RenderPipeline.Run(sql, { Platform: platform, ContextUser: USER, RequireReadStatement: true });
+        return this.Screen(rendered.Trace.AfterTemplates, provider);
+    }
 }
 
 const PUBLIC_FOO: EntityShape = { Name: 'Public Foo', SchemaName: 'public', BaseView: 'vwFoo' };
@@ -88,9 +96,132 @@ describe('assertFullQueryUsesReadableEntityViews', () => {
         ).toThrow(/'Bar' is row-level-security filtered/);
     });
 
+    it('applies the scope check to a CASE subquery in the select list', () => {
+        const provider = fakeProvider([PUBLIC_FOO, { Name: 'Bar', SchemaName: 'public', BaseView: 'vwBar', rowFilter: '(1=0)' }]);
+        expect(() =>
+            new Probe().Screen('SELECT CASE WHEN (SELECT COUNT(*) FROM public.vwBar) > 0 THEN 1 ELSE 0 END AS x FROM public.vwFoo', provider),
+        ).toThrow(/'Bar' is row-level-security filtered/);
+    });
+
+    it('applies the scope check to every FROM item when an alias repeats', () => {
+        const provider = fakeProvider([PUBLIC_FOO, { Name: 'Bar', SchemaName: 'public', BaseView: 'vwBar', rowFilter: '(1=0)' }]);
+        expect(() =>
+            new Probe().Screen('SELECT a.ID FROM public.vwBar a WHERE a.ID IN (SELECT a.ID FROM public.vwFoo a)', provider),
+        ).toThrow(/'Bar' is row-level-security filtered/);
+    });
+
     it('exempts CTE names the statement defines', () => {
         expect(() =>
             new Probe().Screen('WITH x AS (SELECT ID FROM public.vwFoo) SELECT ID FROM x', fakeProvider([PUBLIC_FOO])),
         ).not.toThrow();
     });
 });
+
+describe('assertFullQueryUsesReadableEntityViews — CTE names', () => {
+    // The parser renames bracket identifiers it cannot read and maps the new names back. The CTE
+    // exemption must only cover names the statement declares, so a name of the renamed form,
+    // quoted or bare, is refused. Orders is row-filtered for the caller; Accounts is not.
+    const ACCOUNTS: EntityShape = { Name: 'Accounts', SchemaName: 'dbo', BaseView: 'vwAccounts' };
+    const ORDERS: EntityShape = { Name: 'Orders', SchemaName: 'dbo', BaseView: 'vwOrders', rowFilter: "(OwnerID = 'U1')" };
+    const DIALECTS: Array<{ Name: string; Platform: DatabasePlatform; Quote: (name: string) => string }> = [
+        { Name: 'SQL Server', Platform: 'sqlserver', Quote: (name) => `[${name}]` },
+        { Name: 'PostgreSQL', Platform: 'postgresql', Quote: (name) => `"${name}"` },
+    ];
+
+    for (const { Name, Platform, Quote } of DIALECTS) {
+        const provider = fakeProvider([ACCOUNTS, ORDERS], Platform);
+
+        it(`refuses a CTE name reserved for the SQL parser, before reading any view (${Name})`, () => {
+            const sql = `WITH ${Quote('a b')} AS (SELECT 1 AS x), _mjid_1 AS (SELECT 1 AS y) SELECT * FROM ${Quote('vwOrders')}`;
+
+            expect(() => new Probe().ScreenRendered(sql, Platform, provider)).toThrow(/reserved for the SQL parser/);
+        });
+
+        it(`refuses a reserved name in any case or quoting (${Name})`, () => {
+            for (const name of ['_MJID_1', Quote('_mjid_1'), '_mjid2_0']) {
+                const sql = `WITH ${Quote('a b')} AS (SELECT 1 AS x), ${name} AS (SELECT 1 AS y) SELECT * FROM ${Quote('vwAccounts')}`;
+                expect(() => new Probe().ScreenRendered(sql, Platform, provider)).toThrow(/reserved for the SQL parser/);
+            }
+        });
+
+        it(`still exempts an ordinary quoted CTE name and screens its body (${Name})`, () => {
+            const cte = Quote('Recent Accounts');
+            const reads = (view: string) => `WITH ${cte} AS (SELECT ID FROM ${Quote(view)}) SELECT ID FROM ${cte}`;
+
+            expect(() => new Probe().ScreenRendered(reads('vwAccounts'), Platform, provider)).not.toThrow();
+            expect(() => new Probe().ScreenRendered(reads('vwOrders'), Platform, provider)).toThrow(/'Orders' is row-level-security filtered/);
+        });
+
+        it(`still refuses a row-filtered view read next to an ordinary quoted CTE (${Name})`, () => {
+            const sql = `WITH ${Quote('a b')} AS (SELECT 1 AS x) SELECT * FROM ${Quote('vwOrders')}`;
+
+            expect(() => new Probe().ScreenRendered(sql, Platform, provider)).toThrow(/'Orders' is row-level-security filtered/);
+        });
+    }
+});
+
+describe('assertFullQueryUsesReadableEntityViews — the CTE exemption covers only a CTE in scope', () => {
+    // Orders is row-filtered for the caller; Accounts is not. Each refused statement reads the real
+    // Orders view at a point where no CTE of that name is in scope, so the read must be checked.
+    const ACCOUNTS: EntityShape = { Name: 'Accounts', SchemaName: 'dbo', BaseView: 'vwAccounts' };
+    const ORDERS: EntityShape = { Name: 'Orders', SchemaName: 'dbo', BaseView: 'vwOrders', rowFilter: "(OwnerID = 'U1')" };
+    const ROW_FILTERED = /'Orders' is row-level-security filtered/;
+    const providers: Record<DatabasePlatform, IMetadataProvider> = {
+        sqlserver: fakeProvider([ACCOUNTS, ORDERS], 'sqlserver'),
+        postgresql: fakeProvider([ACCOUNTS, ORDERS], 'postgresql'),
+    };
+    const screen = (sql: string, platform: DatabasePlatform) => () => new Probe().ScreenRendered(sql, platform, providers[platform]);
+
+    it('refuses a schema-qualified read of a view a CTE is named after (SQL Server dbo, PostgreSQL)', () => {
+        expect(screen('WITH vwOrders AS (SELECT 1 AS y) SELECT * FROM dbo.vwOrders', 'sqlserver')).toThrow(ROW_FILTERED);
+        expect(screen('WITH "vwOrders" AS (SELECT 1 AS y) SELECT * FROM dbo."vwOrders"', 'postgresql')).toThrow(ROW_FILTERED);
+    });
+
+    it('refuses a read outside the subquery or branch whose WITH declares the name (PostgreSQL)', () => {
+        const statements = [
+            'SELECT o.* FROM (WITH "vwOrders" AS (SELECT 1 AS a) SELECT * FROM "vwOrders") s CROSS JOIN "vwOrders" o',
+            'SELECT "ID" FROM "vwAccounts" WHERE EXISTS (WITH "vwOrders" AS (SELECT 1 AS a) SELECT 1 FROM "vwOrders") AND "ID" IN (SELECT "ID" FROM "vwOrders")',
+            'WITH a AS (WITH "vwOrders" AS (SELECT 1 AS x) SELECT * FROM "vwOrders") SELECT * FROM a, "vwOrders"',
+            'SELECT * FROM ((WITH "vwOrders" AS (SELECT 1 AS "ID") SELECT "ID" FROM "vwOrders") UNION SELECT "ID" FROM "vwOrders") u',
+        ];
+        for (const sql of statements) {
+            expect(screen(sql, 'postgresql')).toThrow(ROW_FILTERED);
+        }
+    });
+
+    it('refuses a read in a CTE body that does not see that CTE yet (PostgreSQL without RECURSIVE, SQL Server)', () => {
+        expect(screen('WITH "vwOrders" AS (SELECT * FROM "vwOrders") SELECT * FROM "vwOrders"', 'postgresql')).toThrow(ROW_FILTERED);
+        expect(screen('WITH a AS (SELECT * FROM "vwOrders"), "vwOrders" AS (SELECT 1 AS y) SELECT * FROM a', 'postgresql')).toThrow(ROW_FILTERED);
+        expect(screen('WITH a AS (SELECT * FROM vwOrders), vwOrders AS (SELECT 1 AS y) SELECT * FROM a', 'sqlserver')).toThrow(ROW_FILTERED);
+    });
+
+    it('refuses a quoted read whose name differs from the CTE name once PostgreSQL case rules apply', () => {
+        expect(screen('WITH vworders AS (SELECT 1 AS y) SELECT * FROM "vwOrders"', 'postgresql')).toThrow(ROW_FILTERED);
+        expect(screen('WITH "VWORDERS" AS (SELECT 1 AS y) SELECT * FROM "vwOrders"', 'postgresql')).toThrow(ROW_FILTERED);
+    });
+
+    it('still exempts ordinary CTE references (SQL Server)', () => {
+        const statements = [
+            'WITH Recent AS (SELECT ID FROM vwAccounts) SELECT ID FROM recent',
+            'WITH r AS (SELECT ID FROM vwAccounts UNION ALL SELECT ID FROM r WHERE 1 = 0) SELECT ID FROM r',
+            'WITH a AS (SELECT ID FROM vwAccounts), b AS (SELECT ID FROM a) SELECT ID FROM b WHERE ID IN (SELECT ID FROM a UNION SELECT ID FROM a)',
+        ];
+        for (const sql of statements) {
+            expect(screen(sql, 'sqlserver')).not.toThrow();
+        }
+    });
+
+    it('still exempts ordinary CTE references (PostgreSQL)', () => {
+        const statements = [
+            'WITH recent AS (SELECT "ID" FROM "vwAccounts") SELECT "ID" FROM Recent',
+            'WITH "Recent" AS (SELECT "ID" FROM "vwAccounts") SELECT "ID" FROM "Recent"',
+            'WITH RECURSIVE r AS (SELECT 1 AS n UNION ALL SELECT n + 1 FROM r WHERE n < 3) SELECT n FROM r',
+            'WITH RECURSIVE a AS (SELECT * FROM b), b AS (SELECT "ID" FROM "vwAccounts") SELECT * FROM a',
+            'SELECT * FROM (WITH x AS (SELECT "ID" FROM "vwAccounts") SELECT * FROM x) s',
+            'WITH a AS (SELECT "ID" FROM "vwAccounts") SELECT "ID" FROM (SELECT "ID" FROM a) s WHERE "ID" IN (SELECT "ID" FROM a UNION SELECT "ID" FROM a)',
+        ];
+        for (const sql of statements) {
+            expect(screen(sql, 'postgresql')).not.toThrow();
+        }
+    });
+});

package/src/__tests__/ResolverBase.balancedClause.test.ts

@@ -0,0 +1,155 @@
+// ResolverBase transitively pulls in type-graphql decorators, which need the
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect } from 'vitest';
+import type { DatabaseProviderBase, IMetadataProvider, RunViewParams, RunViewResult, UserInfo } from '@memberjunction/core';
+import type { PubSubEngine } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import type { RunDynamicViewInput } from '../generic/RunViewResolver.js';
+import type { UserPayload } from '../types.js';
+
+/**
+ * The provider splices a client ExtraFilter as `(<ExtraFilter>) AND (<row-level security>)` and the
+ * tenant hook as `(<ExtraFilter>) AND (<tenant>)`. A fragment that closes a parenthesis it did not
+ * open, such as `1=1) OR (1=1`, turns that into `(1=1) OR (1=1) AND (<rls>)`. AND binds tighter than
+ * OR, so the server filter then narrows only one side of an OR the caller controls.
+ *
+ * The boundary screen parsed each fragment inside the parentheses it adds itself, which hides exactly
+ * that imbalance. These tests pin that the screen requires every fragment to be balanced on its own.
+ */
+
+const ENTITY_NAME = 'MJ: Conversations';
+
+/** Captures what the resolver asked `RunView` for. */
+type Captured = { params: RunViewParams | null };
+
+function fakeProvider(captured: Captured): DatabaseProviderBase {
+    return {
+        Entities: [
+            {
+                ID: 'E1',
+                Name: ENTITY_NAME,
+                SchemaName: '__mj',
+                BaseView: 'vwConversations',
+                BaseTable: 'Conversation',
+                Fields: [{ Name: 'Name', NeedsQuotes: true }],
+                GetUserPermisions: () => ({ CanRead: true }),
+            },
+        ],
+        RunView: async (params: RunViewParams): Promise<RunViewResult> => {
+            captured.params = params;
+            return { Success: true, Results: [], RowCount: 0, TotalRowCount: 0, ErrorMessage: '' } as RunViewResult;
+        },
+    } as unknown as DatabaseProviderBase;
+}
+
+const fakeUser = () => ({ Email: 'tester@example.com' } as UserInfo);
+const fakePayload = () => ({ email: 'tester@example.com', userRecord: fakeUser() } as UserPayload);
+
+/** Reaches the protected boundary screen and the dynamic-view entry point. */
+class Probe extends ResolverBase {
+    public ScreenClause(clause: string, label: string, provider: DatabaseProviderBase): void {
+        this.assertClientClauseUsesEntityBaseViews(clause, label, provider as unknown as IMetadataProvider);
+    }
+
+    public RunDynamic(input: RunDynamicViewInput, provider: DatabaseProviderBase) {
+        return this.RunDynamicViewGeneric(input, provider, fakePayload(), undefined as unknown as PubSubEngine);
+    }
+}
+
+describe('ResolverBase boundary screen — a client filter must be one balanced expression', () => {
+    const provider = () => fakeProvider({ params: null });
+
+    // Each of these closes the parentheses the provider wraps the fragment in. All of them parse
+    // once the screen adds its own `(` … `)`, which is why the screen must check them standalone.
+    const escapes = [
+        '1=1) OR (1=1',
+        "Name = 'a') OR (Name = 'b'",
+        "[Name] = 'a') OR ([Name] = 'b'",
+        '(1=1)) OR ((1=1)',
+    ];
+
+    it.each(escapes)('rejects the ExtraFilter %j', (clause) => {
+        expect(() => new Probe().ScreenClause(clause, 'ExtraFilter', provider())).toThrow(/parenthesis/);
+    });
+
+    it.each(escapes)('rejects the OverrideExcludeFilter %j', (clause) => {
+        expect(() => new Probe().ScreenClause(clause, 'OverrideExcludeFilter', provider())).toThrow(/parenthesis/);
+    });
+
+    it('rejects a fragment that leaves a parenthesis open', () => {
+        expect(() => new Probe().ScreenClause('(1=1', 'ExtraFilter', provider())).toThrow();
+    });
+
+    it('allows a balanced filter, including parentheses inside string literals', () => {
+        const p = new Probe();
+        const md = provider();
+        expect(() => p.ScreenClause("(Name = 'a' OR Name = 'b') AND (Name <> 'c')", 'ExtraFilter', md)).not.toThrow();
+        expect(() => p.ScreenClause("Name = 'a) OR (b'", 'ExtraFilter', md)).not.toThrow();
+        expect(() => p.ScreenClause("Name LIKE '%(%'", 'OverrideExcludeFilter', md)).not.toThrow();
+    });
+
+    it('RunDynamicViewGeneric never reaches RunView with an ExtraFilter that closes the wrapper', async () => {
+        const captured: Captured = { params: null };
+        const input = { EntityName: ENTITY_NAME, ExtraFilter: '1=1) OR (1=1' } as RunDynamicViewInput;
+
+        await expect(new Probe().RunDynamic(input, fakeProvider(captured))).rejects.toThrow(/parenthesis/);
+        expect(captured.params).toBeNull();
+    });
+
+    it('RunDynamicViewGeneric passes a balanced ExtraFilter through unchanged', async () => {
+        const captured: Captured = { params: null };
+        const input = { EntityName: ENTITY_NAME, ExtraFilter: "Name = 'a' OR Name = 'b'" } as RunDynamicViewInput;
+
+        await new Probe().RunDynamic(input, fakeProvider(captured));
+
+        expect(captured.params?.ExtraFilter).toBe("Name = 'a' OR Name = 'b'");
+    });
+
+    it('rejects a comment', () => {
+        expect(() => new Probe().ScreenClause("Name = 'a' -- note\n", 'ExtraFilter', provider())).toThrow(/comment/);
+        expect(() => new Probe().ScreenClause("Name = 'a' /* note */", 'OrderBy', provider())).toThrow(/comment/);
+    });
+});
+
+describe('ResolverBase boundary screen — backslashes inside quotes', () => {
+    // The screen's parser reads a backslash before a quote inside a plain literal as an escaped
+    // quote; SQL Server and PostgreSQL read the quote as the end of the literal. Text after it can
+    // then be code the engine runs while the parser saw a string, so it escapes the screen's checks.
+    const provider = () => fakeProvider({ params: null });
+
+    it('rejects a filter whose hidden part the parser reads as a string constant', () => {
+        const hidesSelect = "Name = 'a\\' AND 1 = (SELECT 1) AND Name = ' + [b' + [c]";
+        expect(() => new Probe().ScreenClause(hidesSelect, 'ExtraFilter', provider())).toThrow(/backslash/);
+        expect(() => new Probe().ScreenClause(hidesSelect, 'OverrideExcludeFilter', provider())).toThrow(/backslash/);
+    });
+
+    it.each(["Path = 'C:\\temp'", '[a\\b] = 1', '"a\\b" = 1'])('rejects a backslash inside a quoted string or identifier (%#)', (clause) => {
+        expect(() => new Probe().ScreenClause(clause, 'ExtraFilter', provider())).toThrow(/backslash/);
+    });
+
+    it('allows a filter with no backslash inside quotes', () => {
+        expect(() => new Probe().ScreenClause("Path LIKE 'C:/temp%'", 'ExtraFilter', provider())).not.toThrow();
+    });
+});
+
+/** Named so the screen reads clauses with the PostgreSQL dialect, as it does for the real provider. */
+class PostgreSQLDataProviderFake {
+    public Entities = [];
+}
+
+describe('ResolverBase boundary screen — PostgreSQL', () => {
+    const pgProvider = () => new PostgreSQLDataProviderFake() as unknown as DatabaseProviderBase;
+
+    it.each([
+        ['Name = $$x$$', /dollar/],
+        ['Café = 1', /outside ASCII/],
+        ["Name = E'x'\n'y'", /escape string/],
+    ])('rejects what the lexer cannot read the way PostgreSQL does (%#)', (clause, reason) => {
+        expect(() => new Probe().ScreenClause(clause, 'ExtraFilter', pgProvider())).toThrow(reason);
+    });
+
+    it('allows text outside ASCII inside a string literal', () => {
+        expect(() => new Probe().ScreenClause("Name = 'Café'", 'ExtraFilter', pgProvider())).not.toThrow();
+    });
+});