@remit/drizzle-service 0.0.35 → 0.0.36

package/src/repos/thread-search-predicates.ts

@@ -1,34 +1,14 @@
 import { type SQL, sql } from "drizzle-orm";
-import { isSqlite } from "../dialect.js";
 
 // Accent- and case-insensitive substring match over the whole mailbox, isolated
-// here as the one text-search seam that genuinely differs by dialect (RFC 036
-// D1). The subject and sender predicates match the DynamoDB `contains()`
-// substring contract: LIKE metacharacters (`\`, `%`, `_`) are escaped in JS so
-// the needle arrives as bind-parameter text, and the escaped form is treated
-// literally.
+// here as the one text-search seam whose behaviour is engine-specific. The
+// subject and sender predicates match the `contains()` substring contract:
+// LIKE metacharacters (`\`, `%`, `_`) are escaped in JS so the needle arrives as
+// bind-parameter text, and the escaped form is treated literally.
 
 const escapeLike = (term: string): string => term.replace(/[\\%_]/g, "\\$&");
 
-// ─── Postgres ────────────────────────────────────────────────────────────────
-// The folded expressions must reproduce the indexed expressions in
-// npm-scripts/pg-search-index.sql exactly (immutable unaccent + lower over the
-// coalesced text) so the planner uses the trigram GIN indexes. Matching runs
-// over the whole mailbox — Postgres indexes the text, so there is no
-// recent-window read bound.
-const PG_SUBJECT_FOLDED = sql`remit_immutable_unaccent(lower(coalesce(subject, '')))`;
-const PG_FROM_FOLDED = sql`remit_immutable_unaccent(lower(coalesce(from_name, '') || ' ' || coalesce(from_email, '')))`;
-
-const pgLikePattern = (term: string): SQL =>
-	sql`'%' || remit_immutable_unaccent(lower(${escapeLike(term)})) || '%'`;
-
-const pgSubjectMatch = (term: string): SQL =>
-	sql`${PG_SUBJECT_FOLDED} like ${pgLikePattern(term)}`;
-const pgFromMatch = (term: string): SQL =>
-	sql`${PG_FROM_FOLDED} like ${pgLikePattern(term)}`;
-
-// ─── SQLite ──────────────────────────────────────────────────────────────────
-// Text search on SQLite is the external-content FTS5 trigram index that
+// Text search is the external-content FTS5 trigram index that
 // npm-scripts/sqlite-search-index.sql installs (RFC 036 D4): `thread_message_fts`
 // indexes the folded subject and sender, and MATCH is an accent- and
 // case-insensitive substring search (the tokenizer folds both sides, so the
@@ -39,7 +19,7 @@ const pgFromMatch = (term: string): SQL =>
 // falls back to the unindexed folded LIKE scan D4 names — lower() both sides,
 // substring-match, `escape '\'` making the JS-escaped metacharacters literal.
 // It is case-insensitive for ASCII and does not fold diacritics; the accepted
-// per-target difference from Postgres `unaccent`.
+// difference between a short term and an indexed one (contract C10).
 
 // FTS5 treats bare query text as its match grammar (AND/OR/NEAR/`*`/`-`/`:`), so
 // wrap the term as a double-quoted string literal — doubling embedded quotes —
@@ -54,26 +34,18 @@ const isTrigramIndexable = (term: string): boolean => [...term].length >= 3;
 const ftsRowidMatch = (matchExpr: string): SQL =>
 	sql`"thread_message"."rowid" in (select "rowid" from "thread_message_fts" where "thread_message_fts" match ${matchExpr})`;
 
-const SQLITE_SUBJECT_FOLDED = sql`lower(coalesce(subject, ''))`;
-const SQLITE_FROM_FOLDED = sql`lower(coalesce(from_name, '') || ' ' || coalesce(from_email, ''))`;
+const SUBJECT_FOLDED = sql`lower(coalesce(subject, ''))`;
+const FROM_FOLDED = sql`lower(coalesce(from_name, '') || ' ' || coalesce(from_email, ''))`;
 
-const sqliteLikePattern = (term: string): SQL =>
+const likePattern = (term: string): SQL =>
 	sql`'%' || lower(${escapeLike(term)}) || '%'`;
 
-const sqliteSubjectMatch = (term: string): SQL =>
+export const subjectMatch = (term: string): SQL =>
 	isTrigramIndexable(term)
 		? ftsRowidMatch(`subject : ${ftsPhrase(term)}`)
-		: sql`${SQLITE_SUBJECT_FOLDED} like ${sqliteLikePattern(term)} escape '\\'`;
+		: sql`${SUBJECT_FOLDED} like ${likePattern(term)} escape '\\'`;
 
-const sqliteFromMatch = (term: string): SQL =>
+export const fromMatch = (term: string): SQL =>
 	isTrigramIndexable(term)
 		? ftsRowidMatch(`sender : ${ftsPhrase(term)}`)
-		: sql`${SQLITE_FROM_FOLDED} like ${sqliteLikePattern(term)} escape '\\'`;
-
-// ─── Dialect selection ───────────────────────────────────────────────────────
-
-export const subjectMatch = (term: string): SQL =>
-	isSqlite() ? sqliteSubjectMatch(term) : pgSubjectMatch(term);
-
-export const fromMatch = (term: string): SQL =>
-	isSqlite() ? sqliteFromMatch(term) : pgFromMatch(term);
+		: sql`${FROM_FOLDED} like ${likePattern(term)} escape '\\'`;

package/src/repos/unit-of-work.ts

@@ -8,7 +8,7 @@ import { DrizzleMessageRepository } from "./message.js";
 import { DrizzleThreadMessageRepository } from "./thread-message.js";
 
 /**
- * Runs a write set inside a single Postgres transaction. The repositories handed
+ * Runs a write set inside a single transaction. The repositories handed
  * to the callback are bound to that transaction, so the data rows and the
  * transactional-outbox rows the message write appends commit atomically — a
  * throw anywhere rolls the whole set back, outbox included.

package/src/schema/i4-account-config.ts

@@ -1,4 +1,4 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const accountConfigTable = entities.accountConfigs;
 export const accountTable = entities.accounts;

package/src/schema/i4-account-export-request.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const accountExportRequestTable = entities.accountExportRequests;

package/src/schema/i4-account-setting.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const accountSettingTable = entities.accountSettings;

package/src/schema/i4-address.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const addressTable = entities.addresses;

package/src/schema/i4-mailbox-lock.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const mailboxLockTable = entities.mailboxLocks;

package/src/schema/i4-mailbox.ts

@@ -1,4 +1,4 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const mailboxTable = entities.mailboxes;
 export const mailboxSpecialUseTable = entities.mailboxSpecialUseEntries;

package/src/schema/i4-message-flag-push.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const messageFlagPushTable = entities.messageFlagPushes;

package/src/schema/i4-message-placement-move.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const messagePlacementMoveTable = entities.messagePlacementMoves;

package/src/schema/i4-organize-job-request.ts

@@ -1 +1 @@
-export { organizeJobRequests as organizeJobRequestTable } from "@remit/drizzle-pg-schema";
+export { organizeJobRequests as organizeJobRequestTable } from "@remit/drizzle-sqlite-schema";

package/src/schema/i4-outbox-message.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const outboxMessageTable = entities.outboxMessages;

package/src/schema/message-data.ts

@@ -1,4 +1,4 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 import { outboxTable } from "./outbox.js";
 
 export { outboxTable };

package/src/schema/outbox.ts

@@ -1,74 +1,31 @@
 import { sql } from "drizzle-orm";
-import {
-	bigint,
-	jsonb,
-	index as pgIndex,
-	pgTable,
-	text as pgText,
-	timestamp,
-	uuid,
-} from "drizzle-orm/pg-core";
-import {
-	index as sqliteIndex,
-	integer as sqliteInteger,
-	sqliteTable,
-	text as sqliteText,
-} from "drizzle-orm/sqlite-core";
-import { isSqlite } from "../dialect.js";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 /**
  * Transactional outbox. It has no TypeSpec entity — it is infrastructure for
  * the search-index worker (append a row per body change / move, drain by id,
  * mark `processed_at`). The partial index selects unprocessed rows for the
- * boot-time backstop scan (Postgres) and the short-cadence poll (SQLite,
- * RFC 036 D2). It is hand-written per dialect because the two column-builder
- * sets share no surface; both keep identical column names so the repos and the
- * drain logic read the same rows on either backend.
+ * short-cadence poll (RFC 036 D2).
  *
- * Both raw tables are exported for committed-migration generation (schema-full
- * per dialect). The runtime `outboxTable` is the dialect-selected one, cast to
- * the Postgres type so the repos keep one static shape (RFC 036 D1).
+ * Exported raw for committed-migration generation (schema-full-sqlite) as well
+ * as for the repos and the drain logic.
  */
-export const pgOutboxTable = pgTable(
+export const outboxTable = sqliteTable(
 	"outbox",
 	{
-		id: uuid("id").primaryKey(),
-		messageId: pgText("message_id").notNull(),
-		event: pgText("event").notNull(),
-		payload: jsonb("payload").notNull(),
-		createdAt: timestamp("created_at", { withTimezone: true })
-			.defaultNow()
-			.notNull(),
-		processedAt: bigint("processed_at", { mode: "number" }),
-	},
-	(t) => [
-		pgIndex("outbox_message_id_idx").on(t.messageId),
-		pgIndex("outbox_unprocessed_idx")
-			.on(t.createdAt)
-			.where(sql`${t.processedAt} IS NULL`),
-	],
-);
-
-export const sqliteOutboxTable = sqliteTable(
-	"outbox",
-	{
-		id: sqliteText("id").primaryKey(),
-		messageId: sqliteText("message_id").notNull(),
-		event: sqliteText("event").notNull(),
-		payload: sqliteText("payload", { mode: "json" }).notNull(),
-		createdAt: sqliteInteger("created_at", { mode: "timestamp_ms" })
+		id: text("id").primaryKey(),
+		messageId: text("message_id").notNull(),
+		event: text("event").notNull(),
+		payload: text("payload", { mode: "json" }).notNull(),
+		createdAt: integer("created_at", { mode: "timestamp_ms" })
 			.$defaultFn(() => new Date())
 			.notNull(),
-		processedAt: sqliteInteger("processed_at", { mode: "number" }),
+		processedAt: integer("processed_at", { mode: "number" }),
 	},
 	(t) => [
-		sqliteIndex("outbox_message_id_idx").on(t.messageId),
-		sqliteIndex("outbox_unprocessed_idx")
+		index("outbox_message_id_idx").on(t.messageId),
+		index("outbox_unprocessed_idx")
 			.on(t.createdAt)
 			.where(sql`${t.processedAt} IS NULL`),
 	],
 );
-
-export const outboxTable: typeof pgOutboxTable = isSqlite()
-	? (sqliteOutboxTable as unknown as typeof pgOutboxTable)
-	: pgOutboxTable;

package/src/schema/quarantine.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const quarantineTable = entities.quarantines;

package/src/schema/thread-message.ts

@@ -1,3 +1,3 @@
-import { entities } from "./active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const threadMessageTable = entities.threadMessages;

package/src/schema-full-sqlite.ts

@@ -2,10 +2,12 @@
 // (RFC 036 D5) — consumed by packages/migrate/drizzle.entities.sqlite.config.ts
 // and the drift guard (npm-scripts/check-vps-migrations.mjs), never at runtime.
 //
-// The SQLite twin of schema-full.ts: the sqlite-dialect entity package
-// wholesale (`sqliteTable`/`text(json)`/`integer`) plus the raw sqlite outbox
-// infra table. Kept separate from the runtime facade (../schema/active-entities)
-// because drizzle-kit's `generate --dialect sqlite` needs the real sqlite table
-// objects, not the pg-cast the repos consume.
+// It pulls the generated entity package in wholesale, so a new TypeSpec entity
+// flows into the committed migration with nothing to hand-maintain. The only
+// addition is the `outbox` infra table, which has no entity.
+//
+// schema.ts stays the app/dev surface (single `*Table` alias per table, what
+// the repos and `pushSchema` need); this file exposes canonical names, so it
+// must not be fed to `pushSchema` alongside schema.ts (duplicate index names).
 export * from "@remit/drizzle-sqlite-schema";
-export { sqliteOutboxTable as outboxTable } from "./schema/outbox.js";
+export { outboxTable } from "./schema/outbox.js";

package/src/schema.ts

@@ -2,11 +2,11 @@
 // the names the repos and `pushSchema` (test-db.ts) consume. Each table appears
 // exactly once here — `pushSchema` registers a table's indexes per exported
 // binding, so exposing one table under two names creates duplicate index names
-// and breaks `apply()`. The committed-migration `generate` reads schema-full.ts
-// instead (the entity package wholesale), so the migration is driven by the
-// entities, not by this hand-maintained alias list.
+// and breaks `apply()`. The committed-migration `generate` reads
+// schema-full-sqlite.ts instead (the entity package wholesale), so the
+// migration is driven by the entities, not by this hand-maintained alias list.
 
-import { entities } from "./schema/active-entities.js";
+import * as entities from "@remit/drizzle-sqlite-schema";
 
 export const filterAnchorTable = entities.filterAnchors;
 export const filterTable = entities.filters;

package/src/sqlite-client.ts

@@ -12,10 +12,9 @@ import { serializeSqliteWrites } from "./tx.js";
 // serialization (RFC 036 D3). `run`/`transaction`/reads pass through by design —
 // see the wrapper's comment.
 //
-// better-sqlite3 and its drizzle driver are imported dynamically so the Postgres
-// path never loads the native binding, and so the whole module stays out of the
-// DynamoDB Lambda bundle (this package is `external` there — see
-// remit-backend/src/service/dynamodb.ts).
+// better-sqlite3 and its drizzle driver are imported dynamically so the whole
+// module stays out of the DynamoDB Lambda bundle (this package is `external`
+// there — see remit-backend/src/service/data-client.ts).
 
 export interface SqliteClientOptions {
 	filename: string;
@@ -41,7 +40,7 @@ export async function createSqliteDatabase<
 	sqlite.pragma("synchronous = NORMAL");
 	sqlite.pragma("foreign_keys = ON");
 
-	const base = drizzle(sqlite, { schema }) as unknown as Db<TSchema>;
+	const base: Db<TSchema> = drizzle(sqlite, { schema });
 
 	return {
 		db: serializeSqliteWrites(base),

package/src/test-db-sqlite.ts

@@ -12,14 +12,9 @@ const searchIndexDdl = (): string =>
 		"utf8",
 	);
 
-// SQLite counterpart of repos/test-helpers.ts's embedded-Postgres harness
-// (RFC 036 D1). A real better-sqlite3 database (in-memory by default) with the
-// schema pushed from the drizzle table objects — the sqlite `pushSchema` — so a
-// repo runs against the exact dialect it ships on, no hand-maintained DDL.
-//
-// The tests that use it run in a `DATA_BACKEND=sqlite` process (see
-// test:run:sqlite), so the schema facades resolve to the sqlite tables and the
-// repos take the sqlite transaction / predicate paths.
+// A real better-sqlite3 database (in-memory by default) with the schema pushed
+// from the drizzle table objects — the sqlite `pushSchema` — so a repo runs
+// against the exact engine it ships on, no hand-maintained DDL.
 
 export type SqliteTestDb<TSchema extends Record<string, unknown>> = Db<TSchema>;
 
@@ -36,7 +31,7 @@ export async function createSqliteTestDb<
 	const sqlite = new Database(options?.filename ?? ":memory:");
 	sqlite.pragma("foreign_keys = ON");
 
-	const db = drizzle(sqlite, { schema }) as unknown as SqliteTestDb<TSchema>;
+	const db: SqliteTestDb<TSchema> = drizzle(sqlite, { schema });
 
 	// pushSQLiteSchema derives the CREATE statements from the table objects;
 	// better-sqlite3 rejects its own `apply()` (it issues the DDL through a

package/src/test-db.ts

@@ -1,76 +1,21 @@
-import { pushSchema } from "drizzle-kit/api";
-import { drizzle } from "drizzle-orm/node-postgres";
-import EmbeddedPostgres from "embedded-postgres";
-import pg from "pg";
+import type Database from "better-sqlite3";
+import type { Db } from "./db.js";
 import * as schema from "./schema.js";
+import { createSqliteTestDb } from "./test-db-sqlite.js";
 
-const { Pool } = pg;
-
-export type TestDb = ReturnType<typeof drizzle<typeof schema>>;
-
-let _instance: EmbeddedPostgres | null = null;
-let _port = 0;
-
-async function ensureStarted(): Promise<{ port: number }> {
-	if (_instance) return { port: _port };
-
-	for (let attempt = 0; attempt < 10; attempt++) {
-		const port = 15000 + Math.floor(Math.random() * 5000);
-		const instance = new EmbeddedPostgres({
-			databaseDir: `/tmp/remit-test-pg-${process.pid}-${port}-${attempt}`,
-			port,
-			persistent: false,
-		});
-		try {
-			await instance.initialise();
-			await instance.start();
-		} catch (err) {
-			await instance.stop().catch(() => undefined);
-			if (attempt === 9) throw err;
-			continue;
-		}
-		_instance = instance;
-		_port = port;
-		process.on("exit", () => {
-			instance.stop().catch(() => undefined);
-		});
-		return { port };
-	}
-	throw new Error("Failed to start embedded postgres");
-}
+export type TestDb = Db<typeof schema>;
 
+/**
+ * The whole app schema on a throwaway in-memory SQLite database, with the FTS5
+ * search objects installed on top — the harness a repo test takes when it needs
+ * more tables than its own.
+ */
 export async function createTestDb(): Promise<{
 	db: TestDb;
-	pool: pg.Pool;
+	sqlite: Database.Database;
 	close: () => Promise<void>;
 }> {
-	const { port } = await ensureStarted();
-
-	const pool = new Pool({
-		host: "localhost",
-		port,
-		user: "postgres",
-		password: "password",
-		database: "postgres",
-	});
-
-	const db = drizzle(pool, { schema }) as TestDb;
-
-	const { apply } = await pushSchema(schema, drizzle(pool));
-	await apply();
-
-	return {
-		db,
-		pool,
-		close: async () => {
-			await pool.end();
-			if (_instance) {
-				const inst = _instance;
-				_instance = null;
-				await inst.stop();
-			}
-		},
-	};
+	return createSqliteTestDb(schema, { searchIndex: true });
 }
 
 export { randomId } from "./id.js";

package/src/tx.ts

@@ -2,14 +2,13 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { type SQL, sql } from "drizzle-orm";
 import type { Db } from "./db.js";
-import { isSqlite } from "./dialect.js";
 
-// Runs a write set in one transaction, on either dialect (RFC 036 D1).
+// Runs a write set in one transaction.
 //
-// Postgres uses drizzle's own `db.transaction()`. better-sqlite3 cannot: its
-// native transaction runner rejects a callback that returns a promise, and the
-// repos' write sets are async. SQLite instead brackets the callback with a
-// SAVEPOINT — a savepoint opens a transaction when none is active and commits
+// better-sqlite3's native transaction runner rejects a callback that returns a
+// promise, and the repos' write sets are async, so drizzle's own
+// `db.transaction()` cannot be used. The callback is bracketed with a SAVEPOINT
+// instead — a savepoint opens a transaction when none is active and commits
 // when the outermost one is released.
 //
 // All writers on this backend share one better-sqlite3 connection (RFC 036 D3),
@@ -66,10 +65,6 @@ export async function runInTransaction<
 	TSchema extends Record<string, unknown>,
 	T,
 >(db: Db<TSchema>, fn: (tx: Db<TSchema>) => Promise<T>): Promise<T> {
-	if (!isSqlite()) {
-		return db.transaction(fn);
-	}
-
 	if (inSqliteTx.getStore()) {
 		// Already inside a top-level transaction on this connection — nest with a
 		// savepoint, do not re-queue.
@@ -184,8 +179,7 @@ function wrapWriteBuilder<B extends object>(builder: B): B {
 // savepoint DDL, already inside a serialized unit), `transaction`, and reads —
 // reads are not serialized, so a read issued during another unit's open
 // transaction can still observe uncommitted rows; the wrapper closes the
-// write-side rollback hazard, not read isolation. On Postgres this is never
-// applied.
+// write-side rollback hazard, not read isolation.
 export function serializeSqliteWrites<TDb extends Db<Record<string, unknown>>>(
 	db: TDb,
 ): TDb {

package/drizzle.config.ts

@@ -1,15 +0,0 @@
-const url =
-	process.env.DATABASE_URL ??
-	process.env.PG_CONNECTION_URL ??
-	"postgresql://remit:remit@localhost:5432/remit_dev";
-
-export default {
-	dialect: "postgresql",
-	schema: "./src/schema.ts",
-	out: "./.drizzle",
-	dbCredentials: { url },
-	// The better-auth identity tables (auth_*) share this database but are owned
-	// by remit-auth-service's own drizzle config. Exclude them here so an entity
-	// push never proposes dropping tables it does not manage.
-	tablesFilter: ["!auth_*"],
-};

package/src/dialect.ts

@@ -1,13 +0,0 @@
-// The SQL dialect this process runs against (RFC 036 D1). One deployment is
-// one backend, chosen once at startup by `DATA_BACKEND`: `sqlite` selects the
-// SQLite entity tables, outbox table, transaction strategy, and search
-// predicates; anything else keeps the Postgres behavior that predates this
-// switch. Read once at module load — the repos and schema facade branch on it,
-// and a single process never mixes dialects.
-
-export type SqlDialect = "postgres" | "sqlite";
-
-export const SQL_DIALECT: SqlDialect =
-	process.env.DATA_BACKEND === "sqlite" ? "sqlite" : "postgres";
-
-export const isSqlite = (): boolean => SQL_DIALECT === "sqlite";