@remit/drizzle-service 0.0.55 → 0.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

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

@@ -1,4 +1,4 @@
-import { or, type SQL, sql } from "drizzle-orm";
+import { eq, or, type SQL, sql } from "drizzle-orm";
 import { addressTable } from "../schema/i4-address.js";
 
 // The address search seam. A term is matched as a substring of the display name,
@@ -49,10 +49,12 @@ export const addressSearchMatch = (term: string): SQL => {
  * spells out ranks above every prefix of it: a display name is free text the
  * sender picks, and a domain somebody else registered is a prefix away from the
  * address the reader typed, so neither may take the suggestion slot from the
- * address that matches whole. Below that, a match at the start of a column
- * outranks one in the middle, and within each the whole address, the local part
- * and the display name outrank the domain they share. A mid-string match still
- * comes back — this only decides the order.
+ * address that matches whole. A term that spells out a domain whole ranks next,
+ * so `ischen.nl` reaches the domain it names before `ischen.nl.co`, which only
+ * starts with it (#829). Below that, a match at the start of a column outranks
+ * one in the middle, and within each the whole address, the local part and the
+ * display name outrank the domain they share. A mid-string match still comes
+ * back — this only decides the order.
  */
 export const addressMatchRank = (term: string | undefined): SQL<number> => {
 	// Not the bare literal `0`: SQLite reads an integer literal in ORDER BY as a
@@ -60,7 +62,10 @@ export const addressMatchRank = (term: string | undefined): SQL<number> => {
 	if (!term) return sql<number>`cast(0 as integer)`;
 	const { leading, anywhere } = patterns(term);
 	const tiers = [
-		sql`${addressTable.normalizedEmail} = ${term.toLowerCase()}`,
+		eq(addressTable.normalizedEmail, term.toLowerCase()),
+		// `domain` is stored as the envelope spelled it, so `Ischen.NL` only meets
+		// a folded term through `lower()`; `like` folds ASCII on its own.
+		sql`lower(${addressTable.domain}) = ${term.toLowerCase()}`,
 		...SEARCH_COLUMNS.map((column) => like(column, leading)),
 		...SEARCH_COLUMNS.map((column) => like(column, anywhere)),
 	];

package/src/repos/i4-address.test.ts

@@ -474,6 +474,85 @@ describe("AddressRepo", () => {
 		]);
 	});
 
+	test("listByAccountConfig ranks the domain a bare term names above one that only starts with it", async () => {
+		const accountConfigId = randomId();
+		const lookalike = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "matthijs@ischen.nl.co"),
+			displayName: "Ischen Support",
+			normalizedCompound: "ischen support matthijs@ischen.nl.co",
+			inboundCount: 900,
+		});
+		// The envelope's own spelling: `domain` is stored unfolded.
+		const own = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "matthijs@ischen.nl"),
+			domain: "Ischen.NL",
+			displayName: "Matthijs van Henten",
+			normalizedCompound: "matthijs van henten matthijs@ischen.nl",
+			inboundCount: 1,
+		});
+
+		const found = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "ischen.nl",
+		});
+		assert.deepEqual(
+			found.items.map((a) => a.normalizedEmail),
+			[own.normalizedEmail, lookalike.normalizedEmail],
+			"the domain the term names leads one that registered a suffix of it",
+		);
+
+		const onlySuggestion = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "ischen.nl",
+			limit: 1,
+		});
+		assert.deepEqual(
+			onlySuggestion.items.map((a) => a.normalizedEmail),
+			[own.normalizedEmail],
+			"volume on the lookalike must not take the single suggestion slot",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [
+			lookalike.addressId,
+			own.addressId,
+		]);
+	});
+
+	test("listByAccountConfig keeps an address the term spells out whole above a row that only owns the domain", async () => {
+		const accountConfigId = randomId();
+		// A harvested header that carried the bare domain where an address belongs.
+		const bare = await repo.createAddress({
+			addressId: randomId(),
+			accountConfigId,
+			localPart: "ischen.nl",
+			domain: "",
+			normalizedEmail: "ischen.nl",
+			normalizedCompound: "ischen.nl",
+			displayName: "Ischen",
+		});
+		const domainOwner = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "matthijs@ischen.nl"),
+			displayName: "Matthijs van Henten",
+			normalizedCompound: "matthijs van henten matthijs@ischen.nl",
+			inboundCount: 900,
+		});
+
+		const found = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "ischen.nl",
+		});
+		assert.deepEqual(
+			found.items.map((a) => a.normalizedEmail),
+			[bare.normalizedEmail, domainOwner.normalizedEmail],
+			"the address that matches whole stays above the domain tier below it",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [
+			bare.addressId,
+			domainOwner.addressId,
+		]);
+	});
+
 	test("listByAccountConfig keeps a leading display-name match above a domain that only contains the term", async () => {
 		const accountConfigId = randomId();
 		const shop = await repo.createAddress({

package/src/repos/i4-mailbox-special-use.sqlite.test.ts

@@ -1,7 +1,10 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { after, before, describe, test } from "node:test";
-import { composeFolderRoleAppointmentName } from "@remit/data-ports/folder-role";
+import {
+	composeFolderRoleAppointmentName,
+	meetsTrashAssurance,
+} from "@remit/data-ports/folder-role";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
 import {
 	accountSettingTable,
@@ -175,7 +178,9 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 			makeMailboxInput(accountId, "[Gmail]/Trash"),
 		);
 
-		assert.equal(await repo.findConfirmedTrashMailbox(accountId), null);
+		const proposal = await repo.resolveTrashRole(accountId);
+		assert.equal(proposal.kind, "proposed");
+		assert.equal(meetsTrashAssurance(proposal, "confirmed"), false);
 
 		await appoint(
 			accountConfigId,
@@ -183,9 +188,11 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 			CanonicalMailboxRole.Trash,
 			trash.mailboxId,
 		);
-		const confirmed = await repo.findConfirmedTrashMailbox(accountId);
-		assert.equal(confirmed?.mailboxId, trash.mailboxId);
-		assert.notEqual(confirmed?.mailboxId, keepsakes.mailboxId);
+		assert.deepEqual(await repo.resolveTrashRole(accountId), {
+			kind: "appointed",
+			mailbox: { mailboxId: trash.mailboxId, fullPath: "[Gmail]/Trash" },
+		});
+		assert.notEqual(trash.mailboxId, keepsakes.mailboxId);
 	});
 
 	test("keeps a stale Trash appointment visible instead of answering the fallback", async () => {
@@ -214,6 +221,17 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 				mailbox: { mailboxId: flagged.mailboxId, fullPath: "[Gmail]/Trash" },
 			},
 		});
+
+		// The flagged folder is where a delete files mail, and no evidence at all
+		// that the user meant it to be emptied.
+		assert.equal(
+			meetsTrashAssurance(await repo.resolveTrashRole(accountId), "confirmed"),
+			false,
+		);
+		assert.equal(
+			(await repo.findTrashMailbox(accountId))?.mailboxId,
+			flagged.mailboxId,
+		);
 	});
 
 	test("resolves an INBOX-nested Junk folder that advertises \\Junk", async () => {
@@ -259,7 +277,10 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 		// Resolving the name widens where a delete FILES mail, never what an
 		// Empty Trash may expunge (#846): that still needs the flag or an
 		// appointment.
-		assert.equal(await repo.findConfirmedTrashMailbox(accountId), null);
+		assert.equal(
+			meetsTrashAssurance(await repo.resolveTrashRole(accountId), "confirmed"),
+			false,
+		);
 	});
 
 	test("resolves an INBOX-nested Archive folder that advertises no special use", async () => {

package/src/repos/i4-mailbox-special-use.ts

@@ -8,7 +8,6 @@ import {
 	composeFolderRoleAppointmentName,
 	type RoleMailboxCandidate,
 	type RoleResolution,
-	resolveConfirmedMailboxForRole,
 	resolveMailboxForRole,
 	resolveRoleForAccount,
 	type UnappointedRoleResolution,
@@ -144,16 +143,6 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Trash);
 	}
 
-	findConfirmedTrashMailbox(
-		accountId: string,
-	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		return this.findMailboxForRole(
-			accountId,
-			CanonicalMailboxRole.Trash,
-			resolveConfirmedMailboxForRole,
-		);
-	}
-
 	/**
 	 * Trash with its evidence, for the verbs that weigh it. Reads exactly what
 	 * `findMailboxForRole` reads — a `null` answer is thrown away there, and this
@@ -194,13 +183,12 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 	private async findMailboxForRole(
 		accountId: string,
 		role: CanonicalMailboxRoleValue,
-		resolve: typeof resolveMailboxForRole = resolveMailboxForRole,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
 		const [candidates, appointedMailboxId] = await Promise.all([
 			this.roleCandidates(accountId),
 			this.appointedMailboxId(accountId, role),
 		]);
-		const found = resolve(role, candidates, appointedMailboxId);
+		const found = resolveMailboxForRole(role, candidates, appointedMailboxId);
 		return found
 			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
 			: null;