@remit/drizzle-service 0.0.60 → 0.0.62

package/package.json

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

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

@@ -1,3 +1,4 @@
+import { domainToASCII } from "node:url";
 import { eq, or, type SQL, sql } from "drizzle-orm";
 import { addressTable } from "../schema/i4-address.js";
 
@@ -33,12 +34,42 @@ const patterns = (term: string) => {
 	return { leading: `${escaped}%`, anywhere: `%${escaped}%` };
 };
 
+/**
+ * The envelope delivers internationalized domains in punycode, so every column
+ * holds `xn--bcher-kva.de` even though the reader types `bücher.de` (#905). A
+ * term that names a domain is converted the same way, label by label, and both
+ * spellings are searched. Only a whole label converts to what the row holds:
+ * `bücher` becomes `xn--bcher-kva`, but half of it, `büche`, becomes
+ * `xn--bche-0ra`, which prefixes nothing. Only a term carrying a `.` or an `@`
+ * is folded at all, so a name like `Özcan` does not pay for a second spelling
+ * in every predicate. The address is rebuilt around the converted domain, so
+ * the whole address the reader typed still meets the row it names.
+ *
+ * The other direction is out of scope: sync writes `addr.host` as the envelope
+ * spelled it, so an SMTPUTF8 delivery can store a domain in unicode that a
+ * punycode term then misses. #905 covers the punycode rows only.
+ */
+const punyVariants = (term: string): string[] => {
+	const folded = term.toLowerCase();
+	if (!/[.@]/.test(folded)) return [folded];
+	const at = folded.indexOf("@");
+	const local = at === -1 ? "" : folded.slice(0, at);
+	const domain = at === -1 ? folded : folded.slice(at + 1);
+	if (!/[^\p{ASCII}]/u.test(domain)) return [folded];
+	const ascii = domainToASCII(domain);
+	if (!ascii) return [folded];
+	return [folded, local ? `${local}@${ascii}` : ascii];
+};
+
 export const addressSearchMatch = (term: string): SQL => {
-	const { anywhere } = patterns(term);
+	const variants = punyVariants(term);
 	const matched = or(
-		...[...SEARCH_COLUMNS, FOLDED_FALLBACK].map((column) =>
-			like(column, anywhere),
-		),
+		...variants.flatMap((variant) => {
+			const { anywhere } = patterns(variant);
+			return [...SEARCH_COLUMNS, FOLDED_FALLBACK].map((column) =>
+				like(column, anywhere),
+			);
+		}),
 	);
 	if (matched === undefined) throw new Error("no address column to search");
 	return matched;
@@ -60,6 +91,15 @@ export const addressMatchRank = (term: string | undefined): SQL<number> => {
 	// Not the bare literal `0`: SQLite reads an integer literal in ORDER BY as a
 	// column index and rejects it as out of range.
 	if (!term) return sql<number>`cast(0 as integer)`;
+	// The best rank across every spelling of the term: whichever form the row
+	// was stored under decides where it sorts. With one argument `max()` is an
+	// aggregate, so it is only used when there is more than one spelling.
+	const ranks = punyVariants(term).map(rankOneTerm);
+	if (ranks.length === 1) return ranks[0];
+	return sql<number>`max(${sql.join(ranks, sql`, `)})`;
+};
+
+const rankOneTerm = (term: string): SQL<number> => {
 	const { leading, anywhere } = patterns(term);
 	const tiers = [
 		eq(addressTable.normalizedEmail, term.toLowerCase()),
@@ -97,7 +137,13 @@ export const addressListable = (term: string | undefined): SQL => {
 		or ${accountHasCorresponded()} > 0
 		or ${accountHasFlagged()} > 0`;
 	if (!term) return sql`(${shown})`;
-	return sql`(${shown} or ${addressTable.normalizedEmail} = ${term.toLowerCase()})`;
+	const exact = or(
+		...punyVariants(term).map(
+			(variant) =>
+				sql`${addressTable.normalizedEmail} = ${variant.toLowerCase()}`,
+		),
+	);
+	return sql`(${shown} or ${exact})`;
 };
 
 export const addressCorrespondence = (): SQL<number> =>

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

@@ -1320,4 +1320,105 @@ describe("AddressRepo", () => {
 			});
 		}
 	});
+
+	describe("unicode domains match punycode rows (#905)", () => {
+		test("bücher.de finds a row stored as xn--bcher-kva.de", async () => {
+			const accountConfigId = randomId();
+			const addr = await repo.createAddress({
+				addressId: randomId(),
+				accountConfigId,
+				localPart: "postmaster",
+				domain: "xn--bcher-kva.de",
+				normalizedEmail: "postmaster@xn--bcher-kva.de",
+				normalizedCompound: "postmaster@xn--bcher-kva.de:postmaster",
+				lastInboundAt: Date.now(),
+			});
+
+			try {
+				const { items } = await repo.listByAccountConfig({
+					accountConfigId,
+					search: "bücher.de",
+				});
+				assert.ok(items.some((item) => item.addressId === addr.addressId));
+			} finally {
+				await repo.deleteAddress(accountConfigId, addr.addressId);
+			}
+		});
+
+		test("a partial term still matches while its unicode label is whole", async () => {
+			const accountConfigId = randomId();
+			const addr = await repo.createAddress({
+				addressId: randomId(),
+				accountConfigId,
+				localPart: "postmaster",
+				domain: "xn--bcher-kva.de",
+				normalizedEmail: "postmaster@xn--bcher-kva.de",
+				normalizedCompound: "postmaster@xn--bcher-kva.de:postmaster",
+				lastInboundAt: Date.now(),
+			});
+
+			try {
+				const { items } = await repo.listByAccountConfig({
+					accountConfigId,
+					search: "bücher.d",
+				});
+				assert.ok(items.some((item) => item.addressId === addr.addressId));
+			} finally {
+				await repo.deleteAddress(accountConfigId, addr.addressId);
+			}
+		});
+
+		test("an address met only in Junk answers to the whole address typed", async () => {
+			const accountConfigId = randomId();
+			const withheld = await repo.upsertJunkAddress(
+				makeAddressInput(accountConfigId, "postmaster@xn--bcher-kva.de"),
+			);
+
+			const page = await repo.listByAccountConfig({
+				accountConfigId,
+				search: "postmaster@bücher.de",
+			});
+
+			assert.deepEqual(
+				page.items.map((a) => a.addressId),
+				[withheld.addressId],
+				"the address typed whole reaches the row its punycode spelling hides",
+			);
+
+			await repo.deleteAddress(accountConfigId, withheld.addressId);
+		});
+
+		test("the address a unicode term spells out leads a sibling at its domain", async () => {
+			const accountConfigId = randomId();
+			// The address typed, worn as a display name by the busiest row at the
+			// domain it names.
+			const sibling = await repo.createAddress({
+				...makeAddressInput(accountConfigId, "sales@xn--bcher-kva.de"),
+				displayName: "postmaster@bücher.de",
+				normalizedCompound: "postmaster@bücher.de sales@xn--bcher-kva.de",
+				inboundCount: 900,
+			});
+			const own = await repo.createAddress({
+				...makeAddressInput(accountConfigId, "postmaster@xn--bcher-kva.de"),
+				displayName: "Bücher",
+				normalizedCompound: "bücher postmaster@xn--bcher-kva.de",
+				inboundCount: 1,
+			});
+
+			const found = await repo.listByAccountConfig({
+				accountConfigId,
+				search: "postmaster@bücher.de",
+			});
+			assert.deepEqual(
+				found.items.map((a) => a.normalizedEmail),
+				[own.normalizedEmail, sibling.normalizedEmail],
+				"volume at the domain must not take the top slot from the address typed",
+			);
+
+			await repo.deleteManyAddresses(accountConfigId, [
+				sibling.addressId,
+				own.addressId,
+			]);
+		});
+	});
 });

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

@@ -135,6 +135,14 @@ describe("MailboxRepo", () => {
 		);
 	});
 
+	test("findByPathPrefix finds nothing in a flat namespace", async () => {
+		const accountId = randomId();
+		await repo.create(makeMailboxInput(accountId, "Work"));
+		await repo.create(makeMailboxInput(accountId, "Workshop"));
+
+		assert.deepEqual(await repo.findByPathPrefix(accountId, "Work", ""), []);
+	});
+
 	test("renameChildPaths updates all children", async () => {
 		const accountId = randomId();
 		await repo.create(makeMailboxInput(accountId, "OldName/Sub1"));

package/src/repos/i4-mailbox.ts

@@ -306,6 +306,9 @@ export class MailboxRepo implements IMailboxRepository {
 		pathPrefix: string,
 		delimiter = "/",
 	): Promise<MailboxItem[]> {
+		// A flat namespace nests nothing: with no delimiter the prefix is the
+		// folder’s own path, which would match every sibling starting with it.
+		if (delimiter.length === 0) return [];
 		const rows = await this.db
 			.select()
 			.from(mailboxTable)