diff --git a/src/sql/core.ts b/src/sql/core.ts index 30f8b6e..e901059 100644 --- a/src/sql/core.ts +++ b/src/sql/core.ts @@ -1169,7 +1169,7 @@ export abstract class AbstractSQLTeaQLClient implements TeaQLDataService { const childPredicates = this.filters(childQuery).map(item => this.compileExpression(item, childSchema, values), ); - if (childSchema.columns.version) { + if (childSchema.columns.version && !this.hasExplicitVersionFilter(childQuery)) { childPredicates.push( `${this.driver.identifier(childSchema.columns.version.columnName)} > 0`, ); @@ -1227,6 +1227,18 @@ export abstract class AbstractSQLTeaQLClient implements TeaQLDataService { return query.filterCondition ? [query.filterCondition] : []; } + // Generated deletedRowsOnly requests express visibility as a version filter. + // Respect that condition at its own query level; a relation subquery's version + // must never change the parent query's default live-row visibility. + private hasExplicitVersionFilter(query: any): boolean { + const containsVersion = (expression: any): boolean => { + if (Array.isArray(expression?.$and)) return expression.$and.some(containsVersion); + return expression !== null && typeof expression === 'object' + && Object.prototype.hasOwnProperty.call(expression, 'version'); + }; + return this.filters(query).some(containsVersion); + } + private groupBy(query: any): string[] { return query._groupBy || query.groupByItems || []; } @@ -1333,7 +1345,7 @@ export abstract class AbstractSQLTeaQLClient implements TeaQLDataService { const predicates = filters.map(expression => this.compileExpression(expression, schema, values), ); - if (schema.columns.version) { + if (schema.columns.version && !this.hasExplicitVersionFilter(query)) { predicates.push( `${this.driver.identifier(schema.columns.version.columnName)} > 0`, ); --- /dev/null +++ b/tests/sql-deleted-rows.test.ts @@ -0,0 +1,95 @@ +import { UserContext } from '../src/core/context'; +import { OrderBy, SelectQuery } from '../src/core/ast'; +import { EntitySchema } from '../src/sql/core'; +import { SQLiteTeaQLClient } from '../src/sql/sqlite'; + +const schemas: Record = { + SchoolType: { + table: 'school_type_data', + columns: { + id: { columnName: 'id', logicalType: 'integer', decode: 'string' }, + version: { columnName: 'version', logicalType: 'integer', decode: 'number' }, + }, + relations: { schools: { targetEntity: 'School', localKey: 'id', foreignKey: 'schoolType', many: true } }, + }, + School: { + table: 'school_data', + columns: { + id: { columnName: 'id', logicalType: 'integer', decode: 'string' }, + version: { columnName: 'version', logicalType: 'integer', decode: 'number' }, + schoolType: { columnName: 'school_type', logicalType: 'integer', decode: 'string' }, + name: { columnName: 'name', logicalType: 'text', decode: 'native' }, + }, + }, +}; +const query = (entity: string) => new SelectQuery(entity).order(OrderBy.asc('id')).limit(10) + .comment('Read School deletion visibility').purpose('Verify explicit version selection'); +const deleted = () => query('School').filter({ $and: [ + { version: { $lte: -1 } }, { name: { $eq: 'Hill Secondary School' } }, +] }); + +let client: SQLiteTeaQLClient; +beforeEach(async () => { + client = new SQLiteTeaQLClient(':memory:', schemas); + await new UserContext().insertResource('dataService', client).ensureSchema(); + for (const id of ['1001', '1002']) await client.executeMutation({ + entity: 'SchoolType', action: 'Create', id, payload: {}, comment: 'Seed school types', + }); + for (const [id, schoolType, name] of [ + ['1', '1001', 'Riverside Primary School'], ['2', '1002', 'Hill Secondary School'], + ]) await client.executeMutation({ entity: 'School', action: 'Create', id, + payload: { schoolType, name }, comment: 'Seed School deletion regression' }); + await client.executeMutation({ entity: 'School', action: 'Delete', id: '2', version: 1, + comment: 'Retire Hill Secondary School' }); +}); +afterEach(async () => { await client.close(); }); + +test('default reads hide tombstones while the generated deleted-only filter reads one', async () => { + expect((await client.executeQuery(query('School'))).map(row => row.id)).toEqual(['1']); + const request = deleted(); + const before = JSON.stringify(request); + const auditCount = client.auditTrace.length; + for (let pass = 0; pass < 2; pass++) { + expect(await client.executeQuery(request)).toEqual([ + { id: '2', version: -2, schoolType: '1002', name: 'Hill Secondary School' }, + ]); + } + expect(JSON.stringify(request)).toBe(before); + expect(client.auditTrace).toHaveLength(auditCount); +}); + +test.each([{ version: { $lt: 0 } }, { $and: [{ $and: [{ version: { $eq: -2 } }] }] }])( + 'honors direct and nested version filters: %j', async filter => { + expect((await client.executeQuery(query('School').filter(filter))).map(row => row.id)).toEqual(['2']); + }, +); + +test('count and stream share the same deleted-only visibility', async () => { + expect(await client.executeCount(deleted())).toBe(1); + expect(await client.executeQuery(deleted().aggregate('Count', 'id', 'count'))).toEqual([{ count: 1 }]); + const ids: string[] = []; + for await (const rows of client.executeForStream(deleted(), 1)) ids.push(...rows.map(row => row.id)); + expect(ids).toEqual(['2']); +}); + +test.each(['$inSubquery', '$notInSubquery'])('subquery %s respects its own version filter', async operator => { + const request = query('SchoolType').filter({ id: { [operator]: { query: deleted(), field: 'schoolType' } } }); + expect((await client.executeQuery(request)).map(row => row.id)) + .toEqual(operator === '$inSubquery' ? ['1002'] : ['1001']); +}); + +test('child tombstone selection cannot disable the parent default filter', async () => { + await client.executeMutation({ entity: 'SchoolType', action: 'Delete', id: '1002', version: 1, + comment: 'Retire the parent for query-scope isolation' }); + const membership = { id: { $inSubquery: { query: deleted(), field: 'schoolType' } } }; + expect(await client.executeQuery(query('SchoolType').filter(membership))).toEqual([]); + expect((await client.executeQuery(query('SchoolType').filter({ $and: [ + membership, { version: { $lte: -1 } }, + ] }))).map(row => row.id)).toEqual(['1002']); +}); + +test('relation loads preserve explicit child visibility and the default for other parents', async () => { + const rows = await client.executeQuery(query('SchoolType').relationQuery('schools', deleted())); + expect(rows.map(row => [row.id, row.schools.map((school: any) => school.id)])) + .toEqual([['1001', []], ['1002', ['2']]]); +});