@remit/drizzle-service 0.0.34 → 0.0.36

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.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();
@@ -387,22 +329,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 +601,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 +776,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 () => {

package/src/repos/thread-message.ts

@@ -19,7 +19,6 @@ import {
 	type SQL,
 	sql,
 } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/node-postgres";
 import shortUuid from "short-uuid";
 import { v5 as uuidv5 } from "uuid";
 import type { Db } from "../db.js";
@@ -90,7 +89,6 @@ function decodeAccountCursor(token: string): AccountCursor {
 
 // ─── Schema ──────────────────────────────────────────────────────────────────
 
-const SCHEMA = { threadMessage: threadMessageTable };
 type Row = typeof threadMessageTable.$inferSelect;
 
 // ─── Row mapping ─────────────────────────────────────────────────────────────
@@ -128,9 +126,9 @@ function toItem(row: Row): ThreadMessageItem {
 
 // ─── Search predicates ────────────────────────────────────────────────────────
 
-// The accent-/case-insensitive substring predicates are the one text-search
-// seam that differs by dialect; they live in ./thread-search-predicates.ts
-// (Postgres: unaccent + pg_trgm; SQLite: a folded LIKE fallback, RFC 036 D4).
+// The accent-/case-insensitive substring predicates are the one engine-specific
+// text-search seam; they live in ./thread-search-predicates.ts (the FTS5 trigram
+// index, with a folded LIKE fallback below three characters, RFC 036 D4).
 
 // Translate SearchOptions into SQL conditions: subject/from/query as indexed
 // text predicates, the rest as plain column equalities. A multi-word `query`
@@ -196,22 +194,12 @@ export class DrizzleThreadMessageRepository
 {
 	private db: Db<Record<string, unknown>>;
 
-	constructor(connectionOrDb: string | Db<Record<string, unknown>>) {
-		this.db =
-			typeof connectionOrDb === "string"
-				? drizzle(connectionOrDb, { schema: SCHEMA })
-				: connectionOrDb;
+	constructor(db: Db<Record<string, unknown>>) {
+		this.db = db;
 	}
 
 	async close(): Promise<void> {
-		// The underlying driver differs by dialect: a pg Pool closes with `end()`,
-		// a better-sqlite3 Database with `close()`. Feature-detect so a sqlite
-		// handle never hits a missing `end()`.
 		const client = (this.db as unknown as { $client?: unknown }).$client;
-		if (client && typeof (client as { end?: unknown }).end === "function") {
-			await (client as { end: () => Promise<void> }).end();
-			return;
-		}
 		if (client && typeof (client as { close?: unknown }).close === "function") {
 			(client as { close: () => void }).close();
 		}
@@ -831,8 +819,8 @@ export class DrizzleThreadMessageRepository
 	 * the boolean filters) runs in SQL over the whole mailbox via the trigram
 	 * indexes, ordered by sent_date with an id tiebreak. `limit` is a page size
 	 * over MATCHES (clamped to THREAD_SEARCH_MAX_LIMIT); the DynamoDB name is
-	 * kept for interface parity, but there is no recent-window read bound —
-	 * Postgres indexes the text, so a match anywhere in the mailbox is reachable.
+	 * kept for interface parity, but there is no recent-window read bound — the
+	 * text is indexed, so a match anywhere in the mailbox is reachable.
 	 *
 	 * Cursor: the last returned row `(sentDate, threadMessageId)`. A full page
 	 * yields a cursor so callers can resume.