Spaces:
Running
Running
| import assert from 'node:assert/strict'; | |
| import {createHash, randomUUID} from 'node:crypto'; | |
| import {mkdirSync, readFileSync, readdirSync} from 'node:fs'; | |
| import {dirname, join, resolve} from 'node:path'; | |
| import {UserContext} from 'teaql-ts'; | |
| import {AbstractSQLTeaQLClient, SQLExecutionEvidenceStore} from 'teaql-ts/sql/core'; | |
| import {SQLiteDriver} from 'teaql-ts/sql/sqlite'; | |
| import {Q} from './lib/src/generated/Q'; | |
| import {E} from './lib/src/generated/E'; | |
| import {GENERATED_RUNTIME_MODULE} from './lib/src/runtime-module'; | |
| type Order = Parameters<typeof E.customerOrder>[0]; | |
| type Payment = Parameters<typeof E.payment>[0]; | |
| const manifest = (path: string): string => readdirSync(path, {withFileTypes: true}) | |
| .sort((a, b) => a.name.localeCompare(b.name)).map(entry => entry.isDirectory() | |
| ? manifest(join(path, entry.name)) | |
| : createHash('sha256').update(readFileSync(join(path, entry.name))).digest('hex')).join(''); | |
| class Driver extends SQLiteDriver { | |
| calls = 0; | |
| aggregateFailure?: Error; | |
| override async query(sql: string, values: any[] = []) { | |
| this.calls++; | |
| if (this.aggregateFailure && /COUNT\(/i.test(sql)) throw this.aggregateFailure; | |
| return super.query(sql, values); | |
| } | |
| override async *stream(sql: string, values: any[] = []) { | |
| this.calls++; | |
| yield* super.stream(sql, values); | |
| } | |
| } | |
| class Client extends AbstractSQLTeaQLClient { | |
| constructor(driver: Driver) { super(driver, GENERATED_RUNTIME_MODULE.schemas); } | |
| } | |
| async function collect<T>(stream: AsyncIterable<T>): Promise<T[]> { | |
| const result: T[] = []; | |
| for await (const row of stream) result.push(row); | |
| return result; | |
| } | |
| function relatedCount(entity: object, alias: string): number { | |
| const value = (entity as unknown as Record<string, unknown>)[alias]; | |
| assert.equal(typeof value, 'number', `related count ${alias} was not loaded`); | |
| assert(Number.isSafeInteger(value)); | |
| return value as number; | |
| } | |
| async function main() { | |
| const before = manifest('lib'); | |
| const path = resolve(process.env.TEAQL_TRACE_CHAIN_AGGREGATE_DB ?? '.local/relation-aggregate.sqlite'); | |
| mkdirSync(dirname(path), {recursive: true}); | |
| const driver = new Driver(path); | |
| const client = new Client(driver).install(GENERATED_RUNTIME_MODULE).setDiagnosticSQLLogSink(undefined); | |
| const context = new UserContext().insertResource('dataService', client); | |
| const evidence = new SQLExecutionEvidenceStore(); | |
| client.setRuntimeTelemetrySink(evidence); | |
| const group = randomUUID(), secret = 'PRIVATE-GENERATED-AGGREGATE', alias = 'matchingItems'; | |
| const ids: string[] = []; | |
| try { | |
| await context.ensureSchema(); | |
| await context.ensureSchema(); | |
| for (let i = 0; i < 2; i++) { | |
| const order = Q.customerOrders().comment('initialize aggregate fixture').purpose('verify generated relation aggregate') | |
| .newEntity(context).updatePlatform('1').updateOrderNumber(`${group}-${i}`).updateDescription(group); | |
| for (const name of [secret, 'ordinary item']) { | |
| order.orderItemList().push(Q.orderItems().comment('initialize item').purpose('verify count predicate') | |
| .newEntity(context).updateName(name)); | |
| } | |
| order.paymentList().push(Q.payments().comment('initialize payment').purpose('verify nested count') | |
| .newEntity(context).updateReferenceCode(`${group}-${i}`)); | |
| await order.auditAs('seed generated aggregate graph').save(context); | |
| ids.push(order.id!); | |
| } | |
| for (const logging of [true, false]) { | |
| client.setQueryLoggingEnabled(logging); | |
| const filtered = await Q.payments().filterByCustomerOrderIn(ids[0]).limit(1) | |
| .selectCustomerOrderWith(Q.customerOrders().withIdIs('0').limit(1)) | |
| .comment('load a filtered forward reference').purpose('distinguish NotLoaded details from null') | |
| .executeForList(context); | |
| assert.equal(filtered.length, 1); | |
| const identity = E.payment(filtered[0]).customerOrder().eval(); | |
| assert(identity, 'a filtered target must retain its actual FK identity'); | |
| assert.equal(E.customerOrder(identity).id().eval(), ids[0]); | |
| assert.throws(() => E.customerOrder(identity).description().eval(), | |
| {name: 'TeaQLNotLoadedError'}, | |
| 'unfetched description must not become a loaded-null value'); | |
| const visible = await Q.payments().filterByCustomerOrderIn(ids[0]).limit(1) | |
| .selectCustomerOrderWith(Q.customerOrders().withIdIs(ids[0]).limit(1)) | |
| .comment('load the full forward reference').purpose('verify independent detail loading') | |
| .executeForList(context); | |
| const full = E.payment(visible[0]).customerOrder().eval(); | |
| assert(full); | |
| assert.equal(E.customerOrder(full).description().eval(), group); | |
| assert.throws(() => E.customerOrder(identity).description().eval(), | |
| {name: 'TeaQLNotLoadedError'}, | |
| 'a later loaded view must not leak into the filtered edge'); | |
| console.log(`FORWARD_NOTLOADED_OBSERVED ${JSON.stringify({logging, id: ids[0]})}`); | |
| } | |
| for (const nested of [false, true]) for (const mode of ['list', 'stream-full', 'stream-tail']) { | |
| for (const logging of [true, false]) { | |
| evidence.enableAll(); | |
| client.setQueryLoggingEnabled(logging); | |
| const child = Q.orderItems().withNameIs(secret).limit(2); | |
| const orders = Q.customerOrders().withIdIn(...ids).limit(2) | |
| .countOrderItemsWith(alias, child) | |
| .selectOrderItemListWith(Q.orderItems().limit(2)); | |
| const payments = logging | |
| ? Q.payments().withCustomerOrderMatching(Q.customerOrders().withIdIn(...ids).limit(2)) | |
| : Q.payments().filterByCustomerOrderIn(...ids); | |
| const query = nested ? payments.limit(2).selectCustomerOrderWith(orders) : orders; | |
| const request = query.comment(`inspect ${secret}`).purpose('verify generated aggregate ancestry'); | |
| const start = driver.calls; | |
| const rows = mode === 'list' ? await request.executeForList(context) | |
| : await collect<Order | Payment>(request.executeForStream(context, mode === 'stream-full' ? 1 : 3)); | |
| assert.equal(rows.length, 2); | |
| const chunkCount = mode === 'stream-full' ? 2 : 1; | |
| const calls = 1 + 2 + chunkCount * (nested ? 2 : 1); | |
| assert.equal(driver.calls - start, calls, 'actual aggregate and relation SQL must execute even with logs off'); | |
| for (const row of rows) { | |
| // Narrow the public union at its known query boundary, not generated implementation state. | |
| const order = nested ? E.payment(row as Payment).customerOrder().eval() : row as Order; | |
| assert(order); | |
| assert(ids.includes(E.customerOrder(order).id().eval()!)); | |
| assert.equal(relatedCount(order, alias), 1); | |
| assert.equal(E.customerOrder(order).orderItemList().size().eval(), 2); | |
| } | |
| if (logging) { | |
| const entries = evidence.snapshot(); | |
| assert.equal(entries.length, calls); | |
| assert(!JSON.stringify(entries).includes(secret)); | |
| assert(entries.every(entry => entry.tracePath[0].name === (nested ? 'Payment' : 'CustomerOrder'))); | |
| const aggregate = entries.filter(entry => /COUNT\(/i.test(entry.parameterizedSQL)); | |
| assert.equal(aggregate.length, chunkCount); | |
| for (const entry of aggregate) { | |
| assert.deepEqual(entry.tracePath.filter(frame => frame.kind === 'relation').map(frame => frame.name), | |
| nested ? ['customerOrder', 'orderItemList'] : ['orderItemList']); | |
| } | |
| } | |
| console.log(`AGGREGATE_OBSERVED ${JSON.stringify({nested, mode, logging, rows: rows.length, calls})}`); | |
| } | |
| } | |
| client.setQueryLoggingEnabled(true); | |
| const loaded = await Q.customerOrders().withIdIs(ids[0]).countOrderItemsAs(alias) | |
| .selectOrderItemListWith(Q.orderItems().limit(2)).limit(1) | |
| .comment('load graph with a computed projection').purpose('verify aggregate is not mutation data').executeForList(context); | |
| assert.equal(relatedCount(loaded[0], alias), 2); | |
| evidence.enableAll(); | |
| await loaded[0].updateDescription(`saved-${group}`).auditAs('update aggregate-loaded graph').save(context); | |
| const writes = evidence.snapshot().filter(entry => entry.operation === 'update'); | |
| assert.equal(writes.length, 1, 'unchanged children and count projection are not mutations'); | |
| assert(!writes[0].parameterizedSQL.includes(alias)); | |
| const reloaded = await Q.customerOrders().withIdIs(ids[0]).countOrderItemsAs(alias).limit(1) | |
| .comment('recheck saved graph').purpose('verify computed count survives ordinary save').executeForList(context); | |
| assert.equal(E.customerOrder(reloaded[0]).description().eval(), `saved-${group}`); | |
| assert.equal(relatedCount(reloaded[0], alias), 2); | |
| evidence.enableAll(); | |
| const failure = new Error('generated aggregate failure'); | |
| driver.aggregateFailure = failure; | |
| await assert.rejects(collect(Q.customerOrders().withIdIn(...ids).countOrderItemsAs(alias).limit(2) | |
| .comment('reject incomplete aggregate rows').purpose('verify failed stream provenance').executeForStream(context, 1)), | |
| error => error === failure); | |
| assert.deepEqual(evidence.snapshot().map(entry => entry.executionOutcome), ['failure', 'failure']); | |
| driver.aggregateFailure = undefined; | |
| assert.equal(manifest('lib'), before, 'generated library must remain unchanged'); | |
| console.log('PASS TypeScript generated relation aggregates: 12 combinations, audited save and stream failure'); | |
| } finally { await client.close(); } | |
| } | |
| main().catch(error => { console.error(error); process.exitCode = 1; }); | |