@remit/backend 0.0.50 → 0.0.52

package/src/jwt-auth.test.ts

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, test } from "node:test";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import {
 	_setVerifierForTest,
-	authenticatePostgresRequest,
+	authenticateSelfHostRequest,
 } from "./jwt-auth.js";
 
 const buildEvent = (
@@ -34,7 +34,7 @@ test("valid token injects verified sub into authorizer claims", async () => {
 		headers: { Authorization: "Bearer good.token.here" },
 	});
 
-	const result = await authenticatePostgresRequest(event);
+	const result = await authenticateSelfHostRequest(event);
 
 	assert.equal(result, null);
 	assert.equal(event.requestContext.authorizer?.claims?.sub, "user-abc");
@@ -49,7 +49,7 @@ test("invalid token returns 401 and does not inject claims", async () => {
 		headers: { authorization: "Bearer bad.token" },
 	});
 
-	const result = await authenticatePostgresRequest(event);
+	const result = await authenticateSelfHostRequest(event);
 
 	assert.equal(result?.statusCode, 401);
 	assert.equal(event.requestContext.authorizer, undefined);
@@ -59,7 +59,7 @@ test("no token with a local bypass configured is allowed", async () => {
 	process.env.LOCAL_ACCOUNT_CONFIG_ID = "some-config-id";
 	const event = buildEvent();
 
-	const result = await authenticatePostgresRequest(event);
+	const result = await authenticateSelfHostRequest(event);
 
 	assert.equal(result, null);
 });
@@ -67,7 +67,7 @@ test("no token with a local bypass configured is allowed", async () => {
 test("no token and no bypass returns 401", async () => {
 	const event = buildEvent();
 
-	const result = await authenticatePostgresRequest(event);
+	const result = await authenticateSelfHostRequest(event);
 
 	assert.equal(result?.statusCode, 401);
 });
@@ -82,7 +82,7 @@ test("pre-injected claims (edge tier) short-circuit verification", async () => {
 		} as unknown as APIGatewayProxyEvent["requestContext"],
 	});
 
-	const result = await authenticatePostgresRequest(event);
+	const result = await authenticateSelfHostRequest(event);
 
 	assert.equal(result, null);
 	assert.equal(event.requestContext.authorizer?.claims?.sub, "edge-user");

package/src/jwt-auth.ts

@@ -56,7 +56,7 @@ const hasLocalBypass = (): boolean =>
 	Boolean(process.env.LOCAL_ACCOUNT_CONFIG_ID);
 
 /**
- * Authenticate a Postgres-mode request from a better-auth RS256 JWT.
+ * Authenticate a self-host request from a better-auth RS256 JWT.
  *
  * On a valid token the verified `sub` is injected into the event's authorizer
  * claims, exactly where the Cognito authorizer puts it, so every downstream
@@ -68,7 +68,7 @@ const hasLocalBypass = (): boolean =>
  * When the edge tier (APISIX) has already verified and injected claims, this is
  * a no-op — the backend trusts pre-populated claims and re-verifies otherwise.
  */
-export const authenticatePostgresRequest = async (
+export const authenticateSelfHostRequest = async (
 	event: APIGatewayProxyEvent,
 ): Promise<APIGatewayProxyResult | null> => {
 	const existingSub = event.requestContext?.authorizer?.claims?.sub;

package/src/service/compose-sqlite.ts

@@ -25,7 +25,6 @@ import {
 	OutboxMessageRepo,
 	QuarantineRepo,
 } from "@remit/drizzle-service";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { env } from "expect-env";
 import {
 	buildSharedDeps,
@@ -34,25 +33,20 @@ import {
 	type RemitClientRepositories,
 } from "./create-remit-client.js";
 
-// The SQLite backend (RFC 036). Mirrors the Postgres composition — the same
-// dialect-neutral Drizzle repos, wired to one shared SQLite file instead of a
-// Postgres server — with two differences the file topology forces (D3): every
-// repo runs on the single serialized connection `createSqliteDatabase` opens
-// (writes cannot bypass serialization, so a plain repo write never joins an
-// open transaction's savepoint), and `threadMessage` takes that shared handle
-// rather than its own connection string, so its writes enlist in the same
-// unit-of-work transaction and the same write queue as everything else.
+// The SQLite adapter composition (RFC 036). Every repo runs on the single
+// serialized connection `createSqliteDatabase` opens (D3), so a plain repo
+// write cannot bypass serialization and join an open transaction's savepoint,
+// and `threadMessage` takes that same shared handle, so its writes enlist in
+// the same unit-of-work transaction and the same write queue as everything
+// else.
 export const buildSqliteClient = async (): Promise<RemitClient> => {
 	const sqliteDbPath = env.SQLITE_DB_PATH;
 
 	const { db } = await createSqliteDatabase(messageDataSchema, {
 		filename: sqliteDbPath,
 	});
-	const genericDb = db as unknown as NodePgDatabase<Record<string, unknown>>;
-
-	const messageDataDb = db as unknown as NodePgDatabase<
-		typeof messageDataSchema
-	>;
+	const genericDb = db;
+	const messageDataDb = db;
 
 	const repositories: RemitClientRepositories = {
 		accountConfig: new AccountConfigRepo(genericDb),

package/src/service/create-remit-client.ts

@@ -85,8 +85,8 @@ export interface RemitClient {
 
 	// Smart Organize (RFC 034, epic #1280). Present on both backends
 	// (`FilterService`/`LabelService`/… on DynamoDB, `FilterRepo`/`LabelRepo`/…
-	// on Postgres) so the matching pipeline and filter CRUD run unchanged on
-	// either. The Postgres side has no TTL reaper for expired Temporary filters;
+	// relationally) so the matching pipeline and filter CRUD run unchanged on
+	// either. The relational side has no TTL reaper for expired Temporary filters;
 	// match-time correctness gates on `expiresAt` (RFC 034 Decision 1.1), never
 	// on the row still existing, so the missing reaper is housekeeping only.
 	filter: IFilterRepository;
@@ -99,7 +99,7 @@ export interface RemitClient {
 	label: ILabelRepository;
 	messageLabel: IMessageLabelRepository;
 
-	// Atomic write set for a message save. Present on Postgres (real
+	// Atomic write set for a message save. Present on the relational backend (real
 	// transaction); absent on DynamoDB, where callers fall back to per-repo
 	// writes with that backend's own (non-transactional) guarantees.
 	unitOfWork?: IUnitOfWork;
@@ -123,16 +123,16 @@ export interface RemitClient {
 
 	// Pending placement-move markers (issue #1271). Present on both backends
 	// (`MessagePlacementMoveService` on DynamoDB, `MessagePlacementMoveRepo` on
-	// Postgres) so a caller never needs to guess which backend is active. Used
+	// relationally) so a caller never needs to guess which backend is active. Used
 	// for read-time count prediction (epic #1281 invariant 4) and by the
 	// account-worker cascade delete. Written by the imap-worker's bulk
 	// body-sync path through this `placementMove`, so the placement producer
-	// runs on whatever backend is active — DynamoDB, Postgres, or SQLite.
+	// runs on whatever backend is active — DynamoDB or SQLite.
 	placementMove: IMessagePlacementMoveRepository;
 
 	// Pending flag-push markers (issue #1273). Present on both backends
 	// (`MessageFlagPushService` on DynamoDB, `MessageFlagPushRepo` on
-	// Postgres). Used for read-time unseenCount prediction (epic #1281
+	// relationally). Used for read-time unseenCount prediction (epic #1281
 	// invariant 4), by the account-worker cascade delete, and by the periodic
 	// per-mailbox sync tick to re-arm a marker stuck `pending`. Unlike
 	// `placementMove`, this one IS written on both backends — `flagQueue`

package/src/service/data-client.test.ts

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, test } from "node:test";
+import {
+	_resetForTest,
+	getClient,
+	type RemitClient,
+	setClient,
+} from "./data-client.js";
+
+const REQUIRED_KEYS: ReadonlyArray<keyof RemitClient> = [
+	"accountConfig",
+	"account",
+	"accountSetting",
+	"address",
+	"mailbox",
+	"mailboxSpecialUse",
+	"message",
+	"messageFlag",
+	"outboxMessage",
+	"threadMessage",
+	"envelope",
+	"accountExportRequest",
+	"quarantine",
+	"storage",
+	"search",
+	"secrets",
+	"bodySync",
+	"flagQueue",
+	"mailboxQueue",
+	"messageMove",
+	"outboxQueue",
+	"createConnectionScope",
+] as const;
+
+afterEach(() => {
+	_resetForTest();
+});
+
+const withSqliteDbPath = async (run: () => Promise<void>): Promise<void> => {
+	const saved = process.env.SQLITE_DB_PATH;
+	const dir = mkdtempSync(join(tmpdir(), "remit-data-client-"));
+	process.env.SQLITE_DB_PATH = join(dir, "remit.db");
+	try {
+		await run();
+	} finally {
+		_resetForTest();
+		if (saved === undefined) delete process.env.SQLITE_DB_PATH;
+		else process.env.SQLITE_DB_PATH = saved;
+		rmSync(dir, { recursive: true, force: true });
+	}
+};
+
+test("getClient() falls back to the in-package composition and constructs every service", async () => {
+	await withSqliteDbPath(async () => {
+		const client = await getClient();
+
+		for (const key of REQUIRED_KEYS) {
+			assert.ok(
+				client[key] !== undefined && client[key] !== null,
+				`RemitClient.${String(key)} must be defined on the fallback path`,
+			);
+		}
+
+		assert.equal(typeof client.createConnectionScope, "function");
+	});
+});
+
+test("getClient() names setClient when nothing is registered and there is no database to open", async () => {
+	const saved = process.env.SQLITE_DB_PATH;
+	delete process.env.SQLITE_DB_PATH;
+
+	try {
+		await assert.rejects(getClient(), /register one with setClient\(\)/);
+	} finally {
+		if (saved !== undefined) process.env.SQLITE_DB_PATH = saved;
+	}
+});
+
+test("getClient() returns the injected client without reading the environment", async () => {
+	const saved = process.env.SQLITE_DB_PATH;
+	delete process.env.SQLITE_DB_PATH;
+
+	const injected = { account: {} } as unknown as RemitClient;
+	setClient(injected);
+
+	try {
+		const client = await getClient();
+		assert.equal(client, injected);
+	} finally {
+		_resetForTest();
+		if (saved !== undefined) process.env.SQLITE_DB_PATH = saved;
+	}
+});

package/src/service/data-client.ts

@@ -0,0 +1,58 @@
+import type { RemitClient } from "./create-remit-client.js";
+
+export type {
+	ConnectionScope,
+	RemitClient,
+} from "./create-remit-client.js";
+
+let clientPromise: Promise<RemitClient> | null = null;
+let injected: RemitClient | null = null;
+
+/**
+ * Register the client from the composition root. An adapter that lives outside
+ * this shared, open-core module — DynamoDB, or a Postgres adapter in the
+ * repository that deploys it — is never imported here; its composition root
+ * calls this before handling a request.
+ */
+export const setClient = (client: RemitClient): void => {
+	injected = client;
+	clientPromise = null;
+};
+
+/**
+ * The SQLite composition this build contains, reached only by a process that
+ * registered no client of its own. The `import()` is dynamic so a bundler
+ * following the entry graph of a process that injects its client never reaches
+ * `@remit/drizzle-service` or drizzle-orm (both `external` for the Lambda
+ * esbuild build).
+ *
+ * `SQLITE_DB_PATH` is the precondition the composition needs, checked ahead of
+ * the import so its absence names `setClient` instead of failing on module
+ * resolution inside a bundle, or — worse — opening an empty database and
+ * serving an empty mailbox. It is a precondition, not a backend selection.
+ */
+const buildRelationalClient = async (): Promise<RemitClient> => {
+	if (!process.env.SQLITE_DB_PATH) {
+		throw new Error(
+			"no client registered — register one with setClient() from your composition root",
+		);
+	}
+	const composition = await import("./compose-sqlite.js");
+	return composition.buildSqliteClient();
+};
+
+export const getClient = (): Promise<RemitClient> => {
+	if (!clientPromise) {
+		clientPromise = injected
+			? Promise.resolve(injected)
+			: buildRelationalClient();
+	}
+
+	return clientPromise;
+};
+
+/** Reset the singleton and any injected client — test use only. */
+export const _resetForTest = (): void => {
+	clientPromise = null;
+	injected = null;
+};

package/src/service/organize.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import type { FilterAnchorItem, FilterItem } from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
+import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { FilterMatchOperator, FilterState } from "@remit/domain-enums";
 import type {
 	AnchorPayload,
@@ -9,7 +9,7 @@ import type {
 	VectorRecord,
 } from "@remit/search-service";
 import { createMemoryVectorStore } from "@remit/search-service";
-import type { RemitClient } from "./dynamodb.js";
+import type { RemitClient } from "./data-client.js";
 import {
 	applyOrganize,
 	matchOrganize,
@@ -487,7 +487,7 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 		);
 	});
 
-	it("fails loud on a body-content (HasWords) clause rather than matching it against a preview", async () => {
+	it("rejects a body-content (HasWords) clause as a 400 rather than matching it against a preview", async () => {
 		const deps = vectorlessDeps([
 			candidate("msg-1", { subject: "Dinner reservation" }),
 		]);
@@ -499,7 +499,12 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 					anchorMessageId: "None",
 					literalClauses: [{ field: "HasWords", value: "invoice" }],
 				}),
-			/HasWords/,
+			(error: unknown) => {
+				assert.ok(error instanceof BadRequestError);
+				assert.equal(error.statusCode, 400);
+				assert.match(error.message, /HasWords/);
+				return true;
+			},
 			"the vector-free literal path must not silently narrow a body match to a preview",
 		);
 		assert.equal(deps.semanticUsed(), false);

package/src/service/organize.ts

@@ -3,7 +3,7 @@ import type {
 	IFilterAnchorRepository,
 	OrganizeJobRequestItem,
 } from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
+import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { FilterClauseField, FilterState } from "@remit/domain-enums";
 import {
 	buildMatchText,
@@ -25,7 +25,7 @@ import {
 	buildEmbeddingServiceFromEnv,
 	buildVectorStoreFromEnv,
 } from "@remit/search-service/from-env";
-import type { RemitClient } from "./dynamodb.js";
+import type { RemitClient } from "./data-client.js";
 import { noteSemanticCapabilityAbsence } from "./semantic-capability.js";
 
 /**
@@ -280,16 +280,14 @@ const matchSemantic = async (
  * happened to be indexed. Body-content matching therefore requires the widen
  * (vector) path — {@link matchSemantic} reconstructs body text from chunk
  * previews there. This guard keeps the two matchers from diverging silently: a
- * body-content clause reaching the vector-free path fails loud instead of
- * returning a wrong set. It is unreachable today — no product surface emits a
- * `HasWords` clause (the organize UI sends empty `literalClauses`, the filter
- * builder emits none) — and stays a fail-fast for any future surface that does.
+ * body-content clause reaching the vector-free path is rejected instead of
+ * returning a wrong set.
  */
 const assertNoBodyContentClause = (
 	clauses: OrganizePredicate["literalClauses"],
 ): void => {
 	if (clauses.some((clause) => clause.field === FilterClauseField.HasWords)) {
-		throw new Error(
+		throw new BadRequestError(
 			"Organize literal matching cannot evaluate a body-content (HasWords) clause without the vector pipeline — it requires the semantic widen path",
 		);
 	}

package/src/service/semantic-capability.test.ts

@@ -33,14 +33,11 @@ describe("noteSemanticCapabilityAbsence", () => {
 		_resetSemanticCapabilityForTest();
 	});
 
-	it("absorbs a missing-module failure on the self-host SQL backends and remembers it", () => {
-		for (const backend of ["sqlite", "postgres"]) {
-			_resetSemanticCapabilityForTest();
-			process.env.DATA_BACKEND = backend;
-			assert.equal(isSemanticSearchUnavailable(), false);
-			assert.equal(noteSemanticCapabilityAbsence(moduleNotFound()), true);
-			assert.equal(isSemanticSearchUnavailable(), true);
-		}
+	it("absorbs a missing-module failure on the self-host SQL backend and remembers it", () => {
+		process.env.DATA_BACKEND = "sqlite";
+		assert.equal(isSemanticSearchUnavailable(), false);
+		assert.equal(noteSemanticCapabilityAbsence(moduleNotFound()), true);
+		assert.equal(isSemanticSearchUnavailable(), true);
 	});
 
 	it("absorbs a dlopen failure (musl loading a glibc extension)", () => {
@@ -53,16 +50,13 @@ describe("noteSemanticCapabilityAbsence", () => {
 	});
 
 	it("absorbs an embedding-model load failure (e2e-dev from source, HuggingFace fetch failed) and remembers it", () => {
-		for (const backend of ["sqlite", "postgres"]) {
-			_resetSemanticCapabilityForTest();
-			process.env.DATA_BACKEND = backend;
-			assert.equal(isSemanticSearchUnavailable(), false);
-			assert.equal(noteSemanticCapabilityAbsence(modelUnavailable()), true);
-			assert.equal(isSemanticSearchUnavailable(), true);
-		}
+		process.env.DATA_BACKEND = "sqlite";
+		assert.equal(isSemanticSearchUnavailable(), false);
+		assert.equal(noteSemanticCapabilityAbsence(modelUnavailable()), true);
+		assert.equal(isSemanticSearchUnavailable(), true);
 	});
 
-	it("rethrows genuine query errors on the self-host SQL backends", () => {
+	it("rethrows genuine query errors on the self-host SQL backend", () => {
 		process.env.DATA_BACKEND = "sqlite";
 		assert.equal(
 			noteSemanticCapabilityAbsence(new Error("SQLITE_BUSY")),

package/src/service/semantic-capability.ts

@@ -35,7 +35,7 @@ import { isSelfHostSqlBackend } from "../data-backend.js";
  * the FTS/literal engine is the primary search surface on these profiles and is
  * unaffected. The absence is remembered so subsequent requests short-circuit.
  *
- * Scoped to the self-host SQL backends: on AWS the pipeline (Bedrock +
+ * Scoped to the self-host SQL backend: on AWS the pipeline (Bedrock +
  * S3 Vectors) is bundled, so a module-resolution failure there is a broken
  * deploy and must keep failing loud. Falling back to the FTS engine here
  * instead was considered and rejected — it would fabricate relevance scores and

package/src/service/compose-postgres.ts

@@ -1,76 +0,0 @@
-import {
-	AccountConfigRepo,
-	AccountExportRequestRepo,
-	AccountRepo,
-	AccountSettingRepo,
-	AddressRepo,
-	DrizzleEnvelopeRepository,
-	DrizzleFilterAnchorTransaction,
-	DrizzleMessageFlagRepository,
-	DrizzleMessageRepository,
-	DrizzleThreadMessageRepository,
-	DrizzleUnitOfWork,
-	FilterAnchorRepo,
-	FilterRepo,
-	LabelRepo,
-	MailboxLockRepo,
-	MailboxRepo,
-	MailboxSpecialUseRepo,
-	MessageFlagPushRepo,
-	MessageLabelRepo,
-	MessagePlacementMoveRepo,
-	messageDataSchema,
-	OrganizeJobRequestRepo,
-	OutboxMessageRepo,
-	QuarantineRepo,
-} from "@remit/drizzle-service";
-import { drizzle, type NodePgDatabase } from "drizzle-orm/node-postgres";
-import { env } from "expect-env";
-import {
-	buildSharedDeps,
-	createRemitClient,
-	type RemitClient,
-	type RemitClientRepositories,
-} from "./create-remit-client.js";
-
-export const buildPostgresClient = (): RemitClient => {
-	const pgConnectionUrl = env.PG_CONNECTION_URL;
-
-	// One drizzle db instance shared across repos.
-	// The schema is registered for message-data tables; i4 repos use the same
-	// underlying connection and only need the builder API (no relational queries).
-	const db = drizzle(pgConnectionUrl, { schema: messageDataSchema });
-	const genericDb = db as unknown as NodePgDatabase<Record<string, unknown>>;
-
-	const messageDataDb = db as unknown as NodePgDatabase<
-		typeof messageDataSchema
-	>;
-
-	const repositories: RemitClientRepositories = {
-		accountConfig: new AccountConfigRepo(genericDb),
-		account: new AccountRepo(genericDb),
-		accountSetting: new AccountSettingRepo(genericDb),
-		address: new AddressRepo(genericDb),
-		mailbox: new MailboxRepo(genericDb),
-		mailboxSpecialUse: new MailboxSpecialUseRepo(genericDb),
-		mailboxLock: new MailboxLockRepo(genericDb),
-		message: new DrizzleMessageRepository(messageDataDb),
-		messageFlag: new DrizzleMessageFlagRepository(messageDataDb),
-		outboxMessage: new OutboxMessageRepo(genericDb),
-		threadMessage: new DrizzleThreadMessageRepository(pgConnectionUrl),
-		envelope: new DrizzleEnvelopeRepository(messageDataDb),
-		accountExportRequest: new AccountExportRequestRepo(genericDb),
-		quarantine: new QuarantineRepo(genericDb),
-		organizeJobRequest: new OrganizeJobRequestRepo(genericDb),
-		placementMove: new MessagePlacementMoveRepo(genericDb),
-		flagPush: new MessageFlagPushRepo(genericDb),
-		filter: new FilterRepo(genericDb),
-		filterAnchor: new FilterAnchorRepo(genericDb),
-		filterAnchorTransaction: new DrizzleFilterAnchorTransaction(genericDb),
-		label: new LabelRepo(genericDb),
-		messageLabel: new MessageLabelRepo(genericDb),
-		unitOfWork: new DrizzleUnitOfWork(messageDataDb),
-	};
-
-	return createRemitClient({ repositories, ...buildSharedDeps() });
-};

package/src/service/dynamodb.test.ts

@@ -1,98 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, test } from "node:test";
-import {
-	_resetForTest,
-	getClient,
-	type RemitClient,
-	setClient,
-} from "./dynamodb.js";
-
-const REQUIRED_KEYS: ReadonlyArray<keyof RemitClient> = [
-	"accountConfig",
-	"account",
-	"accountSetting",
-	"address",
-	"mailbox",
-	"mailboxSpecialUse",
-	"message",
-	"messageFlag",
-	"outboxMessage",
-	"threadMessage",
-	"envelope",
-	"accountExportRequest",
-	"quarantine",
-	"storage",
-	"search",
-	"secrets",
-	"bodySync",
-	"flagQueue",
-	"mailboxQueue",
-	"messageMove",
-	"outboxQueue",
-	"createConnectionScope",
-] as const;
-
-afterEach(() => {
-	_resetForTest();
-});
-
-test("getClient() with DATA_BACKEND=postgres constructs all services without throwing", async () => {
-	const savedBackend = process.env.DATA_BACKEND;
-	const savedPgUrl = process.env.PG_CONNECTION_URL;
-
-	process.env.DATA_BACKEND = "postgres";
-	process.env.PG_CONNECTION_URL =
-		"postgresql://remit:remit@localhost:5432/remit_test";
-
-	try {
-		const client = await getClient();
-
-		for (const key of REQUIRED_KEYS) {
-			assert.ok(
-				client[key] !== undefined && client[key] !== null,
-				`RemitClient.${key} must be defined on the postgres path`,
-			);
-		}
-
-		assert.equal(typeof client.createConnectionScope, "function");
-	} finally {
-		_resetForTest();
-		if (savedBackend === undefined) {
-			delete process.env.DATA_BACKEND;
-		} else {
-			process.env.DATA_BACKEND = savedBackend;
-		}
-		if (savedPgUrl === undefined) {
-			delete process.env.PG_CONNECTION_URL;
-		} else {
-			process.env.PG_CONNECTION_URL = savedPgUrl;
-		}
-	}
-});
-
-test("getClient() without DATA_BACKEND throws until a client is registered", () => {
-	const savedBackend = process.env.DATA_BACKEND;
-	delete process.env.DATA_BACKEND;
-
-	try {
-		assert.throws(() => getClient(), /no DynamoDB client registered/);
-	} finally {
-		if (savedBackend !== undefined) process.env.DATA_BACKEND = savedBackend;
-	}
-});
-
-test("getClient() without DATA_BACKEND returns the injected client", async () => {
-	const savedBackend = process.env.DATA_BACKEND;
-	delete process.env.DATA_BACKEND;
-
-	const injected = { account: {} } as unknown as RemitClient;
-	setClient(injected);
-
-	try {
-		const client = await getClient();
-		assert.equal(client, injected);
-	} finally {
-		_resetForTest();
-		if (savedBackend !== undefined) process.env.DATA_BACKEND = savedBackend;
-	}
-});

package/src/service/dynamodb.ts

@@ -1,57 +0,0 @@
-import type { RemitClient } from "./create-remit-client.js";
-
-export type {
-	ConnectionScope,
-	RemitClient,
-} from "./create-remit-client.js";
-
-let clientPromise: Promise<RemitClient> | null = null;
-let injected: RemitClient | null = null;
-
-/**
- * Register the DynamoDB-backed client from the composition root. The DynamoDB
- * composition lives outside this shared, open-core module and is never imported
- * here. Every DynamoDB entry point calls this before handling a request. The
- * relational backends compose in-package below and never touch this seam.
- */
-export const setClient = (client: RemitClient): void => {
-	injected = client;
-	clientPromise = null;
-};
-
-// The API process and the imap-worker share this composition root. The
-// relational backends are loaded through a lazy `import()` of their own
-// in-package composition module, so the module a given deploy never runs never
-// enters its graph: `@remit/drizzle-service`/`drizzle-orm` stay out of a
-// Lambda bundle (both `external` for the Lambda esbuild build;
-// `remit-lambda-bundles.test.ts` enforces this). The DynamoDB backend is
-// injected by the composition root through `setClient`, so this module carries
-// no import of the DynamoDB composition.
-export const getClient = (): Promise<RemitClient> => {
-	if (!clientPromise) {
-		if (process.env.DATA_BACKEND === "postgres") {
-			clientPromise = import("./compose-postgres.js").then((m) =>
-				m.buildPostgresClient(),
-			);
-		} else if (process.env.DATA_BACKEND === "sqlite") {
-			clientPromise = import("./compose-sqlite.js").then((m) =>
-				m.buildSqliteClient(),
-			);
-		} else {
-			if (!injected) {
-				throw new Error(
-					"no DynamoDB client registered — register one with setClient() from your composition root",
-				);
-			}
-			clientPromise = Promise.resolve(injected);
-		}
-	}
-
-	return clientPromise;
-};
-
-/** Reset the singleton and any injected client — test use only. */
-export const _resetForTest = (): void => {
-	clientPromise = null;
-	injected = null;
-};