Spaces:
Running
Running
File size: 9,007 Bytes
9afbea6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | 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; });
|