@remit/drizzle-service 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Drizzle ORM service parameterized by dialect (Postgres / SQLite)",
   "type": "module",
   "main": "src/index.ts",
@@ -21,9 +21,7 @@
   },
   "devDependencies": {
     "@remit/api-zod-schemas": "*",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/pg": "^8.0.0",
-    "better-sqlite3": "^12.11.1",
     "drizzle-kit": "^0.31.1",
     "embedded-postgres": "^18.4.0-beta.17",
     "tsx": "*",
@@ -38,7 +36,9 @@
     "short-uuid": "*",
     "uuid": "*",
     "@remit/drizzle-pg-schema": "*",
-    "@remit/drizzle-sqlite-schema": "*"
+    "@remit/drizzle-sqlite-schema": "*",
+    "better-sqlite3": "^12.11.1",
+    "@types/better-sqlite3": "^7.6.13"
   },
   "license": "MIT",
   "publishConfig": {

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

@@ -195,4 +195,152 @@ describe("DrizzleThreadMessageRepository (sqlite)", () => {
 			"pages do not overlap",
 		);
 	});
+	// #44: Flagged was a client-side filter over the newest page of the primary
+	// inboxes, so a star outside that window was invisible. listByStarred is the
+	// byStarred access pattern that view now reads.
+	test("listByStarred returns starred rows from every mailbox", async () => {
+		const acct = "acct-starred";
+		const base = Date.now();
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				mailboxId: "mbx-inbox",
+				subject: "starred in inbox",
+				hasStars: true,
+				sentDate: base,
+				internalDate: base,
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				mailboxId: "mbx-archive",
+				subject: "starred in archive",
+				hasStars: true,
+				sentDate: base - 1,
+				internalDate: base - 1,
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				mailboxId: "mbx-inbox",
+				subject: "not starred",
+				hasStars: false,
+				sentDate: base - 2,
+				internalDate: base - 2,
+			}),
+		);
+
+		const result = await repo.listByStarred(acct, { order: "desc" });
+		assert.deepEqual(
+			result.items.map((i) => i.subject),
+			["starred in inbox", "starred in archive"],
+		);
+	});
+
+	// The star colour is presentation only and defaults to the `none` sentinel,
+	// so a row starred without an explicit colour must still be returned.
+	test("listByStarred returns a starred row whose colour is the none sentinel", async () => {
+		const acct = "acct-starred-none";
+		const created = await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				subject: "uncoloured star",
+				hasStars: true,
+			}),
+		);
+		assert.equal(created.star, "none");
+
+		const result = await repo.listByStarred(acct);
+		assert.deepEqual(
+			result.items.map((i) => i.subject),
+			["uncoloured star"],
+		);
+	});
+
+	test("listByStarred narrows to the supplied mailbox set", async () => {
+		const acct = "acct-starred-scope";
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				mailboxId: "mbx-kept",
+				subject: "kept",
+				hasStars: true,
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				mailboxId: "mbx-muted",
+				subject: "muted",
+				hasStars: true,
+			}),
+		);
+
+		const result = await repo.listByStarred(acct, {
+			mailboxIds: new Set(["mbx-kept"]),
+		});
+		assert.deepEqual(
+			result.items.map((i) => i.subject),
+			["kept"],
+		);
+	});
+
+	test("listByStarred excludes soft-deleted rows when asked", async () => {
+		const acct = "acct-starred-deleted";
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				subject: "live star",
+				hasStars: true,
+			}),
+		);
+		await repo.create(
+			makeInput({
+				accountConfigId: acct,
+				subject: "trashed star",
+				hasStars: true,
+				isDeleted: true,
+			}),
+		);
+
+		const result = await repo.listByStarred(acct, { excludeDeleted: true });
+		assert.deepEqual(
+			result.items.map((i) => i.subject),
+			["live star"],
+		);
+	});
+
+	test("listByStarred pages without overlap", async () => {
+		const acct = "acct-starred-page";
+		const base = Date.now();
+		for (let i = 0; i < 5; i++) {
+			await repo.create(
+				makeInput({
+					accountConfigId: acct,
+					subject: `star ${i}`,
+					hasStars: true,
+					sentDate: base - i,
+					internalDate: base - i,
+				}),
+			);
+		}
+
+		const first = await repo.listByStarred(acct, { limit: 2, order: "desc" });
+		assert.equal(first.items.length, 2);
+		assert.ok(first.continuationToken);
+
+		const second = await repo.listByStarred(acct, {
+			limit: 2,
+			order: "desc",
+			continuationToken: first.continuationToken,
+		});
+		assert.equal(second.items.length, 2);
+		const firstIds = new Set(first.items.map((i) => i.threadMessageId));
+		assert.ok(
+			second.items.every((i) => !firstIds.has(i.threadMessageId)),
+			"pages do not overlap",
+		);
+	});
 });

package/src/repos/thread-message.ts

@@ -43,6 +43,9 @@ export const deriveThreadMessageId = (
 
 export const THREAD_SEARCH_MAX_LIMIT = 500;
 
+/** Page size used when a list caller supplies no explicit limit. */
+const DEFAULT_LIST_LIMIT = 100;
+
 export const clampThreadSearchLimit = (limit?: number): number => {
 	if (limit === undefined || !Number.isFinite(limit)) {
 		return THREAD_SEARCH_MAX_LIMIT;
@@ -493,6 +496,61 @@ export class DrizzleThreadMessageRepository
 		};
 	}
 
+	async listByStarred(
+		accountConfigId: string,
+		options?: {
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			mailboxIds?: Set<string>;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>> {
+		const order = options?.order ?? "desc";
+		// Default before the has-more check, or an absent limit silently truncates
+		// at the implicit cap with no continuation token.
+		const limit = options?.limit ?? DEFAULT_LIST_LIMIT;
+		const cursor = options?.continuationToken
+			? decodeDateCursor(options.continuationToken)
+			: null;
+
+		const mailboxCond = options?.mailboxIds?.size
+			? inArray(threadMessageTable.mailboxId, [...options.mailboxIds])
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(threadMessageTable)
+			.where(
+				and(
+					eq(threadMessageTable.accountConfigId, accountConfigId),
+					eq(threadMessageTable.hasStars, true),
+					mailboxCond,
+					options?.excludeDeleted
+						? eq(threadMessageTable.isDeleted, false)
+						: undefined,
+					sentDateCursorCond(order, cursor),
+				),
+			)
+			.orderBy(
+				order === "desc"
+					? desc(threadMessageTable.sentDate)
+					: asc(threadMessageTable.sentDate),
+				asc(threadMessageTable.threadMessageId),
+			)
+			.limit(limit);
+
+		const lastRow = rows[rows.length - 1];
+		const hasMore = rows.length === limit;
+		return {
+			items: rows.map(toItem),
+			continuationToken:
+				hasMore && lastRow
+					? encodeDateCursor(lastRow.sentDate, lastRow.threadMessageId)
+					: undefined,
+		};
+	}
+
 	async listByThread(
 		threadId: string,
 		accountConfigId: string,