HWLAB Code Queue
120 lines
4.6 KiB
JavaScript
120 lines
4.6 KiB
JavaScript
#!/usr/bin/env node
|
|
import assert from "node:assert/strict";
|
|
import { readFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const driftMapPath = path.join(repoRoot, "protocol/schema-drift-map.json");
|
|
|
|
const requiredKeys = [
|
|
"projectId",
|
|
"operationId",
|
|
"auditId",
|
|
"traceId",
|
|
"evidenceId",
|
|
"serviceId",
|
|
"environment",
|
|
"resourceId",
|
|
"sessionId"
|
|
];
|
|
|
|
const requiredStatuses = new Set(["aligned", "gap"]);
|
|
|
|
function assertObject(value, label) {
|
|
assert.ok(value && typeof value === "object" && !Array.isArray(value), `${label} must be an object`);
|
|
}
|
|
|
|
function loadDriftMap() {
|
|
const raw = readFile(driftMapPath, "utf8");
|
|
return raw.then((content) => JSON.parse(content));
|
|
}
|
|
|
|
function assertRequiredCoverage(map) {
|
|
assertObject(map, "drift map");
|
|
assert.equal(map.version, 1, "drift map version must be 1");
|
|
assertObject(map.summary, "drift map summary");
|
|
assert.ok(Array.isArray(map.summary.aligned), "drift map summary.aligned must be an array");
|
|
assert.ok(Array.isArray(map.entities), "drift map entities must be an array");
|
|
assert.ok(
|
|
map.entities.length >= 5,
|
|
"expected drift map entities for protocol, DB, audit, evidence chain, evidence, and deploy"
|
|
);
|
|
assertObject(map.requiredKeyCoverage, "drift map requiredKeyCoverage");
|
|
|
|
for (const key of requiredKeys) {
|
|
assert.ok(Object.hasOwn(map.requiredKeyCoverage, key), `missing required coverage for ${key}`);
|
|
const coverage = map.requiredKeyCoverage[key];
|
|
assertObject(coverage, `coverage for ${key}`);
|
|
assert.ok(Array.isArray(coverage.protocol) && coverage.protocol.length >= 1, `${key} protocol coverage must exist`);
|
|
assert.ok(
|
|
Array.isArray(coverage.dbMigration) && coverage.dbMigration.length >= 1,
|
|
`${key} dbMigration coverage must exist`
|
|
);
|
|
}
|
|
}
|
|
|
|
function assertEntityDrift(entity) {
|
|
assertObject(entity, `entity ${entity?.name ?? "<unknown>"}`);
|
|
assert.equal(typeof entity.name, "string", "entity.name must be a string");
|
|
assert.equal(typeof entity.protocol, "string", `entity ${entity.name} protocol must be a string`);
|
|
assert.ok(Array.isArray(entity.drift) && entity.drift.length >= 1, `entity ${entity.name} drift must exist`);
|
|
|
|
for (const [index, entry] of entity.drift.entries()) {
|
|
assertObject(entry, `${entity.name}.drift[${index}]`);
|
|
assert.equal(typeof entry.field, "string", `${entity.name}.drift[${index}].field must be a string`);
|
|
assert.equal(typeof entry.protocolField, "string", `${entity.name}.drift[${index}].protocolField must be a string`);
|
|
assert.equal(typeof entry.dbColumn, "string", `${entity.name}.drift[${index}].dbColumn must be a string`);
|
|
assert.ok(requiredStatuses.has(entry.status), `${entity.name}.drift[${index}].status must be aligned or gap`);
|
|
if (entry.status === "gap") {
|
|
assert.equal(typeof entry.gap, "string", `${entity.name}.drift[${index}].gap must describe the gap`);
|
|
assert.ok(entry.gap.length > 0, `${entity.name}.drift[${index}].gap must not be empty`);
|
|
}
|
|
}
|
|
}
|
|
|
|
function assertSummary(map) {
|
|
const aligned = new Set(map.summary?.aligned ?? []);
|
|
for (const key of requiredKeys) {
|
|
assert.ok(aligned.has(key), `summary.aligned must include ${key}`);
|
|
}
|
|
assert.equal(typeof map.summary.gapCount, "number", "summary.gapCount must be numeric");
|
|
assert.ok(map.summary.gapCount >= 1, "summary.gapCount must report at least one gap");
|
|
}
|
|
|
|
async function main() {
|
|
const map = await loadDriftMap();
|
|
|
|
assert.equal(map.$schema, "https://json-schema.org/draft/2020-12/schema", "drift map $schema");
|
|
assert.equal(
|
|
map.$id,
|
|
"https://hwlab.pikastech.local/protocol/schema-drift-map.json",
|
|
"drift map $id"
|
|
);
|
|
|
|
assertSummary(map);
|
|
assertRequiredCoverage(map);
|
|
|
|
let alignCount = 0;
|
|
let gapCount = 0;
|
|
for (const entity of map.entities) {
|
|
assertEntityDrift(entity);
|
|
alignCount += entity.drift.filter((entry) => entry.status === "aligned").length;
|
|
gapCount += entity.drift.filter((entry) => entry.status === "gap").length;
|
|
}
|
|
|
|
assert.equal(gapCount, map.summary.gapCount, "summary.gapCount must match computed gap count");
|
|
|
|
assert.ok(
|
|
Array.isArray(map.missingToFixBeforeRealPersistence) && map.missingToFixBeforeRealPersistence.length >= 1,
|
|
"expected a non-empty list of persistence blockers"
|
|
);
|
|
|
|
assert.ok(alignCount >= 20, "expected broad alignment coverage");
|
|
assert.ok(gapCount >= 5, "expected explicit drift gaps");
|
|
|
|
console.log(`validated schema drift map with ${alignCount} aligned fields and ${gapCount} gaps`);
|
|
}
|
|
|
|
await main();
|