@remit/backend 0.0.128 → 0.0.130

package/package.json

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

package/src/handlers/calendar-event.test.ts

@@ -36,6 +36,8 @@ const listEvents =
 	CalendarEventOperations.CalendarEventOperations_listCalendarEvents as Handler;
 const createEvent =
 	CalendarEventOperations.CalendarEventOperations_createCalendarEvent as Handler;
+const getEvent =
+	CalendarEventDetailOperations.CalendarEventDetailOperations_getCalendarEvent as Handler;
 const updateEvent =
 	CalendarEventDetailOperations.CalendarEventDetailOperations_updateCalendarEvent as Handler;
 const deleteEvent =
@@ -264,6 +266,118 @@ describe("GET /calendar-events", () => {
 	});
 });
 
+describe("GET /calendar-events?calendarObjectId", () => {
+	it("lists the occurrences of that one resource, across the caller's calendars", async () => {
+		const { event } = anAccount();
+		const defaultId = await defaultCalendarId(event);
+		const work = (await createCalendar(
+			contextOf({ requestBody: { urlSegment: "work", displayName: "Work" } }),
+			event,
+		)) as unknown as { calendarId: string };
+		const series = await seedEvent(event, {
+			calendarId: work.calendarId,
+			summary: "Stand-up",
+			start: "2026-09-07T09:00:00Z",
+			end: "2026-09-07T09:15:00Z",
+			recurrenceRule: "FREQ=WEEKLY;COUNT=3",
+		});
+		await seedEvent(event, {
+			calendarId: defaultId,
+			summary: "Dentist",
+			start: "2026-09-08T09:00:00Z",
+			end: "2026-09-08T10:00:00Z",
+		});
+
+		const listed = (await listEvents(
+			contextOf({
+				query: { ...WINDOW, calendarObjectId: series.calendarObjectId },
+			}),
+			event,
+		)) as unknown as { items: Instance[] };
+
+		assert.deepEqual(
+			listed.items.map((instance) => [
+				instance.calendarId,
+				instance.start.slice(0, 10),
+			]),
+			[
+				[work.calendarId, "2026-09-07"],
+				[work.calendarId, "2026-09-14"],
+				[work.calendarId, "2026-09-21"],
+			],
+		);
+	});
+
+	it("lists nothing for a resource on another account", async () => {
+		const stranger = anAccount();
+		const theirs = await seedEvent(stranger.event, {
+			calendarId: await defaultCalendarId(stranger.event),
+			summary: "Private",
+			start: "2026-09-07T09:00:00Z",
+			end: "2026-09-07T10:00:00Z",
+		});
+		const { event } = anAccount();
+
+		const listed = (await listEvents(
+			contextOf({
+				query: { ...WINDOW, calendarObjectId: theirs.calendarObjectId },
+			}),
+			event,
+		)) as unknown as { items: Instance[] };
+
+		assert.deepEqual(listed.items, []);
+	});
+});
+
+describe("GET /calendar-events/{calendarObjectId} without a calendar", () => {
+	it("finds the resource among the caller's calendars", async () => {
+		const { event } = anAccount();
+		await defaultCalendarId(event);
+		const work = (await createCalendar(
+			contextOf({ requestBody: { urlSegment: "work", displayName: "Work" } }),
+			event,
+		)) as unknown as { calendarId: string };
+		const seeded = await seedEvent(event, {
+			calendarId: work.calendarId,
+			summary: "Stand-up",
+			start: "2026-09-07T09:00:00Z",
+			end: "2026-09-07T09:15:00Z",
+		});
+
+		const found = (await getEvent(
+			contextOf({
+				params: { calendarObjectId: seeded.calendarObjectId },
+				query: {},
+			}),
+			event,
+		)) as unknown as { calendarId: string; dtStart: string };
+
+		assert.equal(found.calendarId, work.calendarId);
+		assert.match(found.dtStart, /^2026-09-07/);
+	});
+
+	it("answers not-found for a resource on another account", async () => {
+		const stranger = anAccount();
+		const theirs = await seedEvent(stranger.event, {
+			calendarId: await defaultCalendarId(stranger.event),
+			summary: "Private",
+			start: "2026-09-07T09:00:00Z",
+			end: "2026-09-07T10:00:00Z",
+		});
+		const { event } = anAccount();
+
+		const found = await getEvent(
+			contextOf({
+				params: { calendarObjectId: theirs.calendarObjectId },
+				query: {},
+			}),
+			event,
+		);
+
+		assert.equal(found.statusCode, 404);
+	});
+});
+
 describe("POST /calendar-events", () => {
 	it("refuses a recurrence rule it cannot read and writes nothing", async () => {
 		const { event } = anAccount();

package/src/handlers/calendar-event.ts

@@ -15,6 +15,7 @@ import {
 	deleteCalendarObject,
 	listBusySpans,
 	listCalendarInstances,
+	listObjectInstances,
 	OFFSET_BEARING,
 	parseCalendar,
 	projectCalendar,
@@ -490,6 +491,22 @@ export const deleteCalendarEventFor = async (
 	);
 };
 
+/** The collection holding a resource, found among the ones given. */
+const locateResource = async (
+	deps: CalendarDeps,
+	collections: CalendarCollectionItem[],
+	calendarObjectId: string,
+): Promise<ResolvedResource | undefined> => {
+	for (const collection of collections) {
+		const object = await deps.calendarObject.find(
+			collection.calendarId,
+			calendarObjectId,
+		);
+		if (object) return { collection, object };
+	}
+	return undefined;
+};
+
 const readCalendarIds = (value: unknown): string[] => {
 	if (typeof value === "string") return value === "" ? [] : [value];
 	if (Array.isArray(value)) return value.filter((id) => typeof id === "string");
@@ -545,6 +562,7 @@ export const CalendarEventOperations: Record<
 			from?: string;
 			to?: string;
 			calendarId?: string | string[];
+			calendarObjectId?: string;
 		};
 		const window = readWindow(query.from, query.to);
 		if (!window.ok) return badRequest(window.error);
@@ -557,6 +575,22 @@ export const CalendarEventOperations: Record<
 		);
 		if (!collections.ok) return answerRefusal(collections.error);
 
+		if (query.calendarObjectId) {
+			const located = await locateResource(
+				deps,
+				collections.value,
+				query.calendarObjectId,
+			);
+			if (!located) return { items: [] };
+			const own = await listObjectInstances(
+				deps,
+				located.collection,
+				located.object,
+				window.value,
+			);
+			return { items: own.map(toInstanceResponse) };
+		}
+
 		const instances = await listCalendarInstances(
 			deps,
 			collections.value,
@@ -594,6 +628,20 @@ export const CalendarEventDetailOperations: Record<
 		if (!request.ok) return badRequest(request.error);
 		const deps = calendarEventDepsOf(calendarDepsOf(await getClient()));
 
+		if (request.value.calendarId === "") {
+			const located = await locateResource(
+				deps,
+				await listCalendarsFor(deps, accountConfigId),
+				request.value.calendarObjectId,
+			);
+			if (!located) {
+				return notFound(
+					`no event ${request.value.calendarObjectId} on this account`,
+				);
+			}
+			return toEventResponse(located.object);
+		}
+
 		const resolved = await resolveResource(
 			deps,
 			accountConfigId,

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),
 	]);