@mason-data/cli 0.0.0-stage → 0.6.2

package/dist/src/duck/publication.js

@@ -0,0 +1,207 @@
+const requiredOf = (t) => t.columns.filter((c) => !c.generated).map((c) => c.name);
+/** what follows every refusal: Mason waits for the owner, and when it looks again */
+const NEVER_ALTERED = "Mason reads a publication it is given as it is, never altering it: once its owner has run that, the next mason start " +
+    "(or mason add) checks it again. Or mason start --replication without --publication, where Mason makes its own (not on a read " +
+    "replica), or mason start --poll, which needs no publication.";
+/**
+ * The verdict over a described publication (pure: `described` is what `readNamedPublication` read). `identities` are
+ * the tables' `relreplident`: a table whose identity is not its key is expected WHOLE (a column list missing an
+ * identity column would make the app's UPDATEs fail).
+ */
+export function namedPublicationVerdict(described, tables, identities) {
+    const whole = new Set(tables.filter((t) => identities.get(t.source) !== "d").map((t) => t.source));
+    const pub = described.publication;
+    const noTruncate = pub.exists && !pub.publish.includes("truncate");
+    if (!pub.exists || !["insert", "update", "delete"].every((k) => pub.publish.includes(k))) {
+        const all = new Map(tables.map((t) => [t.source, requiredOf(t)]));
+        const m = checkPublication(all, described, whole) ?? `publication ${pub.name} cannot be read (Mason bug: report it)`;
+        return { refused: `${m}\n\n${NEVER_ALTERED}`, tables: new Map(), noTruncate };
+    }
+    const out = new Map();
+    for (const t of tables) {
+        const m = checkPublication(new Map([[t.source, requiredOf(t)]]), described, whole);
+        if (m !== null)
+            out.set(t.source, `${m}\n\n${NEVER_ALTERED}`);
+    }
+    return { refused: null, tables: out, noTruncate };
+}
+// ------------------------------------------------------------------ the check
+const q = (s) => /^[a-z_][a-z0-9_]*$/.test(s) ? s : `"${s.replace(/"/g, '""')}"`;
+const qualified = (t) => t.split(".").map(q).join(".");
+/** `schema.table (a, b, c)`, one per line, as a publication's table list reads. */
+function tableLines(tables, columnLists) {
+    return [...tables.entries()].sort(([a], [b]) => a.localeCompare(b))
+        .map(([t, cols]) => `    ${qualified(t)}${columnLists && cols !== null ? ` (${cols.map(q).join(", ")})` : ""}`);
+}
+/** A table's columns in the catalog's order. */
+const inCatalogOrder = (d, cols) => {
+    const want = new Set(cols);
+    return d === undefined ? [...want] : d.columns.filter((c) => want.has(c));
+};
+/**
+ * What the publication lacks of the copy's tables and columns, as the message that refuses them, or null when it
+ * lacks nothing: each missing table or column, the publication EXPECTED (what it streams now PLUS what is missing,
+ * never less: the publication is the owner's "replicate this"), and the one FOUND. Refused besides a missing piece: a
+ * publication that does not publish every insert, update and delete, and a row filter on a copied table. A table the
+ * database does not have is no concern of the publication's (the copy refuses it).
+ */
+function checkPublication(required, described, whole) {
+    const pub = described.publication;
+    const columnLists = described.serverVersion >= 150000;
+    const problems = [];
+    const missingLines = [];
+    for (const [table, cols] of [...required.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        const d = described.tables.get(table);
+        if (d === undefined || !pub.exists)
+            continue;
+        if (d.published === null) {
+            problems.push(`${table} is not published`);
+            missingLines.push(`  missing: ${table} (read by Mason's copy)`);
+            continue;
+        }
+        const lacking = inCatalogOrder(d, cols).filter((c) => !d.published.includes(c));
+        if (lacking.length) {
+            problems.push(`${table} columns ${lacking.join(", ")} are not published`);
+            missingLines.push(`  missing: ${table} columns ${lacking.join(", ")} (read by Mason's copy)`);
+        }
+        if (d.rowFilter !== null) {
+            problems.push(`${table} is published with a row filter`);
+            missingLines.push(`  row filter: ${table} is published WHERE ${d.rowFilter}; a row the filter leaves out never ` +
+                `arrives, and neither does its delete. Publish the whole table.`);
+        }
+    }
+    if (!pub.exists)
+        problems.push(`publication ${pub.name} does not exist`);
+    const publishes = ["insert", "update", "delete"].filter((k) => !pub.publish.includes(k));
+    if (pub.exists && publishes.length)
+        problems.push(`publication ${pub.name} does not publish ${publishes.join(", ")}`);
+    if (problems.length === 0)
+        return null;
+    // EXPECTED: what it streams now, plus what the copy needs
+    const expected = new Map();
+    for (const [t, d] of described.tables)
+        if (d.published !== null)
+            expected.set(t, [...d.published]);
+    for (const [table, cols] of required) {
+        const d = described.tables.get(table);
+        if (d === undefined)
+            continue;
+        expected.set(table, inCatalogOrder(d, [...(expected.get(table) ?? []), ...cols]));
+    }
+    for (const t of whole)
+        if (expected.has(t))
+            expected.set(t, null);
+    const expectedSql = !pub.exists
+        ? [`  CREATE PUBLICATION ${q(pub.name)} FOR TABLE`, tableLines(expected, columnLists).join(",\n"), `  WITH (publish = 'insert, update, delete');`]
+        : addStatements(pub, required, described, expected, columnLists, publishes);
+    const found = new Map();
+    for (const [t, d] of described.tables)
+        if (d.published !== null)
+            found.set(t, d.published);
+    const foundSql = pub.exists
+        ? [`Found: publication ${pub.name} (publish = '${pub.publish.join(", ")}'${pub.allTables ? ", FOR ALL TABLES" : ""})`,
+            (found.size ? tableLines(found, columnLists).join(",\n") : "    (no tables)")]
+        : [`Found: no publication named ${pub.name}. Publications on this database: ${pub.others.length ? pub.others.join(", ") : "none"}.`];
+    return [
+        `publication ${pub.name} does not carry what Mason's copy of the table holds.`,
+        "",
+        ...(missingLines.length ? [...missingLines, ""] : []),
+        ...(publishes.length && pub.exists ? [`  it publishes ${pub.publish.join(", ") || "nothing"}; the change reader needs insert, update and delete`, ""] : []),
+        `Expected (run as the tables' owner, or add it to your migrations):`,
+        ...expectedSql,
+        ...(columnLists ? [] : [`  (Postgres ${described.serverVersion} publishes whole tables: column lists need Postgres 15)`]),
+        "",
+        ...foundSql,
+    ].join("\n");
+}
+/**
+ * The gap alone, as statements on the publication as it is: a table it lacks ADDED; one whose column list lacks a
+ * column, or that carries a row filter, dropped and added again with the found columns plus the missing ones, in one
+ * transaction (no statement widens one table's column list or drops its filter); the publish list widened by what is
+ * missing, what it published kept — never a restatement of the whole list, which could drop what the owner published.
+ */
+function addStatements(pub, required, described, expected, columnLists, publishes) {
+    const missing = [], changed = [];
+    for (const [table, cols] of [...required.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        const d = described.tables.get(table);
+        if (d === undefined)
+            continue;
+        if (d.published === null)
+            missing.push(table);
+        else if (d.rowFilter !== null || cols.some((c) => !d.published.includes(c)))
+            changed.push(table);
+    }
+    const added = new Map([...changed, ...missing].map((t) => [t, expected.get(t) ?? null]));
+    const publish = ["insert", "update", "delete", "truncate"].filter((k) => pub.publish.includes(k) || publishes.includes(k));
+    return [
+        ...(changed.length ? ["  BEGIN;", `  ALTER PUBLICATION ${q(pub.name)} DROP TABLE ${changed.map(qualified).join(", ")};`] : []),
+        ...(added.size ? [`  ALTER PUBLICATION ${q(pub.name)} ADD TABLE`, tableLines(added, columnLists).join(",\n") + ";"] : []),
+        ...(publishes.length ? [`  ALTER PUBLICATION ${q(pub.name)} SET (publish = '${publish.join(", ")}');`] : []),
+        ...(changed.length ? ["  COMMIT;"] : []),
+    ];
+}
+// ------------------------------------------------------------------ the catalog
+const lit = (s) => "'" + s.replace(/'/g, "''") + "'";
+/**
+ * The one catalog query: the publication, and every table it streams or the copy holds (by `schema.table`), each with
+ * its columns in the catalog's order and what the publication carries of it, in one JSON value. Column lists and row
+ * filters exist from Postgres 15. Read-only: the catalog, never a row of data.
+ */
+export function publicationQuery(publication, tables, version) {
+    const modern = version >= 150000;
+    const names = tables.length === 0 ? "NULL" : tables.map(lit).join(", ");
+    return `WITH pt AS (
+  SELECT schemaname || '.' || tablename AS t, ${modern ? "to_json(attnames::text[])" : "NULL::json"} AS cols, ${modern ? "rowfilter" : "NULL::text"} AS rf
+  FROM pg_publication_tables WHERE pubname = ${lit(publication)}
+), wanted AS (
+  SELECT c.oid, n.nspname || '.' || c.relname AS t
+  FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE c.relkind IN ('r', 'p') AND (n.nspname || '.' || c.relname IN (SELECT t FROM pt) OR n.nspname || '.' || c.relname IN (${names}))
+)
+SELECT json_build_object(
+  'version', current_setting('server_version_num')::int,
+  'publication', (SELECT json_build_object('all_tables', puballtables, 'publish', to_json(array_remove(ARRAY[
+      CASE WHEN pubinsert THEN 'insert' END, CASE WHEN pubupdate THEN 'update' END,
+      CASE WHEN pubdelete THEN 'delete' END, CASE WHEN pubtruncate THEN 'truncate' END], NULL)))
+    FROM pg_publication WHERE pubname = ${lit(publication)}),
+  'others', (SELECT coalesce(json_agg(pubname ORDER BY pubname), '[]'::json) FROM pg_publication WHERE pubname <> ${lit(publication)}),
+  'tables', (SELECT coalesce(json_agg(json_build_object(
+    't', w.t,
+    'columns', (SELECT coalesce(json_agg(a.attname ORDER BY a.attnum), '[]'::json)
+      FROM pg_attribute a WHERE a.attrelid = w.oid AND a.attnum > 0 AND NOT a.attisdropped),
+    'in_publication', EXISTS (SELECT 1 FROM pt WHERE pt.t = w.t),
+    'published', (SELECT pt.cols FROM pt WHERE pt.t = w.t),
+    'row_filter', (SELECT pt.rf FROM pt WHERE pt.t = w.t)
+  ) ORDER BY w.t), '[]'::json) FROM wanted w)
+)::text`;
+}
+/** A catalog answer described: before Postgres 15 a publication carries whole rows, every column of a table it names. */
+export function describedOf(answer, publication) {
+    return {
+        publication: { name: publication, exists: answer.publication !== null, publish: answer.publication?.publish ?? [], allTables: answer.publication?.all_tables ?? false, others: answer.others },
+        tables: new Map(answer.tables.map((t) => [t.t, { columns: t.columns, published: t.in_publication ? (t.published ?? t.columns) : null, rowFilter: t.row_filter }])),
+        serverVersion: answer.version,
+    };
+}
+/** The named publication and the copied tables as the live catalog describes them: read-only, two statements.
+ *  (`_project`, the project's name, is unused: the tables are found by their own names.) */
+export async function readNamedPublication(pg, publication, tables, _project) {
+    const one = async (sql) => {
+        const v = (await pg.query(sql)).rows[0]?.[0];
+        if (typeof v !== "string")
+            throw new Error("a catalog query answered no value");
+        return v;
+    };
+    const version = Number(await one("SELECT current_setting('server_version_num')"));
+    if (!Number.isInteger(version) || version <= 0)
+        throw new Error("the server's version did not read as a number");
+    const text = await one(publicationQuery(publication, tables.map((t) => t.source), version));
+    let answer;
+    try {
+        answer = JSON.parse(text);
+    }
+    catch (e) {
+        throw new Error(`the publication's catalog query did not answer JSON (${e.message}): ${text.slice(0, 200)}`);
+    }
+    return describedOf(answer, publication);
+}

package/dist/src/duck/requests.js

@@ -0,0 +1,209 @@
+import { outcomeOf } from "../api/request-log.js";
+import { MASON_SCHEMA } from "./store.js";
+export const REQUESTS_TABLE = `${MASON_SCHEMA}.requests`;
+/** How many days of requests are kept unless MASON_REQUEST_LOG_DAYS says. */
+export const DEFAULT_REQUEST_LOG_DAYS = 7;
+const FLUSH_MS = 1000;
+const BATCH_ROWS = 1000;
+/** how often the rows past the retention are deleted (and once at open) */
+const TRIM_EVERY_MS = 60 * 60 * 1000;
+/**
+ * The days MASON_REQUEST_LOG_DAYS keeps, or why the text is not a number of days. Unset or empty: the default.
+ */
+export function requestLogDays(text) {
+    if (text === undefined || text.trim() === "")
+        return DEFAULT_REQUEST_LOG_DAYS;
+    const days = Number(text);
+    if (!Number.isInteger(days) || days < 1) {
+        return { problem: `MASON_REQUEST_LOG_DAYS=${JSON.stringify(text)} is not a number of days: write a whole number, 1 or more (unset, ${DEFAULT_REQUEST_LOG_DAYS})` };
+    }
+    return days;
+}
+/** A request's outcome in a word, from its SQLSTATE (src/api/request-log.ts: the listener's refusal line reads it too). */
+export { outcomeOf };
+const COLUMNS = ["request_id", "started_at", "session", "application_name", "token_name", "user_name", "method", "sqlstate", "message", "detail", "hint",
+    "rows", "duration_ms", "query", "query_truncated", "seq", "json_reads"];
+/** the ledger's DDL: one row per request, named for a developer who knows pg_stat_activity */
+/** a ledger made before `mason user` gains its column; a column added last is named in every INSERT */
+export const REQUESTS_USER_DDL = `ALTER TABLE ${REQUESTS_TABLE} ADD COLUMN IF NOT EXISTS user_name VARCHAR`;
+/**
+ * The ledger's ORDER within a millisecond: `started_at` is the clock's millisecond and `request_id` a random
+ * UUID, so two requests recorded in one millisecond — a refused login and the statement before it — read back in either
+ * order. Every row is numbered as it is recorded (`seq`, continuing from the ledger's last number at open), and the
+ * ledger is read by start time THEN seq: the order the listener saw, never the UUID's. A ledger made before gains the
+ * column; its old rows (seq NULL) are older than any new one by more than a millisecond.
+ */
+export const REQUESTS_SEQ_DDL = `ALTER TABLE ${REQUESTS_TABLE} ADD COLUMN IF NOT EXISTS seq BIGINT`;
+/**
+ * THE JSON PATHS EACH STATEMENT READ: a JSON array of the copied tables' JSON columns read by literal steps
+ * (src/duck/kept-route.ts readKey), NULL for none — what decides which paths Mason stores as columns (src/duck/kept.ts
+ * `review`: read by several statements, or by a slow one, within the log's retention). A ledger made before gains it.
+ */
+export const REQUESTS_JSON_DDL = `ALTER TABLE ${REQUESTS_TABLE} ADD COLUMN IF NOT EXISTS json_reads VARCHAR`;
+export const REQUESTS_DDL = `CREATE TABLE IF NOT EXISTS ${REQUESTS_TABLE} (request_id VARCHAR, started_at TIMESTAMPTZ, session INTEGER, ` +
+    `application_name VARCHAR, token_name VARCHAR, user_name VARCHAR, method VARCHAR, sqlstate VARCHAR, message VARCHAR, detail VARCHAR, hint VARCHAR, ` +
+    `"rows" BIGINT, duration_ms INTEGER, query VARCHAR, query_truncated BOOLEAN, seq BIGINT, json_reads VARCHAR)`;
+/** an ApiLogRow's values in COLUMNS' order */
+function valuesOf({ row: r, seq }) {
+    const app = (r.client ?? "").replace(/^postgres:/, "");
+    return [r.requestId, r.at.toISOString(), r.session ?? null, app === "unnamed" ? "" : app, r.tokenName ?? "", r.user ?? "", r.method,
+        r.sqlstate ?? null, r.error === undefined || r.error === "" ? null : r.error, r.detail ?? null, r.hint ?? null,
+        r.rows === undefined ? null : r.rows, Math.round(r.durationMs), r.payload ?? "", r.payloadTruncated === true, seq,
+        r.jsonReads === undefined || r.jsonReads.length === 0 ? null : JSON.stringify(r.jsonReads)];
+}
+/** A ledger row as the commands read it. */
+function requestOf(o) {
+    const text = (v) => v === null || v === undefined ? null : String(v);
+    const sqlstate = text(o.sqlstate);
+    return {
+        requestId: String(o.request_id), startedAt: new Date(String(o.started_at)).toISOString(), session: o.session === null ? null : Number(o.session),
+        applicationName: String(o.application_name ?? ""), tokenName: String(o.token_name ?? ""), user: String(o.user_name ?? ""), method: String(o.method),
+        outcome: outcomeOf(sqlstate), sqlstate, message: text(o.message), detail: text(o.detail), hint: text(o.hint),
+        rows: o.rows === null ? null : Number(o.rows), durationMs: Number(o.duration_ms), query: String(o.query ?? ""), queryTruncated: o.query_truncated === true,
+    };
+}
+export class RequestLedger {
+    buffer = [];
+    /** the next row's number (REQUESTS_SEQ_DDL): one past the ledger's last at open, then one per request recorded */
+    next = 0;
+    timer = null;
+    trimTimer = null;
+    /** the flush in flight: one at a time, so batches commit in the order they were taken */
+    flushing = Promise.resolve();
+    /** rows lost since the last flush that succeeded: said once when the streak begins, and when it ends */
+    lost = 0;
+    closed = false;
+    writer;
+    reader;
+    log;
+    options;
+    /** days kept */
+    days;
+    constructor(writer, reader, log, options) {
+        this.writer = writer;
+        this.reader = reader;
+        this.log = log;
+        this.options = options;
+        this.days = options.days;
+    }
+    /** The ledger of a store: its table made, the rows past the retention deleted, and a trim every hour. */
+    static async open(store, log, options) {
+        const writer = await store.instance.connect();
+        await writer.run(`CREATE SCHEMA IF NOT EXISTS ${MASON_SCHEMA}`);
+        await writer.run(REQUESTS_DDL);
+        await writer.run(REQUESTS_USER_DDL);
+        await writer.run(REQUESTS_SEQ_DDL);
+        await writer.run(REQUESTS_JSON_DDL);
+        const reader = await store.instance.connect();
+        const ledger = new RequestLedger(writer, reader, log, options);
+        ledger.next = Number((await reader.runAndReadAll(`SELECT coalesce(max(seq), -1) + 1 FROM ${REQUESTS_TABLE}`)).getRowsJS()[0][0]);
+        await ledger.trim();
+        ledger.trimTimer = setInterval(() => {
+            ledger.trim().catch((e) => log(`request log: deleting the requests older than ${ledger.days} days failed: ${e.message}`));
+        }, TRIM_EVERY_MS);
+        ledger.trimTimer.unref();
+        return ledger;
+    }
+    /** One request, written with the next batch. Never throws: the statement it records was already answered. */
+    record(row) {
+        // the listener closes before the ledger (mason stop), so nothing should arrive after: said if it does, never written
+        if (this.closed) {
+            this.log(`request log: a request after the log closed, not recorded (${row.requestId})`);
+            return;
+        }
+        this.buffer.push({ row, seq: this.next++ });
+        if (this.buffer.length >= BATCH_ROWS) {
+            void this.flush();
+            return;
+        }
+        this.timer ??= setTimeout(() => { void this.flush(); }, this.options.flushMs ?? FLUSH_MS);
+    }
+    /** Writes what is waiting, after any flush in flight. Resolves whether it was written or not (a failure is said). */
+    flush() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        const rows = this.buffer;
+        this.buffer = [];
+        if (rows.length === 0)
+            return this.flushing;
+        this.flushing = this.flushing.then(() => this.write(rows));
+        return this.flushing;
+    }
+    async write(rows) {
+        const width = COLUMNS.length;
+        const sql = `INSERT INTO ${REQUESTS_TABLE} (${COLUMNS.map((c) => c === "rows" ? `"rows"` : c).join(", ")}) VALUES ` +
+            rows.map((_, i) => `(${COLUMNS.map((c, j) => `$${i * width + j + 1}${c === "started_at" ? "::TIMESTAMPTZ" : ""}`).join(", ")})`).join(", ");
+        const values = rows.flatMap(valuesOf);
+        try {
+            if (this.options.insert !== undefined)
+                await this.options.insert(sql, values);
+            else
+                await this.writer.run(sql, values);
+        }
+        catch (e) {
+            // Tolerated, narrowly, as the ClickHouse writer tolerates it: the answers are sent, so there is no statement left
+            // to fail, and a ledger that cannot write must not take the listener down. SAID, once per streak with the rows it
+            // costs, so a ledger that stopped recording never reads as a quiet listener.
+            if (this.lost === 0)
+                this.log(`request log: could not record ${rows.length} request(s) in ${REQUESTS_TABLE} (${rows[0].row.requestId}` +
+                    `${rows.length > 1 ? ` … ${rows[rows.length - 1].row.requestId}` : ""}): ${e.message}; said once until a write succeeds`);
+            this.lost += rows.length;
+            return;
+        }
+        if (this.lost > 0) {
+            this.log(`request log: recording again; ${this.lost} request(s) were not recorded`);
+            this.lost = 0;
+        }
+    }
+    /** Deletes the requests older than the retention; the count is said when there were any. */
+    async trim() {
+        const r = await this.writer.runAndReadAll(`DELETE FROM ${REQUESTS_TABLE} WHERE started_at < now() - INTERVAL (${this.days}) DAY`);
+        const n = Number(r.getRowsJS()[0]?.[0] ?? 0);
+        if (n > 0)
+            this.log(`request log: deleted ${n} request(s) older than ${this.days} days (MASON_REQUEST_LOG_DAYS)`);
+        return n;
+    }
+    /** The newest `limit` requests, newest LAST; `failed`: the refused and failed ones only. Committed rows only. */
+    async recent(o) {
+        const rows = (await this.reader.runAndReadAll(`SELECT * FROM (SELECT * FROM ${REQUESTS_TABLE}${o.failed ? " WHERE sqlstate IS NOT NULL" : ""} ` +
+            `ORDER BY started_at DESC, seq DESC LIMIT $1) ORDER BY started_at, seq`, [o.limit])).getRowObjectsJson();
+        return rows.map((r) => requestOf(r));
+    }
+    /**
+     * The last day's slow statements in `mason status`'s shape (src/cli/run-server.ts SlowQuery): each distinct statement
+     * whose LATEST answer still took `slowMs` or more, slowest first.
+     */
+    async slow(slowMs, limit = 5) {
+        const rows = (await this.reader.runAndReadAll(`SELECT query, count(*) AS runs, CAST(quantile_disc(duration_ms, 0.5) AS INTEGER) AS median_ms, ` +
+            `max(duration_ms) AS max_ms, arg_max(duration_ms, started_at) AS latest_ms, max(started_at) AS last FROM ${REQUESTS_TABLE} ` +
+            `WHERE sqlstate IS NULL AND started_at > now() - INTERVAL 1 DAY AND query <> '' AND NOT query_truncated ` +
+            `GROUP BY query HAVING arg_max(duration_ms, started_at) >= $1 ORDER BY latest_ms DESC LIMIT $2`, [slowMs, limit])).getRowObjectsJson();
+        return rows.map((r) => ({ route: "postgres", payload: String(r.query), runs: Number(r.runs), medianMs: Number(r.median_ms), maxMs: Number(r.max_ms),
+            latestMs: Number(r.latest_ms), last: new Date(String(r.last)).toISOString() }));
+    }
+    /**
+     * The last day's refused and failed statements in `mason status`'s shape (RefusedQuery): each distinct statement once,
+     * newest first, with its latest SQLSTATE and message; and how many there were in all.
+     */
+    async refused(limit = 8) {
+        const day = `sqlstate IS NOT NULL AND started_at > now() - INTERVAL 1 DAY`;
+        const rows = (await this.reader.runAndReadAll(`SELECT query, count(*) AS runs, max(started_at) AS last, arg_max(sqlstate, started_at) AS code, arg_max(message, started_at) AS message ` +
+            `FROM ${REQUESTS_TABLE} WHERE ${day} GROUP BY query ORDER BY last DESC LIMIT $1`, [limit])).getRowObjectsJson();
+        const total = Number((await this.reader.runAndReadAll(`SELECT count(*) FROM ${REQUESTS_TABLE} WHERE ${day}`)).getRowsJS()[0]?.[0] ?? 0);
+        return { total, refused: rows.map((r) => ({ route: "postgres", payload: String(r.query), runs: Number(r.runs), last: new Date(String(r.last)).toISOString(),
+                code: String(r.code), message: String(r.message ?? "") })) };
+    }
+    /** Writes what is waiting and closes the ledger's connections (mason stop). */
+    async close() {
+        if (this.trimTimer !== null) {
+            clearInterval(this.trimTimer);
+            this.trimTimer = null;
+        }
+        await this.flush();
+        this.closed = true;
+        this.writer.closeSync();
+        this.reader.closeSync();
+    }
+}