@remit/drizzle-service 0.0.71 → 0.0.73

package/package.json

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

package/src/repos/i4-address.ts

@@ -18,6 +18,7 @@ import {
 	desc,
 	eq,
 	getTableColumns,
+	gt,
 	inArray,
 	type SQL,
 	sql,
@@ -748,6 +749,40 @@ export class AddressRepo implements IAddressRepository {
 		);
 	}
 
+	async listAllByAccountConfigPage(input: {
+		accountConfigId: string;
+		cursor?: string;
+		limit?: number;
+	}): Promise<ResultList<AddressItem>> {
+		const { accountConfigId, cursor, limit = 100 } = input;
+		const afterAddressId = cursor
+			? (decodeToken(cursor).addressId as string)
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(addressTable)
+			.where(
+				and(
+					eq(addressTable.accountConfigId, accountConfigId),
+					afterAddressId
+						? gt(addressTable.addressId, afterAddressId)
+						: undefined,
+				),
+			)
+			.orderBy(asc(addressTable.addressId))
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToAddress);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem ? { addressId: lastItem.addressId } : undefined,
+		);
+	}
+
 	async createEnvelopeAddress(
 		input: CreateEnvelopeAddressInput,
 	): Promise<EnvelopeAddressItem> {

package/src/repos/i4-outbox-message.test.ts

@@ -224,6 +224,59 @@ describe("OutboxMessageRepo", () => {
 		await repo.deleteMany(accountConfigId, created);
 	});
 
+	test("listByAccounts pages one ordering over every account (#1013)", async () => {
+		const accountConfigId = randomId();
+		const first = randomId();
+		const second = randomId();
+		const created: string[] = [];
+		const byAccount = new Map<string, string[]>([
+			[first, []],
+			[second, []],
+		]);
+		for (let i = 0; i < 6; i++) {
+			const accountId = i % 2 === 0 ? first : second;
+			const msg = await repo.create(
+				makeOutboxInput(accountId, accountConfigId),
+			);
+			created.push(msg.outboxMessageId);
+			byAccount.get(accountId)?.push(msg.outboxMessageId);
+		}
+
+		const wholeList = await repo.listByAccounts([first, second]);
+		const wholeIds = wholeList.items.map((m) => m.outboxMessageId);
+		for (const ids of byAccount.values()) {
+			for (const id of ids) {
+				assert.ok(wholeIds.includes(id), "every account's rows come back");
+			}
+		}
+
+		const seen: string[] = [];
+		let continuationToken: string | undefined;
+		let pages = 0;
+		do {
+			const page = await repo.listByAccounts([first, second], {
+				limit: 2,
+				continuationToken,
+			});
+			seen.push(...page.items.map((m) => m.outboxMessageId));
+			continuationToken = page.continuationToken;
+			pages++;
+			assert.ok(pages < 10, "pagination must terminate");
+		} while (continuationToken);
+
+		assert.equal(seen.length, 6, "every row returned exactly once");
+		assert.equal(new Set(seen).size, 6, "no duplicates across pages");
+		assert.deepEqual([...seen].sort(), [...created].sort(), "no gaps");
+
+		await repo.deleteMany(accountConfigId, created);
+	});
+
+	test("listByAccounts answers no accounts with no rows", async () => {
+		const list = await repo.listByAccounts([]);
+		assert.deepEqual(list.items, []);
+		assert.equal(list.continuationToken, undefined);
+	});
+
 	test("listQueued returns only queued messages", async () => {
 		const accountId = randomId();
 		const accountConfigId = randomId();

package/src/repos/i4-outbox-message.ts

@@ -272,8 +272,17 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 	async listByAccount(
 		accountId: string,
 		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<OutboxMessageItem>> {
+		return this.listByAccounts([accountId], options);
+	}
+
+	async listByAccounts(
+		accountIds: string[],
+		options?: { limit?: number; continuationToken?: string },
 	): Promise<ResultList<OutboxMessageItem>> {
 		const limit = options?.limit ?? 100;
+		if (accountIds.length === 0) return resultList([], limit);
+
 		const cursor = options?.continuationToken
 			? decodeToken(options.continuationToken)
 			: undefined;
@@ -289,7 +298,7 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 			.from(outboxMessageTable)
 			.where(
 				and(
-					eq(outboxMessageTable.accountId, accountId),
+					inArray(outboxMessageTable.accountId, accountIds),
 					after
 						? or(
 								lt(outboxMessageTable.createdAt, after.createdAt),

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

@@ -148,6 +148,27 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 		assert.equal(result.item.messageId, MESSAGE_ID);
 	});
 
+	// The state every inbound sync row is born in, and the one the re-point gate
+	// in mailbox-service has to accept (#1096): the sync path supplies no
+	// syncStatus and nothing later promotes what the repository writes here.
+	test("upsertWithStatus writes pending when the caller names no syncStatus", async () => {
+		const inboundId = "00000000-0000-0000-2222-000000000009";
+		const { item, created } = await repo.upsertWithStatus({
+			messageId: inboundId,
+			mailboxId: MAILBOX_ID,
+			uid: 43,
+			sequenceNumber: 2,
+			rfc822Size: 1024,
+			internalDate: NOW,
+			envelopeId: deriveEnvelopeId(inboundId),
+			rootBodyPartId: deriveRootBodyPartId(inboundId),
+		});
+
+		assert.equal(created, true);
+		assert.equal(item.syncStatus, "pending");
+		assert.equal(item.status, "active");
+	});
+
 	test("delete removes the message and appends a removal outbox row", async () => {
 		await repo.delete(MESSAGE_ID);
 		await assert.rejects(() => repo.get(MESSAGE_ID));