@shaferllc/keel 0.68.0 → 0.77.0

package/dist/watch/entry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A recorded entry — one thing that happened in the app: a request, a query, an
+ * exception, a log line. Every watcher produces these; the store persists them;
+ * the dashboard reads them back.
+ *
+ * Two ids give the UI its shape. `batchId` ties an entry to the request (or job,
+ * or scheduled run) it happened inside, so the dashboard can show a request and
+ * every query, log, and exception it produced. `familyHash` groups entries that
+ * are "the same" — the same SQL shape, the same exception — so recurring things
+ * can be counted and collapsed.
+ */
+export type EntryType = "request" | "query" | "exception" | "log" | "mail" | "job" | "notification" | "cache" | "event" | "schedule";
+/** Every entry type, in the order the dashboard shows its tabs. */
+export declare const ENTRY_TYPES: EntryType[];
+export interface Entry {
+    /** Unique id (32 hex). */
+    uuid: string;
+    /** The request/job/run this happened inside; groups related entries. */
+    batchId: string;
+    type: EntryType;
+    /** Groups "the same" entry — same SQL shape, same exception class+message. */
+    familyHash?: string;
+    /** The type-specific detail the dashboard renders. Always JSON-safe. */
+    content: Record<string, unknown>;
+    /** Free-form labels for filtering: `status:500`, `slow`, `connection:default`. */
+    tags: string[];
+    /** Epoch milliseconds. */
+    createdAt: number;
+}
+/** A filter over stored entries, for the list endpoint. */
+export interface EntryFilter {
+    type?: EntryType;
+    tag?: string;
+    batchId?: string;
+    /** Keyset pagination: only entries created strictly before this timestamp. */
+    before?: number;
+    limit?: number;
+}
+/** A 32-hex id for an entry. */
+export declare function newUuid(): string;
+/** A short, stable hash (8 hex) of a string — for `familyHash`. */
+export declare function familyHash(input: string): string;
+/**
+ * Make an arbitrary value safe to store as JSON: unwrap Errors, truncate long
+ * strings, drop functions, and break cycles. Watchers hand user data (request
+ * bodies, job payloads, event payloads) straight through, so this is the barrier
+ * that keeps one weird value from poisoning the whole store.
+ */
+export declare function jsonSafe(value: unknown, seen?: WeakSet<object>): unknown;
+/** Redact auth/cookie headers before an entry is stored or shown. */
+export declare function redactHeaders(headers: Record<string, string>): Record<string, string>;
+/** Collapse a SQL statement to its shape, so `id = 1` and `id = 2` group together. */
+export declare function sqlShape(sql: string): string;

package/dist/watch/entry.js

@@ -0,0 +1,105 @@
+/**
+ * A recorded entry — one thing that happened in the app: a request, a query, an
+ * exception, a log line. Every watcher produces these; the store persists them;
+ * the dashboard reads them back.
+ *
+ * Two ids give the UI its shape. `batchId` ties an entry to the request (or job,
+ * or scheduled run) it happened inside, so the dashboard can show a request and
+ * every query, log, and exception it produced. `familyHash` groups entries that
+ * are "the same" — the same SQL shape, the same exception — so recurring things
+ * can be counted and collapsed.
+ */
+/** Every entry type, in the order the dashboard shows its tabs. */
+export const ENTRY_TYPES = [
+    "request",
+    "query",
+    "exception",
+    "log",
+    "mail",
+    "job",
+    "notification",
+    "cache",
+    "event",
+    "schedule",
+];
+/* --------------------------------- ids ------------------------------------ */
+/** A 32-hex id for an entry. */
+export function newUuid() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** A short, stable hash (8 hex) of a string — for `familyHash`. */
+export function familyHash(input) {
+    // FNV-1a: tiny, dependency-free, good enough to group like with like.
+    let h = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16).padStart(8, "0");
+}
+/* ------------------------------- serializing ------------------------------ */
+const MAX_STRING = 8_000;
+/**
+ * Make an arbitrary value safe to store as JSON: unwrap Errors, truncate long
+ * strings, drop functions, and break cycles. Watchers hand user data (request
+ * bodies, job payloads, event payloads) straight through, so this is the barrier
+ * that keeps one weird value from poisoning the whole store.
+ */
+export function jsonSafe(value, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return value ?? null;
+    const t = typeof value;
+    if (t === "string") {
+        const s = value;
+        return s.length > MAX_STRING ? `${s.slice(0, MAX_STRING)}… (${s.length} chars)` : s;
+    }
+    if (t === "number" || t === "boolean")
+        return value;
+    if (t === "bigint")
+        return `${value.toString()}n`;
+    if (t === "function" || t === "symbol")
+        return `[${t}]`;
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: (value.stack ?? "").split("\n").map((l) => l.trim()),
+        };
+    }
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === "object") {
+        if (seen.has(value))
+            return "[Circular]";
+        seen.add(value);
+        if (Array.isArray(value))
+            return value.slice(0, 200).map((v) => jsonSafe(v, seen));
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = jsonSafe(v, seen);
+        }
+        return out;
+    }
+    return String(value);
+}
+const REDACTED = "[redacted]";
+const SENSITIVE_HEADERS = new Set(["authorization", "cookie", "set-cookie", "proxy-authorization"]);
+/** Redact auth/cookie headers before an entry is stored or shown. */
+export function redactHeaders(headers) {
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        out[k] = SENSITIVE_HEADERS.has(k.toLowerCase()) ? REDACTED : v;
+    }
+    return out;
+}
+/** Collapse a SQL statement to its shape, so `id = 1` and `id = 2` group together. */
+export function sqlShape(sql) {
+    return sql
+        .replace(/\s+/g, " ")
+        .replace(/'[^']*'/g, "?")
+        .replace(/\b\d+\b/g, "?")
+        .trim()
+        .toLowerCase();
+}

package/dist/watch/gate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Who may see the dashboard. It exposes requests, payloads, and stack traces, so
+ * it must never be world-readable in production. By default it's open only when
+ * `app.debug` is on or the app isn't in production; call `Watch.auth()` to plug
+ * in your own check (an admin session, an allow-list) — mirrors Telescope's gate.
+ */
+import type { Ctx } from "../core/http/router.js";
+export type WatchGate = (c: Ctx) => boolean | Promise<boolean>;
+export declare const Watch: {
+    /**
+     * Restrict dashboard access. Return true to allow the request.
+     *
+     *   Watch.auth((c) => auth().check() && auth().user()?.isAdmin);
+     */
+    auth(fn: WatchGate): void;
+    /** Remove a custom gate, reverting to the default. */
+    clearAuth(): void;
+};
+/** Whether the current request may see the dashboard. */
+export declare function passesGate(c: Ctx): Promise<boolean>;

package/dist/watch/gate.js

@@ -0,0 +1,32 @@
+/**
+ * Who may see the dashboard. It exposes requests, payloads, and stack traces, so
+ * it must never be world-readable in production. By default it's open only when
+ * `app.debug` is on or the app isn't in production; call `Watch.auth()` to plug
+ * in your own check (an admin session, an allow-list) — mirrors Telescope's gate.
+ */
+import { config } from "../core/helpers.js";
+let gate;
+export const Watch = {
+    /**
+     * Restrict dashboard access. Return true to allow the request.
+     *
+     *   Watch.auth((c) => auth().check() && auth().user()?.isAdmin);
+     */
+    auth(fn) {
+        gate = fn;
+    },
+    /** Remove a custom gate, reverting to the default. */
+    clearAuth() {
+        gate = undefined;
+    },
+};
+/** Allow when debugging, or anywhere that isn't production. */
+function defaultGate() {
+    if (config("app.debug", false))
+        return true;
+    return config("app.env", "production") !== "production";
+}
+/** Whether the current request may see the dashboard. */
+export async function passesGate(c) {
+    return gate ? gate(c) : defaultGate();
+}

package/dist/watch/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Keel Watch — a debug dashboard for Keel apps, imported from
+ * `@shaferllc/keel/watch`. Register the provider and open `/watch`:
+ *
+ *   import { WatchServiceProvider } from "@shaferllc/keel/watch";
+ *   app.register(WatchServiceProvider);
+ *
+ * Lock down who can see it with `Watch.auth()`.
+ */
+export { WatchServiceProvider } from "./provider.js";
+export { Watch } from "./gate.js";
+export type { WatchGate } from "./gate.js";
+export { resolveConfig, defaultConfig } from "./config.js";
+export type { WatchConfig } from "./config.js";
+export { MemoryStore, DatabaseStore } from "./store.js";
+export type { EntryStore } from "./store.js";
+export { watchMigration } from "./migration.js";
+export { Recorder } from "./recorder.js";
+export { installWatchers } from "./watchers.js";
+export { ENTRY_TYPES, newUuid, familyHash, jsonSafe, redactHeaders, sqlShape, } from "./entry.js";
+export type { Entry, EntryType, EntryFilter } from "./entry.js";

package/dist/watch/index.js

@@ -0,0 +1,17 @@
+/**
+ * Keel Watch — a debug dashboard for Keel apps, imported from
+ * `@shaferllc/keel/watch`. Register the provider and open `/watch`:
+ *
+ *   import { WatchServiceProvider } from "@shaferllc/keel/watch";
+ *   app.register(WatchServiceProvider);
+ *
+ * Lock down who can see it with `Watch.auth()`.
+ */
+export { WatchServiceProvider } from "./provider.js";
+export { Watch } from "./gate.js";
+export { resolveConfig, defaultConfig } from "./config.js";
+export { MemoryStore, DatabaseStore } from "./store.js";
+export { watchMigration } from "./migration.js";
+export { Recorder } from "./recorder.js";
+export { installWatchers } from "./watchers.js";
+export { ENTRY_TYPES, newUuid, familyHash, jsonSafe, redactHeaders, sqlShape, } from "./entry.js";

package/dist/watch/migration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The `watch_entries` table. Contributed by the provider via `this.migrations()`
+ * and run by `keel migrate` alongside the app's own — the same path any package
+ * ships schema on.
+ */
+import type { Migration } from "../core/migrations.js";
+export declare function watchMigration(table?: string): Migration;

package/dist/watch/migration.js

@@ -0,0 +1,20 @@
+/**
+ * The `watch_entries` table. Contributed by the provider via `this.migrations()`
+ * and run by `keel migrate` alongside the app's own — the same path any package
+ * ships schema on.
+ */
+export function watchMigration(table = "watch_entries") {
+    return {
+        name: `watch_00_create_${table}`,
+        up: (schema) => schema.createTable(table, (t) => {
+            t.string("uuid").unique();
+            t.string("batch_id");
+            t.string("type", 32);
+            t.string("family_hash").nullable();
+            t.text("content");
+            t.text("tags");
+            t.bigInteger("created_at");
+        }),
+        down: (schema) => schema.dropTable(table),
+    };
+}

package/dist/watch/provider.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Keel Watch — a Telescope-style debug dashboard, shipped as a Keel package.
+ *
+ * One line in `bootstrap/providers.ts` turns it on:
+ *   app.register(WatchServiceProvider)
+ *
+ * It's the reference consumer of the package system: it merges its own config,
+ * contributes a migration, mounts routes and a bundled SPA, and adds a console
+ * command — all through `PackageProvider` helpers, touching no framework
+ * internals. The watchers observe the instrumentation event stream; they patch
+ * nothing, so installing Watch changes no behaviour, only visibility.
+ */
+import { PackageProvider } from "../core/package.js";
+export declare class WatchServiceProvider extends PackageProvider {
+    readonly name = "watch";
+    private config;
+    private store;
+    private teardown?;
+    register(): void;
+    boot(): void;
+    shutdown(): void;
+}

package/dist/watch/provider.js

@@ -0,0 +1,58 @@
+/**
+ * Keel Watch — a Telescope-style debug dashboard, shipped as a Keel package.
+ *
+ * One line in `bootstrap/providers.ts` turns it on:
+ *   app.register(WatchServiceProvider)
+ *
+ * It's the reference consumer of the package system: it merges its own config,
+ * contributes a migration, mounts routes and a bundled SPA, and adds a console
+ * command — all through `PackageProvider` helpers, touching no framework
+ * internals. The watchers observe the instrumentation event stream; they patch
+ * nothing, so installing Watch changes no behaviour, only visibility.
+ */
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PackageProvider } from "../core/package.js";
+import { resolveConfig, defaultConfig } from "./config.js";
+import { MemoryStore, DatabaseStore } from "./store.js";
+import { watchMigration } from "./migration.js";
+import { Recorder } from "./recorder.js";
+import { installWatchers } from "./watchers.js";
+import { registerWatchRoutes } from "./routes.js";
+import { pruneCommand } from "./prune.js";
+const here = dirname(fileURLToPath(import.meta.url));
+export class WatchServiceProvider extends PackageProvider {
+    name = "watch";
+    config;
+    store;
+    teardown;
+    register() {
+        this.mergeConfig("watch", defaultConfig);
+        this.config = resolveConfig();
+        this.store =
+            this.config.storage === "memory"
+                ? new MemoryStore(this.config.limit * 10)
+                : new DatabaseStore(this.config.table, this.config.connection);
+        // Schema (run by `keel migrate`), a publishable config stub, and the CLI.
+        this.migrations([watchMigration(this.config.table)]);
+        this.publishes({ [join(here, "watch.config.stub")]: "config/watch.ts" }, "watch-config");
+        this.commands([pruneCommand(this.store, this.config)]);
+    }
+    boot() {
+        if (!this.config.enabled)
+            return;
+        // Observe the instrumentation stream.
+        this.teardown = installWatchers(new Recorder(this.store, this.config), this.config);
+        // Serve the dashboard: the bundled SPA, the JSON API, and the shell.
+        const base = "/" + this.config.path.replace(/^\/|\/$/g, "");
+        const assetsUrl = `${base}/assets`;
+        this.assets(`${this.config.path}/assets`, join(here, "ui/dist"), { maxAge: 3600 });
+        this.routes((r) => registerWatchRoutes(r, this.store, this.config, { base, assetsUrl }), {
+            prefix: this.config.path,
+            as: "watch",
+        });
+    }
+    shutdown() {
+        this.teardown?.();
+    }
+}

package/dist/watch/prune.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `keel watch:prune` — drop entries past the retention window. Contributed as a
+ * package command; schedule it (or run it from cron) to keep the table small.
+ * Note it only reaches persisted storage: with the in-memory store the ring
+ * buffer bounds itself per process, so there's nothing for a separate CLI
+ * process to prune.
+ */
+import type { PackageCommand } from "../core/package.js";
+import type { EntryStore } from "./store.js";
+import type { WatchConfig } from "./config.js";
+export declare function pruneCommand(store: EntryStore, config: WatchConfig): PackageCommand;

package/dist/watch/prune.js

@@ -0,0 +1,22 @@
+/**
+ * `keel watch:prune` — drop entries past the retention window. Contributed as a
+ * package command; schedule it (or run it from cron) to keep the table small.
+ * Note it only reaches persisted storage: with the in-memory store the ring
+ * buffer bounds itself per process, so there's nothing for a separate CLI
+ * process to prune.
+ */
+import { defineCommand, flag } from "../core/console.js";
+export function pruneCommand(store, config) {
+    return defineCommand({
+        name: "watch:prune",
+        description: "Delete Watch entries older than the retention window",
+        flags: { hours: flag.number({ description: "override the retention window (hours)" }) },
+        async run({ flags, ui }) {
+            // A typed flag, so `--hours nonsense` is now a usage error rather than a NaN
+            // that silently prunes everything.
+            const hours = flags.hours ?? config.retentionHours;
+            const removed = await store.prune(Date.now() - hours * 3_600_000);
+            ui.success(`Pruned ${removed} Watch entr${removed === 1 ? "y" : "ies"} older than ${hours}h.`);
+        },
+    });
+}

package/dist/watch/recorder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The recorder turns a watcher's observation into a stored `Entry`. It applies
+ * the config gates (enabled, per-type toggle, sampling), stamps the entry with
+ * the current request/batch id, makes the content JSON-safe, and persists it —
+ * fire-and-forget, so recording never blocks or breaks the thing it's watching.
+ */
+import type { EntryType } from "./entry.js";
+import type { EntryStore } from "./store.js";
+import type { WatchConfig } from "./config.js";
+export interface RecordOptions {
+    /** Force the batch id (else the current request id, else a fresh one). */
+    batchId?: string;
+    /** Group this entry with like ones. */
+    familyHash?: string;
+}
+export declare class Recorder {
+    private store;
+    private config;
+    constructor(store: EntryStore, config: WatchConfig);
+    /** Whether a given entry type should be recorded at all. */
+    enabledFor(type: EntryType): boolean;
+    /** Record one entry. A no-op when the type is disabled or sampled out. */
+    record(type: EntryType, content: Record<string, unknown>, tags?: string[], options?: RecordOptions): void;
+}

package/dist/watch/recorder.js

@@ -0,0 +1,39 @@
+/**
+ * The recorder turns a watcher's observation into a stored `Entry`. It applies
+ * the config gates (enabled, per-type toggle, sampling), stamps the entry with
+ * the current request/batch id, makes the content JSON-safe, and persists it —
+ * fire-and-forget, so recording never blocks or breaks the thing it's watching.
+ */
+import { currentRequestId } from "../core/instrumentation.js";
+import { newUuid, jsonSafe } from "./entry.js";
+export class Recorder {
+    store;
+    config;
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+    }
+    /** Whether a given entry type should be recorded at all. */
+    enabledFor(type) {
+        return this.config.enabled && this.config.watchers[type];
+    }
+    /** Record one entry. A no-op when the type is disabled or sampled out. */
+    record(type, content, tags = [], options = {}) {
+        if (!this.enabledFor(type))
+            return;
+        if (this.config.sampling < 1 && Math.random() > this.config.sampling)
+            return;
+        const entry = {
+            uuid: newUuid(),
+            batchId: options.batchId ?? currentRequestId() ?? newUuid(),
+            type,
+            ...(options.familyHash ? { familyHash: options.familyHash } : {}),
+            content: jsonSafe(content),
+            tags,
+            createdAt: Date.now(),
+        };
+        void Promise.resolve(this.store.record([entry])).catch(() => {
+            // Persistence failures must never surface into the watched request.
+        });
+    }
+}

package/dist/watch/routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The dashboard's HTTP surface: a small JSON API the SPA polls, and the SPA
+ * shell itself. Every route is behind the gate — the API included, so entries
+ * can't be read by anyone the dashboard wouldn't show them to.
+ *
+ * Registered under the configured prefix by the provider, so paths here are
+ * relative to it ("/", "/api/entries", …).
+ */
+import type { Router } from "../core/http/router.js";
+import type { EntryStore } from "./store.js";
+import type { WatchConfig } from "./config.js";
+import { type ShellOptions } from "./ui-shell.js";
+export declare function registerWatchRoutes(r: Router, store: EntryStore, config: WatchConfig, shell: ShellOptions): void;

package/dist/watch/routes.js

@@ -0,0 +1,55 @@
+/**
+ * The dashboard's HTTP surface: a small JSON API the SPA polls, and the SPA
+ * shell itself. Every route is behind the gate — the API included, so entries
+ * can't be read by anyone the dashboard wouldn't show them to.
+ *
+ * Registered under the configured prefix by the provider, so paths here are
+ * relative to it ("/", "/api/entries", …).
+ */
+import { passesGate } from "./gate.js";
+import { dashboardHtml } from "./ui-shell.js";
+export function registerWatchRoutes(r, store, config, shell) {
+    /** Wrap a JSON handler in the gate. */
+    const guarded = (handler) => async (c) => {
+        if (!(await passesGate(c)))
+            return c.json({ error: "Forbidden" }, 403);
+        return handler(c);
+    };
+    // Per-type counts for the tab badges.
+    r.get("/api/counts", guarded(async (c) => c.json({ counts: await store.counts() }))).name("counts");
+    // A page of entries, filtered by type/tag and keyset-paginated by `before`.
+    r.get("/api/entries", guarded(async (c) => {
+        const type = c.req.query("type");
+        const tag = c.req.query("tag") || undefined;
+        const before = c.req.query("before") ? Number(c.req.query("before")) : undefined;
+        const limit = c.req.query("limit") ? Number(c.req.query("limit")) : config.limit;
+        const entries = await store.list({
+            ...(type ? { type } : {}),
+            ...(tag ? { tag } : {}),
+            ...(before ? { before } : {}),
+            limit,
+        });
+        return c.json({ entries });
+    })).name("entries");
+    // One entry, plus the other entries in its batch (the request it belonged to).
+    r.get("/api/entries/:uuid", guarded(async (c) => {
+        const entry = await store.get(c.req.param("uuid"));
+        if (!entry)
+            return c.json({ error: "Not found" }, 404);
+        const related = (await store.batch(entry.batchId)).filter((e) => e.uuid !== entry.uuid);
+        return c.json({ entry, related });
+    })).name("entry");
+    // Every entry in a batch — a request and all it produced.
+    r.get("/api/batch/:batchId", guarded(async (c) => c.json({ entries: await store.batch(c.req.param("batchId")) }))).name("batch");
+    // Wipe the store from the dashboard's "Clear" button.
+    r.delete("/api/entries", guarded(async (c) => {
+        await store.clear();
+        return c.json({ ok: true });
+    })).name("clear");
+    // The SPA shell. Deep links are hash-based, so this one route serves them all.
+    r.get("/", async (c) => {
+        if (!(await passesGate(c)))
+            return c.text("Forbidden", 403);
+        return c.html(dashboardHtml(shell));
+    }).name("dashboard");
+}

package/dist/watch/store.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Where recorded entries live. Two implementations behind one interface:
+ *
+ *   - `MemoryStore` — a per-process ring buffer. Zero setup, great for a single
+ *     dev process or the edge; entries vanish on restart.
+ *   - `DatabaseStore` — a `watch_entries` table via any registered connection.
+ *     Survives restarts and is shared across processes; needs `keel migrate`.
+ *
+ * The store's own reads and writes hit the database like anything else, so they
+ * would show up in the Query watcher — an infinite hall of mirrors. The watcher
+ * filters them out by table name (see `watchers.ts`); the store just does its job.
+ */
+import type { Entry, EntryFilter, EntryType } from "./entry.js";
+export interface EntryStore {
+    /** Persist a batch of entries. */
+    record(entries: Entry[]): Promise<void>;
+    /** One entry by id. */
+    get(uuid: string): Promise<Entry | undefined>;
+    /** Entries matching a filter, newest first. */
+    list(filter: EntryFilter): Promise<Entry[]>;
+    /** Every entry in one batch (a request and its children), newest first. */
+    batch(batchId: string): Promise<Entry[]>;
+    /** How many entries of each type — for the dashboard's tab counts. */
+    counts(): Promise<Record<EntryType, number>>;
+    /** Delete entries created before `timestamp`. Returns how many. */
+    prune(timestamp: number): Promise<number>;
+    /** Delete everything. */
+    clear(): Promise<void>;
+}
+export declare class MemoryStore implements EntryStore {
+    private cap;
+    private entries;
+    constructor(cap?: number);
+    record(entries: Entry[]): Promise<void>;
+    get(uuid: string): Promise<Entry | undefined>;
+    list(filter: EntryFilter): Promise<Entry[]>;
+    batch(batchId: string): Promise<Entry[]>;
+    counts(): Promise<Record<EntryType, number>>;
+    prune(timestamp: number): Promise<number>;
+    clear(): Promise<void>;
+}
+export declare class DatabaseStore implements EntryStore {
+    private table;
+    private connectionName?;
+    constructor(table: string, connectionName?: string | undefined);
+    private conn;
+    record(entries: Entry[]): Promise<void>;
+    get(uuid: string): Promise<Entry | undefined>;
+    list(filter: EntryFilter): Promise<Entry[]>;
+    batch(batchId: string): Promise<Entry[]>;
+    counts(): Promise<Record<EntryType, number>>;
+    prune(timestamp: number): Promise<number>;
+    clear(): Promise<void>;
+}