Spaces:
Running
Running
| import assert from 'node:assert/strict'; | |
| import Database from 'better-sqlite3'; | |
| import { createHash } from 'node:crypto'; | |
| import { mkdirSync, readFileSync, readdirSync } from 'node:fs'; | |
| import { join, resolve } from 'node:path'; | |
| import { MutationRequest, QueryRequest, UserContext } from 'teaql-ts'; | |
| import { AbstractSQLTeaQLClient, MutationResult, SQLExecutionEvidenceStore, | |
| SQLExecutionMetadata, SqlSession } from 'teaql-ts/sql/core'; | |
| import { SQLiteDriver } from 'teaql-ts/sql/sqlite'; | |
| import { Q } from './lib/src/generated/Q'; | |
| import { GENERATED_RUNTIME_MODULE } from './lib/src/runtime-module'; | |
| // Mechanical fingerprints, not generated-source API discovery. | |
| function fingerprint(directory: string, prefix = ''): string { | |
| return readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)) | |
| .map(entry => entry.isDirectory() ? fingerprint(join(directory, entry.name), `${prefix}${entry.name}/`) | |
| : `${createHash('sha256').update(readFileSync(join(directory, entry.name))).digest('hex')} ${prefix}${entry.name}\n`).join(''); | |
| } | |
| const before = fingerprint('lib'); | |
| const base = resolve(process.env.TEAQL_TRACE_CHAIN_BOOTSTRAP_DB ?? '.local/bootstrap-intent.sqlite'); | |
| mkdirSync(join(base, '..'), { recursive: true }); | |
| class Driver extends SQLiteDriver { | |
| active = false; | |
| async transaction<T>(work: (session: SqlSession) => Promise<T>): Promise<T> { | |
| this.active = true; | |
| try { return await super.transaction(work); } | |
| finally { this.active = false; } | |
| } | |
| } | |
| class Client extends AbstractSQLTeaQLClient { | |
| readonly lookups: Array<{ comment: string; purpose: string; rows: number }> = []; | |
| readonly commands: Array<{ request: MutationRequest; result: MutationResult }> = []; | |
| constructor(driver: Driver) { super(driver, GENERATED_RUNTIME_MODULE.schemas); } | |
| async executeQuery<T = any>(query: any): Promise<T[]> { | |
| const request = query instanceof QueryRequest ? query : new QueryRequest(query); | |
| const rows = await super.executeQuery<T>(query); | |
| this.lookups.push({ comment: request.comment, purpose: request.purpose, rows: rows.length }); | |
| return rows; | |
| } | |
| async executeMutation(request: any): Promise<MutationResult> { | |
| assert(request instanceof MutationRequest, 'generated bootstrap owns a validated mutation request'); | |
| const result = await super.executeMutation(request); | |
| this.commands.push({ request, result }); | |
| return result; | |
| } | |
| } | |
| function route(entry: SQLExecutionMetadata, mutation: boolean): void { | |
| assert.equal(entry.executionOutcome, 'success'); | |
| assert.deepEqual(entry.tracePath.map(node => node.kind), | |
| ['operation', mutation ? 'entity' : 'request', 'provider', 'sql']); | |
| assert.equal(entry.tracePath[0].name, 'Platform'); | |
| assert.equal(entry.tracePath[2].name, 'sqlite'); | |
| assert.equal(entry.tracePath[3].name, entry.operation); | |
| } | |
| async function run(logging: boolean): Promise<void> { | |
| const database = `${base}.${logging ? 'on' : 'off'}`; | |
| const driver = new Driver(database); | |
| const client = new Client(driver).install(GENERATED_RUNTIME_MODULE); | |
| const context = new UserContext().insertResource('dataService', client) | |
| .insertResource('bootstrapActor', 'caller-before-bootstrap') | |
| .insertResource('bootstrapCategory', 'caller-category'); | |
| client.setUserContext(context); | |
| const physical = new SQLExecutionEvidenceStore(); | |
| const diagnostics: SQLExecutionMetadata[] = []; | |
| const audits: Readonly<Record<string, unknown>>[] = []; | |
| // Install every observer BEFORE schema/startup; never replace the module's bootstrap. | |
| client.setQueryLoggingEnabled(logging).setMutationLoggingEnabled(logging) | |
| .setRuntimeTelemetrySink(physical) | |
| .setDiagnosticSQLLogSink({ write: entry => diagnostics.push(entry) }) | |
| .setAuditSink(event => { | |
| assert.equal(driver.active, false, 'audit callback must run after transaction commit'); | |
| const reader = new Database(database, { readonly: true }); | |
| try { | |
| assert.deepEqual(reader.prepare('SELECT id, version, name FROM platform_data WHERE id = 1').get(), | |
| { id: 1, version: 1, name: 'Trace Chain Verification' }, 'independent connection sees committed bootstrap'); | |
| } finally { reader.close(); } | |
| audits.push(event); | |
| }); | |
| const restored = () => { | |
| assert.equal(context.getResource('bootstrapActor'), 'caller-before-bootstrap'); | |
| assert.equal(context.getResource('bootstrapCategory'), 'caller-category'); | |
| assert.equal(context.getResource('dataService'), client); | |
| }; | |
| try { | |
| await context.ensureSchema(); | |
| restored(); | |
| assert.equal(client.lookups.length, 1, 'one actual generated root lookup'); | |
| const lookup = client.lookups[0]; | |
| assert(lookup.comment.trim() && lookup.purpose.trim(), 'runtime owns nonblank bootstrap query intent'); | |
| const firstWrites = client.commands.length; | |
| assert(firstWrites === 0 || firstWrites === 1); | |
| assert.equal(lookup.rows, firstWrites ? 0 : 1); | |
| assert.equal(audits.length, firstWrites); | |
| const entries = physical.snapshot(); | |
| assert.equal(entries.length, 1 + 2 * firstWrites, 'real root lookup plus optional write/readback'); | |
| assert.equal(diagnostics.length, logging ? entries.length : 0); | |
| route(entries[0], false); | |
| assert.equal(entries[0].comment, lookup.comment); | |
| assert.equal(entries[0].purpose, lookup.purpose); | |
| assert.equal(entries[0].resultCount, lookup.rows); | |
| if (firstWrites) { | |
| const { request, result } = client.commands[0]; | |
| assert.equal(request.mutation.entity, 'Platform'); | |
| assert.equal(request.mutation.action, 'Create'); | |
| assert(request.comment.trim(), 'runtime owns nonblank bootstrap mutation intent'); | |
| assert.equal(result.id, '1'); assert.equal(result.version, 1); | |
| const lineage = request.traceFor({ entity: 'Platform', id: result.id }); | |
| assert.deepEqual(lineage.map(node => [node.kind, node.name, node.entityId, node.detail]), | |
| [['auditReason', 'Platform', '1', request.comment]]); | |
| assert.equal(result.metadata?.statements?.length, 2); | |
| const [write, readback] = result.metadata!.statements!; | |
| route(write, true); route(readback, false); | |
| assert.equal(write.operation, 'insert'); assert.equal(write.affectedRows, 1); | |
| assert.equal(readback.operation, 'select'); assert.equal(readback.resultCount, 1); | |
| for (const raw of [write, readback]) { | |
| assert.equal(raw.auditReason, request.comment); | |
| assert.deepEqual(raw.mutationLineage, lineage); | |
| } | |
| assert.equal(readback.comment, request.comment); | |
| assert.equal(readback.purpose, 'verify persisted mutation result'); | |
| const expected = request.auditProjection({ entity: 'Platform', id: result.id }, request.mutation.payload); | |
| assert.equal(audits[0].actor, 'teaql-generated-bootstrap'); | |
| assert.equal(audits[0].category, 'runtime-bootstrap'); | |
| assert.equal(audits[0].entity, 'Platform'); assert.equal(audits[0].id, '1'); | |
| assert.equal(audits[0].reason, expected.reason); | |
| assert.deepEqual(audits[0].mutationLineage, expected.mutationLineage); | |
| for (const safe of entries.slice(1)) { | |
| route(safe, safe.operation === 'insert'); | |
| assert.equal(safe.auditReason, expected.reason); | |
| assert.deepEqual(safe.mutationLineage, expected.mutationLineage); | |
| } | |
| } | |
| physical.enableAll(); diagnostics.length = 0; audits.length = 0; | |
| client.lookups.length = 0; client.commands.length = 0; | |
| await context.ensureSchema(); | |
| restored(); | |
| assert.equal(client.commands.length, 0); assert.equal(audits.length, 0); | |
| assert.deepEqual(client.lookups, [{ ...lookup, rows: 1 }], 'repeated startup owns identical query intent'); | |
| assert.equal(client.lookups[0].comment, lookup.comment); | |
| assert.equal(physical.snapshot().length, 1); | |
| assert.equal(diagnostics.length, logging ? 1 : 0); | |
| route(physical.snapshot()[0], false); | |
| assert.equal(physical.snapshot()[0].comment, lookup.comment); | |
| assert.equal(physical.snapshot()[0].purpose, lookup.purpose); | |
| const roots = await Q.platforms().withIdIs('1').limit(1) | |
| .comment('read bootstrap root').purpose('verify generated bootstrap persistence').executeForList(context); | |
| assert.equal(roots.length, 1); assert.equal(roots[0].id, '1'); assert.equal(roots[0].version, 1); | |
| console.log(JSON.stringify({ case: 'TC-REQ-09', path: 'generated default bootstrap', logging, | |
| firstWrites, repeatWrites: 0, committedAudits: firstWrites, | |
| physicalStatements: entries.length, diagnostics: logging ? entries.length : 0, | |
| comment: lookup.comment, purpose: lookup.purpose, restoredContext: true })); | |
| } finally { await client.close(); } | |
| } | |
| async function main(): Promise<void> { | |
| for (const logging of [false, true]) await run(logging); | |
| assert.equal(fingerprint('lib'), before); | |
| console.log('PASS TypeScript generated bootstrap intent: logging off/on, committed audit, repeat no writes, unchanged generated library'); | |
| } | |
| main().catch(error => { console.error(error); process.exitCode = 1; }); | |