@axiom-lattice/pg-stores 3.3.13 → 3.4.0

package/src/__tests__/PostgreSQLCheckpointStorage.test.ts

@@ -0,0 +1,538 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+
+import {
+  CheckpointTargetNotEmptyError,
+  PostgreSQLCheckpointStorage,
+} from "../stores/PostgreSQLCheckpointStorage";
+
+const query = jest.fn();
+const mockPool = { query } as unknown as Pool;
+
+describe("PostgreSQLCheckpointStorage SQL contract", () => {
+  beforeEach(() => query.mockReset());
+
+  it("maps the aggregate row into storage categories", async () => {
+    query.mockResolvedValueOnce({
+      rows: [{
+        checkpoint_count: "2",
+        checkpoint_bytes: "100",
+        blob_count: "3",
+        blob_bytes: "60",
+        write_count: "4",
+        write_bytes: "40",
+      }],
+    });
+    const store = new PostgreSQLCheckpointStorage(mockPool);
+
+    await expect(store.get("thread-1")).resolves.toEqual({
+      threadId: "thread-1",
+      totalBytes: 200,
+      checkpoints: { count: 2, bytes: 100 },
+      channelValues: { count: 3, bytes: 60 },
+      pendingWrites: { count: 4, bytes: 40 },
+    });
+
+    const [sql, params] = query.mock.calls[0] as [string, unknown[]];
+    expect(sql).toContain("FROM checkpoints");
+    expect(sql).toContain("FROM checkpoint_blobs");
+    expect(sql).toContain("FROM checkpoint_writes");
+    expect(sql).toContain("count(*)::bigint");
+    expect(sql).toContain("thread_id=$1");
+    expect(params).toEqual(["thread-1"]);
+    expect(sql).not.toMatch(/\b(INSERT|UPDATE|DELETE|TRUNCATE)\b/i);
+  });
+
+  it("reports 409 conflicts with a typed error code", () => {
+    const error = new CheckpointTargetNotEmptyError("thread-2");
+    expect(error.code).toBe("CHECKPOINT_TARGET_NOT_EMPTY");
+    expect(error.name).toBe("CheckpointTargetNotEmptyError");
+  });
+
+  it("maps a unique violation during copy to CHECKPOINT_TARGET_NOT_EMPTY", async () => {
+    const client = {
+      query: jest.fn()
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({ rows: [{ not_empty: false }] })
+        .mockRejectedValueOnce(Object.assign(new Error("duplicate key"), { code: "23505" }))
+        .mockResolvedValueOnce({ rows: [] }),
+      release: jest.fn(),
+    };
+    const pool = {
+      query: jest.fn(),
+      connect: jest.fn().mockResolvedValue(client),
+    } as unknown as Pool;
+    const store = new PostgreSQLCheckpointStorage(pool);
+
+    await expect(store.copyThread("source", "target")).rejects.toMatchObject({
+      name: "CheckpointTargetNotEmptyError",
+      code: "CHECKPOINT_TARGET_NOT_EMPTY",
+    });
+    expect(client.release).toHaveBeenCalled();
+    expect(client.query).toHaveBeenLastCalledWith("ROLLBACK");
+  });
+
+  it("rolls back when a prune delete fails", async () => {
+    const client = {
+      query: jest.fn()
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({
+          rows: [{ checkpoint_ns: "", checkpoint_id: "cp-2", checkpoint: { channel_versions: {} } }],
+        })
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({
+          rows: [
+            { checkpoint_ns: "", checkpoint_id: "cp-1" },
+            { checkpoint_ns: "", checkpoint_id: "cp-2" },
+          ],
+        })
+        .mockRejectedValueOnce(new Error("delete failed"))
+        .mockResolvedValueOnce({ rows: [] }),
+      release: jest.fn(),
+    };
+    const pool = {
+      query: jest.fn(),
+      connect: jest.fn().mockResolvedValue(client),
+    } as unknown as Pool;
+    const store = new PostgreSQLCheckpointStorage(pool);
+
+    await expect(store.pruneThread("thread-1", { keepLatest: 1 }))
+      .rejects.toThrow("delete failed");
+    expect(client.release).toHaveBeenCalled();
+    expect(client.query).toHaveBeenLastCalledWith("ROLLBACK");
+  });
+
+  it("rejects an invalid keepLatest before opening a transaction", async () => {
+    const connect = jest.fn();
+    const pool = { query: jest.fn(), connect } as unknown as Pool;
+    const store = new PostgreSQLCheckpointStorage(pool);
+
+    for (const keepLatest of [0, -1, 1.5, Number.NaN]) {
+      await expect(store.pruneThread("thread-1", { keepLatest }))
+        .rejects.toThrow("keepLatest must be an integer >= 1");
+    }
+    expect(connect).not.toHaveBeenCalled();
+  });
+
+  it("coalesces missing aggregate values to zero", async () => {
+    query.mockResolvedValueOnce({
+      rows: [{
+        checkpoint_count: 0,
+        checkpoint_bytes: null,
+        blob_count: 0,
+        blob_bytes: null,
+        write_count: 0,
+        write_bytes: null,
+      }],
+    });
+    const store = new PostgreSQLCheckpointStorage(mockPool);
+
+    await expect(store.get("thread-1")).resolves.toEqual({
+      threadId: "thread-1",
+      totalBytes: 0,
+      checkpoints: { count: 0, bytes: 0 },
+      channelValues: { count: 0, bytes: 0 },
+      pendingWrites: { count: 0, bytes: 0 },
+    });
+  });
+});
+
+const TEST_DATABASE_URL = process.env.TEST_DATABASE_URL;
+const maybeDescribe = TEST_DATABASE_URL ? describe : describe.skip;
+
+maybeDescribe("PostgreSQLCheckpointStorage (PostgreSQL)", () => {
+  const threadId = randomUUID();
+  let pool: Pool;
+  let store: PostgreSQLCheckpointStorage;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: TEST_DATABASE_URL! });
+    // Both checkpoint suites create the same schema and Jest runs test files
+    // in parallel. Serialize the DDL so CREATE TABLE IF NOT EXISTS cannot race
+    // on pg_type.
+    const client = await pool.connect();
+    try {
+      await client.query("SELECT pg_advisory_lock(94711231)");
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS checkpoints (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          parent_checkpoint_id TEXT,
+          type TEXT,
+          checkpoint JSONB NOT NULL,
+          metadata JSONB NOT NULL DEFAULT '{}',
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+        );
+        CREATE TABLE IF NOT EXISTS checkpoint_blobs (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          channel TEXT NOT NULL,
+          version TEXT NOT NULL,
+          type TEXT NOT NULL,
+          blob BYTEA,
+          PRIMARY KEY (thread_id, checkpoint_ns, channel, version)
+        );
+        CREATE TABLE IF NOT EXISTS checkpoint_writes (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          task_id TEXT NOT NULL,
+          idx INTEGER NOT NULL,
+          channel TEXT NOT NULL,
+          type TEXT,
+          blob BYTEA NOT NULL,
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+        );
+      `);
+    } finally {
+      await client.query("SELECT pg_advisory_unlock(94711231)").catch(() => undefined);
+      client.release();
+    }
+    store = new PostgreSQLCheckpointStorage(pool);
+  });
+
+  beforeEach(async () => {
+    await pool.query("DELETE FROM checkpoints WHERE thread_id = $1", [threadId]);
+    await pool.query("DELETE FROM checkpoint_blobs WHERE thread_id = $1", [threadId]);
+    await pool.query("DELETE FROM checkpoint_writes WHERE thread_id = $1", [threadId]);
+  });
+
+  afterAll(async () => {
+    await pool.query("DELETE FROM checkpoints WHERE thread_id = $1", [threadId]);
+    await pool.query("DELETE FROM checkpoint_blobs WHERE thread_id = $1", [threadId]);
+    await pool.query("DELETE FROM checkpoint_writes WHERE thread_id = $1", [threadId]);
+    await pool.end();
+  });
+
+  it("reports counts and bytes from the checkpoint tables", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1}'::jsonb, '{"step":1}'::jsonb),
+              ($1, '', 'cp-2', '{"v":2}'::jsonb, '{"step":2}'::jsonb)`,
+      [threadId],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+       VALUES ($1, '', 'messages', '1', 'msgpack', $2),
+              ($1, '', 'messages', '2', 'msgpack', $3),
+              ($1, '', 'messages', '3', 'msgpack', $4)`,
+      [threadId, Buffer.alloc(10), Buffer.alloc(20), Buffer.alloc(30)],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+       VALUES ($1, '', 'cp-1', 'task-1', 0, 'messages', 'msgpack', $2),
+              ($1, '', 'cp-1', 'task-1', 1, 'messages', 'msgpack', $3),
+              ($1, '', 'cp-2', 'task-2', 0, 'messages', 'msgpack', $4),
+              ($1, '', 'cp-2', 'task-2', 1, 'messages', 'msgpack', $5)`,
+      [threadId, Buffer.alloc(5), Buffer.alloc(15), Buffer.alloc(7), Buffer.alloc(13)],
+    );
+
+    const storage = await store.get(threadId);
+
+    expect(storage.threadId).toBe(threadId);
+    expect(storage.checkpoints.count).toBe(2);
+    expect(storage.checkpoints.bytes).toBeGreaterThan(0);
+    expect(storage.channelValues).toEqual({ count: 3, bytes: 60 });
+    expect(storage.pendingWrites).toEqual({ count: 4, bytes: 40 });
+    expect(storage.totalBytes).toBe(
+      storage.checkpoints.bytes + storage.channelValues.bytes + storage.pendingWrites.bytes,
+    );
+  });
+
+  async function removeRows(...threadIds: string[]): Promise<void> {
+    for (const id of threadIds) {
+      await pool.query("DELETE FROM checkpoint_writes WHERE thread_id = $1", [id]);
+      await pool.query("DELETE FROM checkpoint_blobs WHERE thread_id = $1", [id]);
+      await pool.query("DELETE FROM checkpoints WHERE thread_id = $1", [id]);
+    }
+  }
+
+  it("copies checkpoint rows to the target and rewrites metadata thread_id", async () => {
+    const source = randomUUID();
+    const target = randomUUID();
+    try {
+      await pool.query(
+        `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+         VALUES ($1, '', 'cp-1', '{"v":1}'::jsonb, $2::jsonb)`,
+        [source, JSON.stringify({ step: 1, thread_id: source })],
+      );
+      await pool.query(
+        `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+         VALUES ($1, '', 'messages', '1', 'msgpack', $2)`,
+        [source, Buffer.from("blob")],
+      );
+      await pool.query(
+        `INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+         VALUES ($1, '', 'cp-1', 'task-1', 0, 'messages', 'msgpack', $2)`,
+        [source, Buffer.from("write")],
+      );
+
+      await store.copyThread(source, target);
+
+      const checkpoints = await pool.query(
+        "SELECT checkpoint_id, checkpoint, metadata FROM checkpoints WHERE thread_id = $1",
+        [target],
+      );
+      expect(checkpoints.rows).toHaveLength(1);
+      expect(checkpoints.rows[0].checkpoint_id).toBe("cp-1");
+      expect(checkpoints.rows[0].checkpoint).toEqual({ v: 1 });
+      expect(checkpoints.rows[0].metadata).toEqual({ step: 1, thread_id: target });
+
+      const blobs = await pool.query(
+        "SELECT channel, version, blob FROM checkpoint_blobs WHERE thread_id = $1",
+        [target],
+      );
+      expect(blobs.rows).toHaveLength(1);
+      expect(Buffer.from(blobs.rows[0].blob).toString("utf8")).toBe("blob");
+
+      const writes = await pool.query(
+        "SELECT task_id, idx, blob FROM checkpoint_writes WHERE thread_id = $1",
+        [target],
+      );
+      expect(writes.rows).toHaveLength(1);
+      expect(writes.rows[0].task_id).toBe("task-1");
+      expect(Buffer.from(writes.rows[0].blob).toString("utf8")).toBe("write");
+    } finally {
+      await removeRows(source, target);
+    }
+  });
+
+  it("treats an empty source copy as a no-op", async () => {
+    const source = randomUUID();
+    const target = randomUUID();
+    try {
+      await expect(store.copyThread(source, target)).resolves.toBeUndefined();
+      const counts = await pool.query(
+        `SELECT
+          (SELECT count(*)::int FROM checkpoints WHERE thread_id = $1) AS checkpoints,
+          (SELECT count(*)::int FROM checkpoint_blobs WHERE thread_id = $1) AS blobs,
+          (SELECT count(*)::int FROM checkpoint_writes WHERE thread_id = $1) AS writes`,
+        [target],
+      );
+      expect(counts.rows[0]).toEqual({ checkpoints: 0, blobs: 0, writes: 0 });
+    } finally {
+      await removeRows(source, target);
+    }
+  });
+
+  it("rejects a non-empty target with CHECKPOINT_TARGET_NOT_EMPTY", async () => {
+    const source = randomUUID();
+    const target = randomUUID();
+    try {
+      await pool.query(
+        `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+         VALUES ($1, '', 'cp-1', '{"v":1}'::jsonb, '{}'::jsonb)`,
+        [source],
+      );
+      await pool.query(
+        `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+         VALUES ($1, '', 'messages', '1', 'msgpack', $2)`,
+        [target, Buffer.from("existing")],
+      );
+
+      await expect(store.copyThread(source, target)).rejects.toMatchObject({
+        name: "CheckpointTargetNotEmptyError",
+        code: "CHECKPOINT_TARGET_NOT_EMPTY",
+      });
+      expect(await store.get(target)).toMatchObject({
+        checkpoints: { count: 0 },
+        channelValues: { count: 1 },
+      });
+    } finally {
+      await removeRows(source, target);
+    }
+  });
+
+  it("keep_latest retains the latest checkpoint per namespace and its blobs/writes", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1,"channel_versions":{"messages":"1"}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-2', '{"v":1,"channel_versions":{"messages":"2"}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-3', '{"v":1,"channel_versions":{"messages":"3"}}'::jsonb, '{}'::jsonb)`,
+      [threadId],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+       VALUES ($1, '', 'messages', '1', 'msgpack', $2),
+              ($1, '', 'messages', '2', 'msgpack', $3),
+              ($1, '', 'messages', '3', 'msgpack', $4)`,
+      [threadId, Buffer.from("one"), Buffer.from("two"), Buffer.from("three")],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+       VALUES ($1, '', 'cp-1', 'task-1', 0, 'messages', 'msgpack', $2),
+              ($1, '', 'cp-2', 'task-2', 0, 'messages', 'msgpack', $3),
+              ($1, '', 'cp-3', 'task-3', 0, 'messages', 'msgpack', $4)`,
+      [threadId, Buffer.from("w1"), Buffer.from("w2"), Buffer.from("w3")],
+    );
+
+    const counts = await store.pruneThread(threadId, { keepLatest: 1 });
+
+    expect(counts).toEqual({ checkpoints: 2, blobs: 2, writes: 2 });
+    const checkpoints = await pool.query(
+      "SELECT checkpoint_id FROM checkpoints WHERE thread_id = $1 ORDER BY checkpoint_id",
+      [threadId],
+    );
+    expect(checkpoints.rows.map((row) => row.checkpoint_id)).toEqual(["cp-3"]);
+    const blobs = await pool.query(
+      "SELECT version FROM checkpoint_blobs WHERE thread_id = $1 ORDER BY version",
+      [threadId],
+    );
+    expect(blobs.rows.map((row) => row.version)).toEqual(["3"]);
+    const writes = await pool.query(
+      "SELECT checkpoint_id FROM checkpoint_writes WHERE thread_id = $1",
+      [threadId],
+    );
+    expect(writes.rows.map((row) => row.checkpoint_id)).toEqual(["cp-3"]);
+
+    await expect(store.pruneThread(threadId, { keepLatest: 1 }))
+      .resolves.toEqual({ checkpoints: 0, blobs: 0, writes: 0 });
+  });
+
+  it("keep_latest unions blobs referenced by all retained checkpoints", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1,"channel_versions":{"messages":"1"}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-2', '{"v":1,"channel_versions":{"messages":"2"}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-3', '{"v":1,"channel_versions":{"messages":"3"}}'::jsonb, '{}'::jsonb)`,
+      [threadId],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+       VALUES ($1, '', 'messages', '1', 'msgpack', $2),
+              ($1, '', 'messages', '2', 'msgpack', $3),
+              ($1, '', 'messages', '3', 'msgpack', $4)`,
+      [threadId, Buffer.from("one"), Buffer.from("two"), Buffer.from("three")],
+    );
+
+    const counts = await store.pruneThread(threadId, { keepLatest: 2 });
+
+    expect(counts).toEqual({ checkpoints: 1, blobs: 1, writes: 0 });
+    const blobs = await pool.query(
+      "SELECT version FROM checkpoint_blobs WHERE thread_id = $1 ORDER BY version",
+      [threadId],
+    );
+    expect(blobs.rows.map((row) => row.version)).toEqual(["2", "3"]);
+  });
+
+  it("keep_latest retains the latest checkpoint separately per namespace", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1,"channel_versions":{}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-2', '{"v":1,"channel_versions":{}}'::jsonb, '{}'::jsonb),
+              ($1, 'subgraph', 'cp-1', '{"v":1,"channel_versions":{}}'::jsonb, '{}'::jsonb)`,
+      [threadId],
+    );
+
+    const counts = await store.pruneThread(threadId, { keepLatest: 1 });
+
+    expect(counts).toEqual({ checkpoints: 1, blobs: 0, writes: 0 });
+    const retained = await pool.query(
+      "SELECT checkpoint_ns, checkpoint_id FROM checkpoints WHERE thread_id = $1 ORDER BY checkpoint_ns",
+      [threadId],
+    );
+    expect(retained.rows).toEqual([
+      { checkpoint_ns: "", checkpoint_id: "cp-2" },
+      { checkpoint_ns: "subgraph", checkpoint_id: "cp-1" },
+    ]);
+  });
+
+  it("keep_latest is a no-op when the limit meets or exceeds the count", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1,"channel_versions":{}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-2', '{"v":1,"channel_versions":{}}'::jsonb, '{}'::jsonb)`,
+      [threadId],
+    );
+
+    await expect(store.pruneThread(threadId, { keepLatest: 5 }))
+      .resolves.toEqual({ checkpoints: 0, blobs: 0, writes: 0 });
+    expect((await store.get(threadId)).checkpoints.count).toBe(2);
+  });
+
+  it("keep_latest keeps all namespace blobs when a retained checkpoint lacks channel_versions", async () => {
+    await pool.query(
+      `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+       VALUES ($1, '', 'cp-1', '{"v":1,"channel_versions":{"messages":"1"}}'::jsonb, '{}'::jsonb),
+              ($1, '', 'cp-2', '{"v":1}'::jsonb, '{}'::jsonb)`,
+      [threadId],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+       VALUES ($1, '', 'messages', '1', 'msgpack', $2),
+              ($1, '', 'messages', '2', 'msgpack', $3),
+              ($1, '', 'messages', '3', 'msgpack', $4)`,
+      [threadId, Buffer.from("one"), Buffer.from("two"), Buffer.from("three")],
+    );
+    await pool.query(
+      `INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+       VALUES ($1, '', 'cp-1', 'task-1', 0, 'messages', 'msgpack', $2),
+              ($1, '', 'cp-2', 'task-2', 0, 'messages', 'msgpack', $3)`,
+      [threadId, Buffer.from("w1"), Buffer.from("w2")],
+    );
+
+    const counts = await store.pruneThread(threadId, { keepLatest: 1 });
+
+    expect(counts).toEqual({ checkpoints: 1, blobs: 0, writes: 1 });
+    expect((await store.get(threadId)).channelValues.count).toBe(3);
+  });
+
+  it("deletes rows from all three checkpoint tables", async () => {
+    const thread = randomUUID();
+    try {
+      await pool.query(
+        `INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, checkpoint, metadata)
+         VALUES ($1, '', 'cp-1', '{"v":1}'::jsonb, '{}'::jsonb)`,
+        [thread],
+      );
+      await pool.query(
+        `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+         VALUES ($1, '', 'messages', '1', 'msgpack', $2)`,
+        [thread, Buffer.from("blob")],
+      );
+      await pool.query(
+        `INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+         VALUES ($1, '', 'cp-1', 'task-1', 0, 'messages', 'msgpack', $2)`,
+        [thread, Buffer.from("write")],
+      );
+
+      await store.deleteThread(thread);
+
+      const counts = await pool.query(
+        `SELECT
+          (SELECT count(*)::int FROM checkpoints WHERE thread_id = $1) AS checkpoints,
+          (SELECT count(*)::int FROM checkpoint_blobs WHERE thread_id = $1) AS blobs,
+          (SELECT count(*)::int FROM checkpoint_writes WHERE thread_id = $1) AS writes`,
+        [thread],
+      );
+      expect(counts.rows[0]).toEqual({ checkpoints: 0, blobs: 0, writes: 0 });
+    } finally {
+      await removeRows(thread);
+    }
+  });
+
+  it("coalesces a NULL checkpoint blob to zero bytes", async () => {
+    await pool.query(
+      `INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
+       VALUES ($1, '', 'messages', '1', 'msgpack', NULL)`,
+      [threadId],
+    );
+
+    const storage = await store.get(threadId);
+
+    expect(storage.channelValues).toEqual({ count: 1, bytes: 0 });
+    expect(storage.totalBytes).toBe(0);
+  });
+
+  it("returns a zeroed report for an unknown thread", async () => {
+    await expect(store.get(randomUUID())).resolves.toEqual({
+      threadId: expect.any(String),
+      totalBytes: 0,
+      checkpoints: { count: 0, bytes: 0 },
+      channelValues: { count: 0, bytes: 0 },
+      pendingWrites: { count: 0, bytes: 0 },
+    });
+  });
+});