@remit/drizzle-service 0.0.35 → 0.0.37

package/src/repos/message-label.ts

@@ -4,11 +4,11 @@ import type {
 	MessageLabelItem,
 } from "@remit/data-ports";
 import { and, desc, eq, inArray } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Db } from "../db.js";
 import { deterministicBase36Id } from "../id.js";
 import { messageLabelTable } from "../schema.js";
 
-type DB = NodePgDatabase<Record<string, unknown>>;
+type DB = Db<Record<string, unknown>>;
 
 function rowToMessageLabel(
 	row: typeof messageLabelTable.$inferSelect,

package/src/repos/message.ts

@@ -6,7 +6,7 @@ import type {
 	MessageItem,
 } from "@remit/data-ports";
 import { and, asc, eq, gt, inArray, or } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
 import type { Db } from "../db.js";
 import {
 	CreateFailedConflictError,
@@ -99,15 +99,12 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 
 /**
  * Emitted into the transactional outbox when a message's rows are deleted, so
- * the pg-index worker relays a search-index REMOVE and the vectors are dropped.
- * The Postgres-parity equivalent of the DynamoDB stream's REMOVE record.
+ * the search-index worker relays a search-index REMOVE and the vectors are
+ * dropped.
  */
 export const MESSAGE_REMOVED_EVENT = "message.removed";
 
-export type SubtreeDb = Pick<
-	NodePgDatabase<Record<string, unknown>>,
-	"delete" | "insert"
->;
+export type SubtreeDb = Pick<Db<Record<string, unknown>>, "delete" | "insert">;
 
 /**
  * Delete a message and its whole per-message subtree by message id — the nine
@@ -201,7 +198,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 		};
 
 		// Faithful to ElectroDB message.create: a duplicate messageId throws
-		// CreateFailedConflictError. The plain insert raises a PG unique
+		// CreateFailedConflictError. The plain insert raises a unique-constraint
 		// violation, which rolls back the transaction so NO outbox row is
 		// written; we surface it as the domain conflict error.
 		try {
@@ -397,7 +394,8 @@ export class DrizzleMessageRepository implements IMessageRepository {
 		// A non-empty bodyStorageKey means body-sync just persisted the parsed
 		// body, so the message now has embeddable content and its threadMessage
 		// exists. Append a search-index event in the same transaction as the write
-		// (transactional outbox) — the pg-index worker relays it to SQS and embeds.
+		// (transactional outbox) — the search-index worker relays it to SQS and
+		// embeds.
 		// The outbox is append-only: the worker's content-hash gate makes a
 		// redundant pass near-free.
 		const bodySynced =
@@ -540,7 +538,7 @@ export class DrizzleMessageRepository implements IMessageRepository {
 		// mailbox and its COPYUID). The message's search vectors still carry the
 		// old mailbox in their metadata and their body is unchanged, so a normal
 		// re-index would skip them on content hash. Enqueue a move re-index event
-		// in the same transaction as the update; the pg-index worker drains it
+		// in the same transaction as the update; the search-index worker drains it
 		// with force, refreshing the stored mailbox metadata.
 		const rows = await runInTransaction(this.db, async (tx) => {
 			const updated = await tx

package/src/repos/quarantine.ts

@@ -6,10 +6,10 @@ import type {
 } from "@remit/data-ports";
 import { deriveQuarantineId } from "@remit/data-ports/id";
 import { desc, eq } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Db } from "../db.js";
 import { quarantineTable } from "../schema/quarantine.js";
 
-type DB = NodePgDatabase<Record<string, unknown>>;
+type DB = Db<Record<string, unknown>>;
 
 function rowToItem(row: typeof quarantineTable.$inferSelect): QuarantineItem {
 	return {

package/src/repos/test-helpers.ts

@@ -1,224 +1,22 @@
-import { rmSync } from "node:fs";
-import { sql } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { drizzle } from "drizzle-orm/node-postgres";
-import EmbeddedPostgres from "embedded-postgres";
+import type Database from "better-sqlite3";
+import type { Db } from "../db.js";
 import {
 	type MessageDataSchema,
 	messageDataSchema,
 } from "../schema/message-data.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
 
-export type TestDb = NodePgDatabase<MessageDataSchema>;
-
-function randomPort(): number {
-	return 54500 + Math.floor(Math.random() * 400);
-}
+export type TestDb = Db<MessageDataSchema>;
 
+/**
+ * The message-data tables on a throwaway in-memory SQLite database — the
+ * harness for the repos that only touch that subset.
+ */
 export async function createTestDb(): Promise<{
 	db: TestDb;
+	sqlite: Database.Database;
 	stop: () => Promise<void>;
 }> {
-	const port = randomPort();
-	const databaseDir = `/tmp/drizzle-test-pg-${port}-${Date.now()}`;
-
-	const pg = new EmbeddedPostgres({
-		databaseDir,
-		user: "test",
-		password: "test",
-		port,
-		persistent: false,
-	});
-
-	await pg.initialise();
-	await pg.start();
-
-	const connectionString = `postgresql://test:test@localhost:${port}/postgres`;
-	const db = drizzle(connectionString, { schema: messageDataSchema }) as TestDb;
-
-	await db.execute(sql.raw(DDL));
-
-	return {
-		db,
-		stop: async () => {
-			const client = (
-				db as unknown as { $client: { end: () => Promise<void> } }
-			).$client;
-			await client.end();
-			await pg.stop();
-			try {
-				rmSync(databaseDir, { recursive: true, force: true });
-			} catch {
-				// best-effort cleanup
-			}
-		},
-	};
+	const { db, sqlite, close } = await createSqliteTestDb(messageDataSchema);
+	return { db, sqlite, stop: close };
 }
-
-const DDL = `
-CREATE TABLE IF NOT EXISTS envelope (
-  envelope_id       UUID PRIMARY KEY,
-  message_id        UUID NOT NULL,
-  date_value        BIGINT NOT NULL,
-  date_raw          TEXT NOT NULL,
-  subject           TEXT,
-  message_id_value  TEXT,
-  created_at        BIGINT NOT NULL,
-  updated_at        BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS envelope_message_id_idx ON envelope (message_id);
-
-CREATE TABLE IF NOT EXISTS message_reference (
-  message_reference_id  UUID PRIMARY KEY,
-  message_id            UUID NOT NULL,
-  envelope_id           UUID NOT NULL,
-  message_id_value      TEXT NOT NULL,
-  reference_type        TEXT NOT NULL,
-  reference_order       INTEGER NOT NULL,
-  created_at            BIGINT NOT NULL,
-  updated_at            BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS message_reference_message_id_idx ON message_reference (message_id);
-
-CREATE TABLE IF NOT EXISTS envelope_address (
-  envelope_address_id UUID PRIMARY KEY,
-  message_id          UUID NOT NULL,
-  address_id          UUID NOT NULL,
-  display_name        TEXT,
-  normalized_email    TEXT NOT NULL,
-  address_role        TEXT NOT NULL,
-  address_order       INTEGER NOT NULL,
-  created_at          BIGINT NOT NULL,
-  updated_at          BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS envelope_address_message_id_idx ON envelope_address (message_id);
-
-CREATE TABLE IF NOT EXISTS body_part (
-  body_part_id          UUID PRIMARY KEY,
-  message_id            UUID NOT NULL,
-  parent_body_part_id   UUID,
-  part_path             TEXT NOT NULL,
-  media_type            TEXT NOT NULL,
-  media_subtype         TEXT NOT NULL,
-  content_id            TEXT,
-  content_description   TEXT,
-  transfer_encoding     TEXT NOT NULL,
-  size_octets           INTEGER NOT NULL,
-  line_count            INTEGER,
-  md5_hash              TEXT,
-  disposition           TEXT,
-  disposition_filename  TEXT,
-  language              TEXT,
-  location              TEXT,
-  is_multipart          BOOLEAN NOT NULL,
-  multipart_subtype     TEXT,
-  created_at            BIGINT NOT NULL,
-  updated_at            BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS body_part_message_id_idx ON body_part (message_id);
-
-CREATE TABLE IF NOT EXISTS body_part_parameter (
-  body_part_parameter_id  UUID PRIMARY KEY,
-  message_id              UUID NOT NULL,
-  body_part_id            UUID NOT NULL,
-  parameter_name          TEXT NOT NULL,
-  parameter_value         TEXT NOT NULL,
-  created_at              BIGINT NOT NULL,
-  updated_at              BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS body_part_parameter_message_id_idx ON body_part_parameter (message_id);
-
-CREATE TABLE IF NOT EXISTS raw_message_storage (
-  raw_storage_id    UUID PRIMARY KEY,
-  message_id        UUID NOT NULL,
-  storage_type      TEXT NOT NULL,
-  storage_location  TEXT NOT NULL,
-  storage_key       TEXT NOT NULL,
-  size_bytes        INTEGER NOT NULL,
-  checksum_sha256   TEXT NOT NULL,
-  content_encoding  TEXT NOT NULL,
-  stored_at         BIGINT NOT NULL,
-  expires_at        BIGINT,
-  created_at        BIGINT NOT NULL,
-  updated_at        BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS raw_message_storage_message_id_idx ON raw_message_storage (message_id);
-
-CREATE TABLE IF NOT EXISTS body_part_storage (
-  body_part_storage_id  UUID PRIMARY KEY,
-  message_id            UUID NOT NULL,
-  body_part_id          UUID NOT NULL,
-  storage_type          TEXT NOT NULL,
-  storage_location      TEXT NOT NULL,
-  storage_key           TEXT NOT NULL,
-  decoded_size_bytes    INTEGER NOT NULL,
-  checksum_sha256       TEXT NOT NULL,
-  content_encoding      TEXT NOT NULL,
-  is_deduped            BOOLEAN NOT NULL,
-  dedup_hash            TEXT,
-  stored_at             BIGINT NOT NULL,
-  created_at            BIGINT NOT NULL,
-  updated_at            BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS body_part_storage_message_id_idx ON body_part_storage (message_id);
-
-CREATE TABLE IF NOT EXISTS body_part_content (
-  body_part_content_id  UUID PRIMARY KEY,
-  message_id            UUID NOT NULL,
-  body_part_id          UUID NOT NULL,
-  content               TEXT NOT NULL,
-  content_length        INTEGER NOT NULL,
-  created_at            BIGINT NOT NULL,
-  updated_at            BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS body_part_content_message_id_idx ON body_part_content (message_id);
-
-CREATE TABLE IF NOT EXISTS message (
-  message_id              UUID PRIMARY KEY,
-  mailbox_id              UUID NOT NULL,
-  uid                     INTEGER NOT NULL,
-  sequence_number         INTEGER NOT NULL,
-  rfc822_size             INTEGER NOT NULL,
-  internal_date           BIGINT NOT NULL,
-  message_id_header       TEXT,
-  envelope_id             UUID NOT NULL,
-  root_body_part_id       UUID NOT NULL,
-  body_storage_key        TEXT,
-  status                  TEXT NOT NULL DEFAULT 'active',
-  sync_status             TEXT NOT NULL DEFAULT 'pending',
-  original_mailbox_id     UUID,
-  original_uid            INTEGER,
-  category                TEXT NOT NULL DEFAULT 'uncategorized',
-  authenticity            JSONB,
-  auth_result             JSONB,
-  provider_spam           JSONB,
-  has_list_unsubscribe    BOOLEAN NOT NULL DEFAULT false,
-  moved_by_remit          BOOLEAN NOT NULL DEFAULT false,
-  placement_verdict       JSONB,
-  filter_move             JSONB,
-  placement_decided_at    BIGINT,
-  created_at              BIGINT NOT NULL,
-  updated_at              BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS message_mailbox_id_idx ON message (mailbox_id);
-
-CREATE TABLE IF NOT EXISTS message_flag (
-  message_flag_id   UUID PRIMARY KEY,
-  message_id        UUID NOT NULL,
-  flag_name         TEXT NOT NULL,
-  set_at            BIGINT NOT NULL,
-  created_at        BIGINT NOT NULL,
-  updated_at        BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS message_flag_message_id_idx ON message_flag (message_id);
-
-CREATE TABLE IF NOT EXISTS outbox (
-  id           UUID PRIMARY KEY,
-  message_id   UUID NOT NULL,
-  event        TEXT NOT NULL,
-  payload      JSONB NOT NULL,
-  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  processed_at BIGINT
-);
-CREATE INDEX IF NOT EXISTS outbox_message_id_idx ON outbox (message_id);
-CREATE INDEX IF NOT EXISTS outbox_unprocessed_idx ON outbox (created_at) WHERE processed_at IS NULL;
-`;

package/src/repos/thread-message.sqlite.test.ts

@@ -10,7 +10,10 @@ import {
 	LIVE_TOTALS,
 	totalRows,
 } from "./category-fixture.js";
-import { DrizzleThreadMessageRepository } from "./thread-message.js";
+import {
+	DrizzleThreadMessageRepository,
+	THREAD_SEARCH_MAX_LIMIT,
+} from "./thread-message.js";
 
 // The thread-message repo on sqlite (RFC 036 D1): CRUD, keyset pagination, and
 // text search — the FTS5 trigram index for terms of three characters or more
@@ -163,12 +166,9 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 	});
 
 	test("countByMailbox counts matches under the same predicate", async () => {
-		const n = await repo.countByMailbox(
-			ACCOUNT,
-			MAILBOX,
-			{ subject: "invoice" },
-			{ limit: 100 },
-		);
+		const n = await repo.countByMailbox(ACCOUNT, MAILBOX, {
+			subject: "invoice",
+		});
 		assert.ok(n >= 1);
 	});
 
@@ -754,9 +754,6 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			assert.equal(seen.length, LIVE_TOTALS.social + LIVE_TOTALS.transactional);
 		});
 
-		// No `limit`: countByMailbox still clamps its answer to the clamped limit,
-		// which is what #305 changes. What this asserts is the predicate — the
-		// count is over the mailbox rather than over a page of it.
 		test("countByMailbox counts the matches in the mailbox, not the page", async () => {
 			assert.equal(
 				await repo.countByMailbox(
@@ -769,6 +766,34 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			);
 		});
 
+		// Regression for #509. The count was computed in full and then discarded
+		// down to THREAD_SEARCH_MAX_LIMIT, so this mailbox's 4,753 personal
+		// messages reported as 500 — a number that reads to the user as the whole
+		// match. A page size bounds the rows a response carries; it cannot bound
+		// how many messages match.
+		test("a match far larger than a page reports its real size", async () => {
+			assert.ok(
+				LIVE_TOTALS.personal > THREAD_SEARCH_MAX_LIMIT,
+				"the fixture has to outgrow the page cap for this to mean anything",
+			);
+			const page = await repo.searchByMailboxWindow(
+				CAT_ACCOUNT,
+				CAT_MAILBOX,
+				{ category: ["personal"] },
+				{ order: "desc", excludeDeleted: true },
+			);
+			assert.equal(page.items.length, THREAD_SEARCH_MAX_LIMIT);
+			assert.equal(
+				await repo.countByMailbox(
+					CAT_ACCOUNT,
+					CAT_MAILBOX,
+					{ category: ["personal"] },
+					{ excludeDeleted: true },
+				),
+				LIVE_TOTALS.personal,
+			);
+		});
+
 		test("the category predicate composes with the other filters", async () => {
 			const page = await repo.searchByMailboxWindow(
 				CAT_ACCOUNT,

package/src/repos/thread-message.test.ts

@@ -1,12 +1,9 @@
 import assert from "node:assert";
-import { readFileSync } from "node:fs";
 import { after, before, describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
 import type { CreateThreadMessageInput } from "@remit/data-ports";
-import { sql } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/node-postgres";
 import shortUuid from "short-uuid";
 import { threadMessageTable } from "../schema/thread-message.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
 import {
 	clampThreadSearchLimit,
 	DrizzleThreadMessageRepository,
@@ -18,50 +15,6 @@ import {
 const translator = shortUuid.createTranslator(shortUuid.constants.uuid25Base36);
 const uuid = () => translator.generate();
 
-const PG_URL =
-	process.env.PG_CONNECTION_URL ??
-	"postgresql://remit:remit@localhost:5432/remit_test";
-
-// These suites connect to a real Postgres (pg_trgm/unaccent search DDL, which
-// embedded-postgres cannot provide), so they run only in the dedicated pg job
-// that provisions Postgres — mirroring the RUN_INTEG_TESTS gate used across the
-// integration suites. The pure-unit describe below always runs.
-const RUN_INTEG = process.env.RUN_INTEG_TESTS === "1";
-
-const DDL = `
-CREATE TABLE IF NOT EXISTS thread_message (
-  thread_message_id TEXT PRIMARY KEY,
-  account_config_id TEXT NOT NULL,
-  thread_id         TEXT NOT NULL,
-  message_id        TEXT NOT NULL,
-  mailbox_id        TEXT NOT NULL,
-  uid               INTEGER NOT NULL,
-  message_id_header TEXT,
-  in_reply_to       TEXT,
-  reference_order   INTEGER NOT NULL DEFAULT 0,
-  from_email        TEXT,
-  from_name         TEXT,
-  subject           TEXT,
-  internal_date     BIGINT NOT NULL,
-  sent_date         BIGINT NOT NULL,
-  is_read           BOOLEAN NOT NULL,
-  has_attachment    BOOLEAN NOT NULL,
-  star              TEXT NOT NULL DEFAULT 'none',
-  has_stars         BOOLEAN NOT NULL,
-  is_deleted        BOOLEAN NOT NULL,
-  snippet           TEXT,
-  created_at        BIGINT NOT NULL,
-  updated_at        BIGINT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS tm_by_date_idx ON thread_message (account_config_id, sent_date);
-CREATE INDEX IF NOT EXISTS tm_by_mailbox_idx ON thread_message (account_config_id, mailbox_id, sent_date);
-CREATE INDEX IF NOT EXISTS tm_by_attachment_idx ON thread_message (account_config_id, has_attachment, sent_date);
-CREATE INDEX IF NOT EXISTS tm_by_starred_idx ON thread_message (account_config_id, has_stars, sent_date);
-CREATE INDEX IF NOT EXISTS tm_by_mailbox_readstatus_idx ON thread_message (account_config_id, mailbox_id, is_read, sent_date);
-CREATE INDEX IF NOT EXISTS tm_by_thread_idx ON thread_message (thread_id, internal_date);
-CREATE INDEX IF NOT EXISTS tm_by_message_idx ON thread_message (message_id);
-`;
-
 function makeInput(
 	accountConfigId: string,
 	mailboxId: string,
@@ -85,24 +38,13 @@ function makeInput(
 	};
 }
 
-// The trigram search columns/indexes live in an idempotent SQL script applied
-// after `drizzle-kit push` (kept out of the drizzle schema — see the script
-// header). Apply it here too so the test table matches production.
-const SEARCH_DDL = readFileSync(
-	fileURLToPath(
-		new URL("../../../../npm-scripts/pg-search-index.sql", import.meta.url),
-	),
-	"utf8",
-);
-
-async function setupDb(): Promise<void> {
-	const db = drizzle(PG_URL, { schema: { threadMessage: threadMessageTable } });
-	await db.execute(sql.raw(DDL));
-	await db.execute(sql.raw(SEARCH_DDL));
-	const client = (db as unknown as { $client: { end(): Promise<void> } })
-		.$client;
-	await client.end();
-}
+// A real better-sqlite3 database with the FTS5 trigram objects the migrator
+// installs, so the search predicates run their shipped path.
+const setupDb = () =>
+	createSqliteTestDb(
+		{ threadMessage: threadMessageTable },
+		{ searchIndex: true },
+	);
 
 // ─── clampThreadSearchLimit unit tests ───────────────────────────────────────
 
@@ -135,22 +77,22 @@ describe("clampThreadSearchLimit", () => {
 // These six scenarios mirror the canonical DynamoDB test suite in
 // packages/remit-electrodb-service/src/models/thread-message.test.ts.
 
-describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox", {
-	skip: !RUN_INTEG,
-}, () => {
+describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox", () => {
 	let repo: DrizzleThreadMessageRepository;
+	let close: () => Promise<void>;
 	const cleanup: Array<() => Promise<void>> = [];
 
 	before(async () => {
-		await setupDb();
-		repo = new DrizzleThreadMessageRepository(PG_URL);
+		const harness = await setupDb();
+		close = harness.close;
+		repo = new DrizzleThreadMessageRepository(harness.db);
 	});
 
 	after(async () => {
 		for (const fn of cleanup.reverse()) {
 			await fn();
 		}
-		await repo.close();
+		await close();
 	});
 
 	async function seed(
@@ -248,8 +190,8 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 	// ── Scenario 4 ────────────────────────────────────────────────────────────
 	// Matching runs over the WHOLE mailbox via the trigram index, so an old
 	// match well behind the recent rows is still found and paged (the DynamoDB
-	// recent-window bound does not apply on Postgres — the improvement over #443
-	// on the DDB path).
+	// recent-window bound does not apply here — the improvement over #443 on the
+	// DDB path).
 	test("an old match behind the recent rows is still found — matching is whole-mailbox, not window-bounded", async () => {
 		const acct = uuid();
 		const mbx = uuid();
@@ -299,15 +241,15 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "match" },
-			{ excludeDeleted: true, limit: 2 },
+			{ excludeDeleted: true },
 		);
-		assert.equal(count, 2, "count is capped at the page limit when more match");
+		assert.equal(count, 4, "count names every match, not one page of them");
 	});
 
 	// ── Scenario 5 ────────────────────────────────────────────────────────────
-	// desc default: the first page holds the newest matches; count equals the
-	// page length when more rows match than the limit.
-	test("desc page holds the newest matches and count equals items.length", async () => {
+	// desc default: the first page holds the newest matches; the count names the
+	// whole match set behind that page.
+	test("desc page holds the newest matches and the count names the whole match", async () => {
 		const acct = uuid();
 		const mbx = uuid();
 		const now = Date.now();
@@ -335,14 +277,13 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "alpha" },
-			{ excludeDeleted: true, limit: 2 },
+			{ excludeDeleted: true },
 		);
-		assert.equal(count, window.items.length, "count == items.length");
-		assert.equal(count, 2);
+		assert.equal(count, 5, "every alpha row is counted, not the page of two");
 	});
 
 	// ── Scenario 6 ────────────────────────────────────────────────────────────
-	// order:asc returns the OLDEST matches first; count agrees with the page.
+	// order:asc returns the OLDEST matches first; the count is order-independent.
 	test("order:asc returns the oldest matches first", async () => {
 		const acct = uuid();
 		const mbx = uuid();
@@ -375,10 +316,9 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 			acct,
 			mbx,
 			{ subject: "beta" },
-			{ excludeDeleted: true, limit: 2, order: "asc" },
+			{ excludeDeleted: true, order: "asc" },
 		);
-		assert.equal(count, window.items.length, "count == items.length for asc");
-		assert.equal(count, 2);
+		assert.equal(count, 5, "asc counts the whole match set too");
 	});
 });
 
@@ -387,22 +327,22 @@ describe("DrizzleThreadMessageRepository.searchByMailboxWindow / countByMailbox"
 // one query, so matching must span the caller-supplied mailbox scope rather
 // than a single mailbox.
 
-describe("DrizzleThreadMessageRepository.searchByDate", {
-	skip: !RUN_INTEG,
-}, () => {
+describe("DrizzleThreadMessageRepository.searchByDate", () => {
 	let repo: DrizzleThreadMessageRepository;
+	let close: () => Promise<void>;
 	const cleanup: Array<() => Promise<void>> = [];
 
 	before(async () => {
-		await setupDb();
-		repo = new DrizzleThreadMessageRepository(PG_URL);
+		const harness = await setupDb();
+		close = harness.close;
+		repo = new DrizzleThreadMessageRepository(harness.db);
 	});
 
 	after(async () => {
 		for (const fn of cleanup.reverse()) {
 			await fn();
 		}
-		await repo.close();
+		await close();
 	});
 
 	async function seed(
@@ -659,25 +599,25 @@ describe("DrizzleThreadMessageRepository.searchByDate", {
 
 // ─── Native text-search semantics ─────────────────────────────────────────────
 // The type-ahead search box lowercases the query before sending it. These tests
-// pin the Postgres-native behaviour: case- and accent-insensitive substring
+// pin the engine-native behaviour: case- and accent-insensitive substring
 // matching over the whole mailbox, scoped to the account/mailbox.
 
-describe("DrizzleThreadMessageRepository — native text search", {
-	skip: !RUN_INTEG,
-}, () => {
+describe("DrizzleThreadMessageRepository — native text search", () => {
 	let repo: DrizzleThreadMessageRepository;
+	let close: () => Promise<void>;
 	const cleanup: Array<() => Promise<void>> = [];
 
 	before(async () => {
-		await setupDb();
-		repo = new DrizzleThreadMessageRepository(PG_URL);
+		const harness = await setupDb();
+		close = harness.close;
+		repo = new DrizzleThreadMessageRepository(harness.db);
 	});
 
 	after(async () => {
 		for (const fn of cleanup.reverse()) {
 			await fn();
 		}
-		await repo.close();
+		await close();
 	});
 
 	async function seed(
@@ -834,22 +774,22 @@ describe("DrizzleThreadMessageRepository — native text search", {
 
 // ─── Smoke tests for the full interface ──────────────────────────────────────
 
-describe("DrizzleThreadMessageRepository — core CRUD", {
-	skip: !RUN_INTEG,
-}, () => {
+describe("DrizzleThreadMessageRepository — core CRUD", () => {
 	let repo: DrizzleThreadMessageRepository;
+	let close: () => Promise<void>;
 	const cleanup: Array<() => Promise<void>> = [];
 
 	before(async () => {
-		await setupDb();
-		repo = new DrizzleThreadMessageRepository(PG_URL);
+		const harness = await setupDb();
+		close = harness.close;
+		repo = new DrizzleThreadMessageRepository(harness.db);
 	});
 
 	after(async () => {
 		for (const fn of cleanup.reverse()) {
 			await fn();
 		}
-		await repo.close();
+		await close();
 	});
 
 	test("create and get round-trip", async () => {