@remit/backend 0.0.127 → 0.0.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.127",
+  "version": "0.0.129",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/handlers/mailbox.ts

@@ -327,6 +327,7 @@ const toMailboxResponse = (
 	// client cannot tell a create in flight from a rename in flight, name the
 	// target of a failed rename, or offer the right retry.
 	pendingPath: mailbox.pendingPath,
+	syncFailureReason: mailbox.syncFailureReason,
 	muted: overrides.muted,
 	displayNameOverride: overrides.displayNameOverride,
 	createdAt: mailbox.createdAt,

package/src/handlers/outbox.test.ts

@@ -168,11 +168,14 @@ const refusingSqsClient = (): { client: SQSClient; accept: () => void } => {
 	};
 };
 
+let accountSyncedServices: string[] = ["Mail"];
+
 const accountRepository = {
 	get: async () => ({
 		accountId: ACCOUNT_ID,
 		accountConfigId: ACCOUNT_CONFIG_ID,
 		email: ACCOUNT_EMAIL,
+		syncedServices: accountSyncedServices,
 	}),
 } as unknown as IAccountRepository;
 
@@ -327,6 +330,7 @@ const sentOutboxMessageId = async (): Promise<string> => {
 
 afterEach(() => {
 	_resetForTest();
+	accountSyncedServices = ["Mail"];
 });
 
 describe("an outbox entry that has left draft (#604)", () => {
@@ -674,3 +678,67 @@ describe("attachmentIds on a draft update (#679)", () => {
 		assert.equal(attachmentRows.size, 2);
 	});
 });
+
+describe("sending from an account with mail off (#1181)", () => {
+	const assertRefusal = (response: APIGatewayProxyResult): void => {
+		assert.equal(response.statusCode, 400);
+		const body = JSON.parse(response.body) as {
+			code?: string;
+			message?: string;
+			details?: Record<string, string>;
+		};
+		assert.equal(body.code, "mail_sync_off");
+		assert.match(String(body.message), /Turn Mail back on .* in Settings/);
+		assert.deepEqual(body.details, { accountId: ACCOUNT_ID });
+	};
+
+	it("answers a send of a saved draft with a 400 naming the fix", async () => {
+		installClient();
+		const draft = await createDraft(
+			requestContext({}),
+			authorizedEvent({
+				accountId: ACCOUNT_ID,
+				toAddresses: ["recipient@example.com"],
+				subject: "hello",
+			}),
+		);
+		accountSyncedServices = ["Calendar"];
+
+		const response = await respond(() =>
+			sendMessage(
+				requestContext({
+					params: { outboxMessageId: String(draft.outboxMessageId) },
+				}),
+				authorizedEvent(),
+			),
+		);
+
+		assertRefusal(response);
+		const kept = await getMessage(
+			requestContext({
+				params: { outboxMessageId: String(draft.outboxMessageId) },
+			}),
+			authorizedEvent(),
+		);
+		assert.equal(kept.status, "draft");
+	});
+
+	it("answers a send-immediately create with the same 400", async () => {
+		installClient();
+		accountSyncedServices = ["Calendar"];
+
+		const response = await respond(() =>
+			createDraft(
+				requestContext({}),
+				authorizedEvent({
+					accountId: ACCOUNT_ID,
+					toAddresses: ["recipient@example.com"],
+					subject: "hello",
+					sendImmediately: true,
+				}),
+			),
+		);
+
+		assertRefusal(response);
+	});
+});

package/src/handlers/unified-threads-mail-sources.sqlite.test.ts

@@ -0,0 +1,197 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { AccountItem } from "@remit/data-ports";
+import {
+	AccountAuthType,
+	AccountService,
+	ConnectionState,
+	MailboxCursorState,
+} from "@remit/domain-enums";
+import {
+	AccountRepo,
+	AccountSettingRepo,
+	AddressRepo,
+	DrizzleMessageRepository,
+	DrizzleThreadMessageRepository,
+	LabelRepo,
+	MailboxRepo,
+	MessageLabelRepo,
+} from "@remit/drizzle-service";
+import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import { deriveAccountConfigId } from "../auth.js";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "../service/data-client.js";
+import { ThreadOperations } from "./thread.js";
+import {
+	buildInboxMailboxMap,
+	executeUnifiedThreadListing,
+	type UnifiedThreadClient,
+} from "./unified-threads.js";
+
+const SUB = "cognito-sub-1181";
+const ACCOUNT_CONFIG_ID = deriveAccountConfigId(SUB);
+const NOW = 1_700_000_000_000;
+
+let client: UnifiedThreadClient & RemitClient;
+let close: () => void;
+
+beforeEach(() => {
+	const store = createShippedSqliteDb();
+	store.sqlite.exec(
+		readFileSync(
+			new URL(
+				"../../../../npm-scripts/sqlite-search-index.sql",
+				import.meta.url,
+			),
+			"utf8",
+		),
+	);
+	close = store.close;
+	const db = store.db as never;
+	client = {
+		account: new AccountRepo(store.db),
+		accountSetting: new AccountSettingRepo(store.db),
+		mailbox: new MailboxRepo(store.db),
+		address: new AddressRepo(store.db),
+		message: new DrizzleMessageRepository(db),
+		threadMessage: new DrizzleThreadMessageRepository(db),
+		label: new LabelRepo(store.db),
+		messageLabel: new MessageLabelRepo(store.db),
+	} as unknown as UnifiedThreadClient & RemitClient;
+	setClient(client);
+});
+
+afterEach(() => {
+	_resetForTest();
+	close();
+});
+
+const seedAccountWithInboxThread = async (
+	syncedServices: AccountItem["syncedServices"],
+): Promise<{ accountId: string; mailboxId: string; threadId: string }> => {
+	const label = syncedServices.join("-");
+	const account = await client.account.create({
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		username: `${label}@example.com`,
+		email: `${label}@example.com`,
+		authType: AccountAuthType.OauthMicrosoft,
+		syncedServices,
+		imapHost: "outlook.office365.com",
+		imapPort: 993,
+		imapTls: true,
+		imapStartTls: false,
+		isActive: true,
+		connectionState: ConnectionState.Authenticated,
+	});
+	const created = await client.mailbox.create({
+		accountId: account.accountId,
+		namespacePrefix: "",
+		hierarchyDelimiter: "/",
+		fullPath: "INBOX",
+		uidValidity: 1,
+		uidNext: 2,
+		highestModseq: "0",
+		messageCount: 1,
+		unseenCount: 1,
+		deletedCount: 0,
+		totalSize: 10,
+		lastSyncUid: 1,
+		highWaterMarkUid: 1,
+		lastMessageSyncAt: NOW,
+		cursorState: MailboxCursorState.normal,
+	} as Parameters<MailboxRepo["create"]>[0]);
+	if (created.outcome !== "Created") throw new Error("INBOX path taken");
+	const mailbox = created.mailbox;
+	const messageId = randomUUID();
+	await client.message.create({
+		messageId,
+		mailboxId: mailbox.mailboxId,
+		uid: 1,
+		sequenceNumber: 1,
+		rfc822Size: 10,
+		internalDate: NOW,
+		envelopeId: randomUUID(),
+		rootBodyPartId: randomUUID(),
+		status: "active",
+		syncStatus: "synced",
+	});
+	const threadId = randomUUID();
+	await client.threadMessage.create({
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		threadId,
+		messageId,
+		mailboxId: mailbox.mailboxId,
+		uid: 1,
+		referenceOrder: 0,
+		internalDate: NOW,
+		sentDate: NOW,
+		subject: `hello from ${label}`,
+		isRead: false,
+		isDeleted: false,
+		hasAttachment: false,
+		hasStars: false,
+	});
+	return {
+		accountId: account.accountId,
+		mailboxId: mailbox.mailboxId,
+		threadId,
+	};
+};
+
+const unifiedThreadIds = async (searchText?: string): Promise<string[]> => {
+	const response = await executeUnifiedThreadListing(
+		client,
+		ACCOUNT_CONFIG_ID,
+		{
+			starredOnly: false,
+			searchText,
+			count: false,
+			results: true,
+		},
+	);
+	return (response.items ?? []).map((item) => item.threadId).sort();
+};
+
+describe("a mail-off account in the unified surfaces (#1181)", () => {
+	it("leaves the unified list and search, and its mailbox still opens directly", async () => {
+		const mailOnly = await seedAccountWithInboxThread([AccountService.Mail]);
+		const both = await seedAccountWithInboxThread([
+			AccountService.Mail,
+			AccountService.Calendar,
+		]);
+		const calendarOnly = await seedAccountWithInboxThread([
+			AccountService.Calendar,
+		]);
+		const mailSources = [mailOnly.threadId, both.threadId].sort();
+
+		assert.deepEqual(await unifiedThreadIds(), mailSources);
+		assert.deepEqual(await unifiedThreadIds("hello"), mailSources);
+
+		const scope = await buildInboxMailboxMap(ACCOUNT_CONFIG_ID, client);
+		assert.equal(scope.starredMailboxIds.has(calendarOnly.mailboxId), false);
+
+		const listThreads = ThreadOperations.ThreadOperations_listThreads as (
+			context: Context,
+			event: APIGatewayProxyEvent,
+		) => Promise<unknown>;
+		const opened = (await listThreads(
+			{
+				request: { params: { mailboxId: calendarOnly.mailboxId }, query: {} },
+			} as unknown as Context,
+			{
+				requestContext: { authorizer: { claims: { sub: SUB } } },
+			} as unknown as APIGatewayProxyEvent,
+		)) as { items: { threadId: string }[] };
+		assert.deepEqual(
+			opened.items.map((item) => item.threadId),
+			[calendarOnly.threadId],
+		);
+	});
+});

package/src/handlers/unified-threads.test.ts

@@ -52,7 +52,7 @@ const buildClient = (
 	settings: AccountSettingItem[] = [],
 ): InboxMapClient =>
 	({
-		account: { listAllByAccountConfig: async () => accounts },
+		account: { listMailSourcesByAccountConfig: async () => accounts },
 		mailbox: {
 			listAllByAccount: async (accountId: string) =>
 				mailboxesByAccount[accountId] ?? [],
@@ -455,7 +455,10 @@ describe("executeUnifiedThreadListing", () => {
 	const buildListingClient = (calls: Call[], count = 0) =>
 		({
 			account: {
-				listAllByAccountConfig: async () => [account("a1"), account("a2")],
+				listMailSourcesByAccountConfig: async () => [
+					account("a1"),
+					account("a2"),
+				],
 			},
 			mailbox: {
 				listAllByAccount: async (accountId: string) =>

package/src/handlers/unified-threads.ts

@@ -37,7 +37,9 @@ const MAILBOX_LIST_CONCURRENCY = 5;
  */
 export interface InboxMapClient {
 	account: {
-		listAllByAccountConfig(accountConfigId: string): Promise<AccountItem[]>;
+		listMailSourcesByAccountConfig(
+			accountConfigId: string,
+		): Promise<AccountItem[]>;
 	};
 	mailbox: {
 		listAllByAccount(accountId: string): Promise<MailboxItem[]>;
@@ -125,7 +127,7 @@ const isExcludedFromSearch = (mailbox: MailboxItem): boolean =>
  * keyed by accountId/mailboxId; a target counts as muted only when its MutedFlag
  * exists AND `value === true`.
  *
- * NOTE (read cost / mute drift): this fan-out (one listAllByAccountConfig + N
+ * NOTE (read cost / mute drift): this fan-out (one listMailSourcesByAccountConfig + N
  * per-account mailbox listings) runs on *every* page request and is not cached
  * across a pagination session. Acceptable for v1 — mailbox lists are small —
  * but it means the inbox/mute filter set is rebuilt per page from live state,
@@ -146,7 +148,7 @@ export const buildInboxMailboxMap = async (
 	virtualCopyMailboxIds: Set<string>;
 }> => {
 	const [accounts, settings] = await Promise.all([
-		client.account.listAllByAccountConfig(accountConfigId),
+		client.account.listMailSourcesByAccountConfig(accountConfigId),
 		client.accountSetting.listByAccountConfig(accountConfigId),
 	]);