jschoubben
f77745d7c0
The universal consumer from ADR 0046 — no privilege, just a module that
consumes '#' and writes each event to an append-only trail. Its whole code
is on('#', record); the manifest declares consumes:['#'] and a log dir.
Records module.*, mesh.* and node.* events alike (ADR 0047's namespace).
Type-checks against @novox/mesh-sdk; the handler test records a module
event and a node event with their metadata; the manifest parses against
the consumes-enabled schema.
Claude-Session: https://claude.ai/code/session_01LrgweAeERJYBg88c5cKDzF
59 lines
2.2 KiB
TypeScript
59 lines
2.2 KiB
TypeScript
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { mkdtemp, readFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
|
|
import { useBroker } from "@novox/mesh-sdk/messaging";
|
|
import { emit, on } from "@novox/mesh-sdk/events";
|
|
import { record } from "../audit.ts";
|
|
|
|
test("audit-logger records every event to the trail as one line each", async () => {
|
|
const broker = memBroker();
|
|
useBroker(() => broker);
|
|
const dir = await mkdtemp(join(tmpdir(), "audit-"));
|
|
const path = join(dir, "audit.log");
|
|
|
|
// The audit-logger's whole behaviour: consume everything, record it.
|
|
await on("#", async (event) => record(event, path));
|
|
|
|
process.env.MESH_MODULE = "umami";
|
|
process.env.MESH_NODE = "anchor";
|
|
await emit("module.umami.site.created", { domain: "my-app" });
|
|
await emit("node.anchor.joined", { role: "worker" }); // a node event, not a module one
|
|
|
|
const lines = (await readFile(path, "utf8")).trim().split("\n").map((l) => JSON.parse(l));
|
|
assert.equal(lines.length, 2);
|
|
assert.deepEqual(lines.map((l) => l.type), ["module.umami.site.created", "node.anchor.joined"]);
|
|
assert.equal(lines[0].source, "umami");
|
|
assert.equal(lines[0].node, "anchor");
|
|
assert.equal(lines[0].body.domain, "my-app");
|
|
|
|
delete process.env.MESH_MODULE;
|
|
delete process.env.MESH_NODE;
|
|
});
|
|
|
|
function memBroker() {
|
|
const subs: { pattern: string; handler: (env: { key: string; node: string; body: unknown }) => Promise<void> }[] = [];
|
|
return {
|
|
async request() {
|
|
throw new Error("unused");
|
|
},
|
|
async handle() {
|
|
return () => {};
|
|
},
|
|
async publish<T>(env: { key: string; node: string; body: T }): Promise<void> {
|
|
for (const s of subs) if (match(s.pattern, env.key)) await s.handler(env);
|
|
},
|
|
async subscribe<T>(pattern: string, handler: (env: { key: string; node: string; body: T }) => Promise<void>): Promise<() => void> {
|
|
subs.push({ pattern, handler: handler as (env: { key: string; node: string; body: unknown }) => Promise<void> });
|
|
return () => {};
|
|
},
|
|
async close() {},
|
|
};
|
|
}
|
|
|
|
function match(pattern: string, key: string): boolean {
|
|
return pattern === "#" || pattern === key;
|
|
}
|