@remit/drizzle-service 0.0.10 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Drizzle ORM service parameterized by dialect (Postgres / SQLite)",
   "type": "module",
   "main": "src/index.ts",

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

@@ -209,6 +209,57 @@ describe("AddressRepo", () => {
 		await repo.deleteManyAddresses(accountConfigId, created);
 	});
 
+	test("listByAccountConfig resolves a search by exact email even when the sender has a display name", async () => {
+		const accountConfigId = randomId();
+		const created = await repo.createAddress({
+			...makeAddressInput(accountConfigId, "support@npmjs.com"),
+			displayName: "npm support",
+			// How message-sync writes it: display name first, then the email.
+			normalizedCompound: "npm support support@npmjs.com",
+		});
+
+		const byEmail = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "support@npmjs.com",
+		});
+		assert.deepEqual(
+			byEmail.items.map((a) => a.addressId),
+			[created.addressId],
+			"an exact-address lookup must resolve the row",
+		);
+
+		const byDisplayName = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "npm",
+		});
+		assert.deepEqual(
+			byDisplayName.items.map((a) => a.addressId),
+			[created.addressId],
+			"display-name search keeps working",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [created.addressId]);
+	});
+
+	test("listByAccountConfig treats LIKE metacharacters in a search term literally", async () => {
+		const accountConfigId = randomId();
+		const plain = await repo.createAddress(
+			makeAddressInput(accountConfigId, "ab@x.com"),
+		);
+
+		const result = await repo.listByAccountConfig({
+			accountConfigId,
+			search: "a_@x.com",
+		});
+		assert.equal(
+			result.items.length,
+			0,
+			"`_` must not act as a single-character wildcard",
+		);
+
+		await repo.deleteManyAddresses(accountConfigId, [plain.addressId]);
+	});
+
 	test("cross-tenant: getAddress refuses a foreign accountConfig", async () => {
 		const addr = await repo.createAddress(makeAddressInput(randomId()));
 		const other = randomId();

package/src/repos/i4-address.ts

@@ -20,6 +20,31 @@ import { shouldPromoteWellknown } from "./i4-address-wellknown.js";
 
 type DB = Db<Record<string, unknown>>;
 
+/**
+ * Escape the LIKE metacharacters so a term containing `%` or `_` (both legal in
+ * an email local part) matches literally instead of as a wildcard.
+ */
+const escapeLikeTerm = (term: string): string =>
+	term.replace(/[\\%_]/g, (char) => `\\${char}`);
+
+/**
+ * Match an address search term as a prefix of either the display-name compound
+ * or the normalized email.
+ *
+ * `normalizedCompound` is stored as `"<display name> <email>"`, so a prefix
+ * match on it only ever answers display-name queries — an exact-address lookup
+ * such as `support@npmjs.com` can never match a row whose sender has a display
+ * name. Matching `normalizedEmail` in the same predicate is what makes address
+ * resolution by email work at all (issue #51).
+ */
+const addressSearchPredicate = (term: string) => {
+	const pattern = `${escapeLikeTerm(term)}%`;
+	return or(
+		sql`${addressTable.normalizedCompound} LIKE ${pattern} ESCAPE '\\'`,
+		sql`${addressTable.normalizedEmail} LIKE ${pattern} ESCAPE '\\'`,
+	);
+};
+
 export function rowToAddress(
 	row: typeof addressTable.$inferSelect,
 ): AddressItem {
@@ -454,11 +479,11 @@ export class AddressRepo implements IAddressRepository {
 
 	async listByAccountConfig(input: {
 		accountConfigId: string;
-		normalizedCompound?: string;
+		search?: string;
 		cursor?: string;
 		limit?: number;
 	}): Promise<ResultList<AddressItem>> {
-		const { accountConfigId, normalizedCompound, cursor, limit = 100 } = input;
+		const { accountConfigId, search, cursor, limit = 100 } = input;
 		const decoded = cursor ? decodeToken(cursor) : undefined;
 		const after = decoded
 			? {
@@ -473,9 +498,7 @@ export class AddressRepo implements IAddressRepository {
 			.where(
 				and(
 					eq(addressTable.accountConfigId, accountConfigId),
-					normalizedCompound
-						? sql`${addressTable.normalizedCompound} LIKE ${`${normalizedCompound}%`}`
-						: undefined,
+					search ? addressSearchPredicate(search) : undefined,
 					after
 						? or(
 								gt(addressTable.normalizedCompound, after.normalizedCompound),

package/src/repos/thread-message.sqlite.test.ts

@@ -212,6 +212,76 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 		);
 	});
 
+	test("listByThread defaults to oldest first, by the date the mail was sent", async () => {
+		const acct = "acct-conversation-dates";
+		const threadId = "t-conversation-dates";
+		const base = Date.now();
+		// The folder a message was delivered to decides its internalDate, so a
+		// reply synced from Sent can carry an earlier internalDate than the
+		// message it answers. sentDate is what the conversation is ordered by.
+		const turns = [
+			{ messageId: "m-question", sentDate: base, internalDate: base + 5000 },
+			{ messageId: "m-answer", sentDate: base + 1000, internalDate: base },
+		];
+		for (const turn of turns) {
+			await repo.create(
+				makeInput({
+					accountConfigId: acct,
+					threadId,
+					messageId: turn.messageId,
+					sentDate: turn.sentDate,
+					internalDate: turn.internalDate,
+				}),
+			);
+		}
+
+		const result = await repo.listByThread(threadId, acct, {
+			excludeDeleted: true,
+		});
+		assert.deepEqual(
+			result.items.map((item) => item.messageId),
+			["m-question", "m-answer"],
+			"the reply follows the message it answers",
+		);
+	});
+
+	test("listByThread paginates in sentDate order without skipping or repeating", async () => {
+		const acct = "acct-conversation-pages";
+		const threadId = "t-conversation-pages";
+		const base = Date.now();
+		for (let index = 0; index < 5; index++) {
+			await repo.create(
+				makeInput({
+					accountConfigId: acct,
+					threadId,
+					messageId: `m-page-${index}`,
+					sentDate: base + index * 1000,
+					internalDate: base,
+				}),
+			);
+		}
+
+		const seen: string[] = [];
+		let continuationToken: string | undefined;
+		do {
+			const page = await repo.listByThread(threadId, acct, {
+				limit: 2,
+				continuationToken,
+				excludeDeleted: true,
+			});
+			seen.push(...page.items.map((item) => item.messageId));
+			continuationToken = page.continuationToken;
+		} while (continuationToken);
+
+		assert.deepEqual(seen, [
+			"m-page-0",
+			"m-page-1",
+			"m-page-2",
+			"m-page-3",
+			"m-page-4",
+		]);
+	});
+
 	test("listByThread excludes soft-deleted messages but keeps the rest of the conversation", async () => {
 		const acct = "acct-conversation-deleted";
 		const threadId = "t-conversation-deleted";

package/src/repos/thread-message.ts

@@ -56,7 +56,6 @@ export const clampThreadSearchLimit = (limit?: number): number => {
 // ─── Cursor ──────────────────────────────────────────────────────────────────
 
 type DateCursor = { s: number; id: string };
-type ThreadCursor = { d: number; id: string };
 type AccountCursor = { id: string };
 
 function encodeDateCursor(sentDate: number, threadMessageId: string): string {
@@ -73,23 +72,6 @@ function decodeDateCursor(token: string): DateCursor | null {
 	}
 }
 
-function encodeThreadCursor(
-	internalDate: number,
-	threadMessageId: string,
-): string {
-	return Buffer.from(
-		JSON.stringify({ d: internalDate, id: threadMessageId }),
-	).toString("base64");
-}
-
-function decodeThreadCursor(token: string): ThreadCursor | null {
-	try {
-		return JSON.parse(Buffer.from(token, "base64").toString()) as ThreadCursor;
-	} catch {
-		return null;
-	}
-}
-
 function encodeAccountCursor(threadMessageId: string): string {
 	return Buffer.from(JSON.stringify({ id: threadMessageId })).toString(
 		"base64",
@@ -563,22 +545,22 @@ export class DrizzleThreadMessageRepository
 	): Promise<ResultList<ThreadMessageItem>> {
 		const order = options?.order ?? "asc";
 		const cursor = options?.continuationToken
-			? decodeThreadCursor(options.continuationToken)
+			? decodeDateCursor(options.continuationToken)
 			: null;
 
 		const cursorCond = cursor
 			? order === "asc"
 				? or(
-						gt(threadMessageTable.internalDate, cursor.d),
+						gt(threadMessageTable.sentDate, cursor.s),
 						and(
-							eq(threadMessageTable.internalDate, cursor.d),
+							eq(threadMessageTable.sentDate, cursor.s),
 							gt(threadMessageTable.threadMessageId, cursor.id),
 						),
 					)
 				: or(
-						lt(threadMessageTable.internalDate, cursor.d),
+						lt(threadMessageTable.sentDate, cursor.s),
 						and(
-							eq(threadMessageTable.internalDate, cursor.d),
+							eq(threadMessageTable.sentDate, cursor.s),
 							gt(threadMessageTable.threadMessageId, cursor.id),
 						),
 					)
@@ -599,8 +581,8 @@ export class DrizzleThreadMessageRepository
 			)
 			.orderBy(
 				order === "asc"
-					? asc(threadMessageTable.internalDate)
-					: desc(threadMessageTable.internalDate),
+					? asc(threadMessageTable.sentDate)
+					: desc(threadMessageTable.sentDate),
 				asc(threadMessageTable.threadMessageId),
 			)
 			.limit(options?.limit ?? 100);
@@ -612,7 +594,7 @@ export class DrizzleThreadMessageRepository
 			items: rows.map(toItem),
 			continuationToken:
 				hasMore && lastRow
-					? encodeThreadCursor(lastRow.internalDate, lastRow.threadMessageId)
+					? encodeDateCursor(lastRow.sentDate, lastRow.threadMessageId)
 					: undefined,
 		};
 	}