@remit/drizzle-service 0.0.44 → 0.0.45

package/package.json

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

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

@@ -8,10 +8,10 @@ import { addressTable } from "../schema/i4-address.js";
 const escapeLike = (term: string): string => term.replace(/[\\%_]/g, "\\$&");
 
 const SEARCH_COLUMNS = [
-	sql`lower(coalesce(${addressTable.displayName}, ''))`,
+	sql`${addressTable.normalizedEmail}`,
 	sql`${addressTable.localPart}`,
+	sql`lower(coalesce(${addressTable.displayName}, ''))`,
 	sql`${addressTable.domain}`,
-	sql`${addressTable.normalizedEmail}`,
 ] as const;
 
 /**
@@ -45,22 +45,27 @@ export const addressSearchMatch = (term: string): SQL => {
 };
 
 /**
- * Where the term hit, as one number: every match at the start of a column
- * outranks every match in the middle of one, and within each the display name
- * outranks the local part, the domain and the whole address. A mid-string match
- * still comes back — this only decides the order.
+ * Where the term hit, as one number, highest tier first. The address the term
+ * 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.
  */
 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)`;
 	const { leading, anywhere } = patterns(term);
-	const arms = [
+	const tiers = [
+		sql`${addressTable.normalizedEmail} = ${term.toLowerCase()}`,
 		...SEARCH_COLUMNS.map((column) => like(column, leading)),
 		...SEARCH_COLUMNS.map((column) => like(column, anywhere)),
-	].map(
-		(condition, index) =>
-			sql`when ${condition} then ${SEARCH_COLUMNS.length * 2 - index}`,
+	];
+	const arms = tiers.map(
+		(condition, index) => sql`when ${condition} then ${tiers.length - index}`,
 	);
 	return sql<number>`case ${sql.join(arms, sql` `)} else 0 end`;
 };

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

@@ -417,6 +417,156 @@ describe("AddressRepo", () => {
 		]);
 	});
 
+	test("listByAccountConfig never lets a display name outrank the address a term matches", async () => {
+		const accountConfigId = randomId();
+		// The 2021 spam row: its display name is the account's own address, its
+		// real address is somewhere else entirely.
+		const spoof = await repo.createAddress({
+			...makeAddressInput(
+				accountConfigId,
+				"aramirez@secresaludguaviare.gov.co",
+			),
+			displayName: "matthijs@ischen.nl",
+			normalizedCompound:
+				"matthijs@ischen.nl aramirez@secresaludguaviare.gov.co",
+			inboundCount: 500,
+		});
+		// The address typed, as a prefix of a domain somebody else registered,
+		// louder than the account's own correspondence with itself.
+		const lookalike = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "matthijs@ischen.nl.evil.example"),
+			displayName: "matthijs@ischen.nl",
+			normalizedCompound: "matthijs@ischen.nl matthijs@ischen.nl.evil.example",
+			inboundCount: 900,
+		});
+		const own = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "matthijs@ischen.nl"),
+			displayName: "Matthijs van Henten",
+			normalizedCompound: "matthijs van henten matthijs@ischen.nl",
+			inboundCount: 3,
+		});
+
+		const found = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "matthijs@ischen.nl",
+		});
+		assert.deepEqual(
+			found.items.map((a) => a.normalizedEmail),
+			[own.normalizedEmail, lookalike.normalizedEmail, spoof.normalizedEmail],
+			"the address typed must lead every address that only prefixes or claims it",
+		);
+
+		const onlySuggestion = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "matthijs@ischen.nl",
+			limit: 1,
+		});
+		assert.deepEqual(
+			onlySuggestion.items.map((a) => a.normalizedEmail),
+			[own.normalizedEmail],
+			"a single suggestion slot goes to the address that matches whole",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [
+			spoof.addressId,
+			lookalike.addressId,
+			own.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({
+			...makeAddressInput(accountConfigId, "hello@other.test"),
+			displayName: "Corner Shop",
+			normalizedCompound: "corner shop hello@other.test",
+		});
+		const leadingDomain = await repo.createAddress({
+			...makeAddressInput(
+				accountConfigId,
+				"sales@cornerstone-analytics.example",
+			),
+			displayName: "Sales Team",
+			normalizedCompound: "sales team sales@cornerstone-analytics.example",
+			inboundCount: 200,
+		});
+		const middleDomain = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "news@list-corner.example"),
+			displayName: "Loud List",
+			normalizedCompound: "loud list news@list-corner.example",
+			inboundCount: 500,
+		});
+
+		const found = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "corner",
+		});
+		assert.deepEqual(
+			found.items.map((a) => a.addressId),
+			[shop.addressId, leadingDomain.addressId, middleDomain.addressId],
+			"the name a reader types stays the first suggestion",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [
+			shop.addressId,
+			leadingDomain.addressId,
+			middleDomain.addressId,
+		]);
+	});
+
+	test("listByAccountConfig ranks an address match above a display-name match for the same term", async () => {
+		const accountConfigId = randomId();
+		const byAddress = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "corner@shop.test"),
+			displayName: "Zed Ziegler",
+			normalizedCompound: "zed ziegler corner@shop.test",
+		});
+		const byName = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "hello@other.test"),
+			displayName: "Corner Shop",
+			normalizedCompound: "corner shop hello@other.test",
+			inboundCount: 500,
+		});
+
+		const found = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "corner",
+		});
+		assert.deepEqual(
+			found.items.map((a) => a.addressId),
+			[byAddress.addressId, byName.addressId],
+			"the address decides ahead of free text the sender wrote",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [
+			byAddress.addressId,
+			byName.addressId,
+		]);
+	});
+
+	test("listByAccountConfig still resolves a display-name match no address matches", async () => {
+		const accountConfigId = randomId();
+		const created = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "w.baker@kliniek.nl"),
+			displayName: "Wendy Baker",
+			normalizedCompound: "wendy baker w.baker@kliniek.nl",
+		});
+
+		for (const term of ["wendy", "baker", "wendy baker"]) {
+			const found = await repo.listByAccountConfig({
+				accountConfigId,
+				search: term,
+			});
+			assert.deepEqual(
+				found.items.map((a) => a.addressId),
+				[created.addressId],
+				`"${term}" must resolve the address by its display name`,
+			);
+		}
+
+		await repo.deleteManyAddresses(accountConfigId, [created.addressId]);
+	});
+
 	test("cross-tenant: a search never reaches another account's addresses", async () => {
 		const mine = randomId();
 		const theirs = randomId();