@remit/backend 0.0.142 → 0.0.144

package/src/handlers/thread.ts

@@ -1,427 +0,0 @@
-import type {
-	MessageCategory,
-	SenderTrust,
-	ThreadSearchResponse,
-} from "@remit/api-openapi-types";
-import type { ResultList, ThreadMessageItem } from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
-import { isValidMessageId } from "@remit/data-ports/id";
-import type { APIGatewayProxyEvent } from "aws-lambda";
-import type { Context } from "openapi-backend";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import {
-	type EnrichClient,
-	enrichThreadRows,
-} from "../derive/enrichThreadRows.js";
-import {
-	filterByOffRowCriteria,
-	hasOffRowCriteria,
-} from "../derive/filterThreadCriteria.js";
-import { getClient } from "../service/data-client.js";
-import type {
-	OperationHandler,
-	ThreadDetailOperationIds,
-	ThreadOperationIds,
-} from "../types.js";
-
-const DEFAULT_THREADS_PAGE_SIZE = 50;
-
-// Project to fields used by ListThreadsResponse — keep in sync with handler mapping.
-// Includes ThreadMessage table key fields (accountConfigId, threadMessageId) and
-// the lsi2 index components (mailboxId, sentDate) so ElectroDB can materialize
-// entities and pagination cursors from projected reads. accountConfigId +
-// fromEmail are required at read time to derive the From Address row for
-// senderTrust enrichment (see enrichThreadRows).
-const THREAD_LIST_ATTRIBUTES: ReadonlyArray<keyof ThreadMessageItem> = [
-	"threadMessageId",
-	"threadId",
-	"messageId",
-	"accountConfigId",
-	"mailboxId",
-	"fromEmail",
-	"fromName",
-	"subject",
-	"sentDate",
-	"isRead",
-	"hasAttachment",
-	"star",
-	"hasStars",
-	"isDeleted",
-	"snippet",
-	"category",
-	"createdAt",
-	"updatedAt",
-];
-
-/**
- * Build the `listByMailbox` options for the thread list handler.
- *
- * Exposed as a pure helper so the `excludeDeleted: true` default — which is
- * the entire point of the #212 fix on the handler side — is testable without
- * standing up DynamoDB. The defaults must stay opt-out from the user (a
- * future Trash / All-Mail view can flip the flag) and opt-in at the
- * service layer.
- */
-export const buildListThreadsOptions = (query: {
-	continuationToken?: string;
-	order?: "asc" | "desc";
-}) => ({
-	order: query.order ?? ("desc" as const),
-	continuationToken: query.continuationToken,
-	limit: DEFAULT_THREADS_PAGE_SIZE,
-	attributes: [...THREAD_LIST_ATTRIBUTES],
-	excludeDeleted: true,
-});
-
-/**
- * Build the `searchByMailboxWindow` options for the thread search handler.
- * Same #212 `excludeDeleted` default as `buildListThreadsOptions`. The caller's
- * `limit` is forwarded raw and clamped server-side (THREAD_SEARCH_MAX_LIMIT).
- */
-export const buildSearchThreadsOptions = (query: {
-	continuationToken?: string;
-	order?: "asc" | "desc";
-	limit?: number;
-}) => ({
-	order: query.order ?? ("desc" as const),
-	continuationToken: query.continuationToken,
-	limit: query.limit,
-	attributes: [...THREAD_LIST_ATTRIBUTES],
-	excludeDeleted: true,
-});
-
-const toArray = <T>(value: T | T[] | undefined): T[] | undefined => {
-	if (value === undefined) return undefined;
-	return Array.isArray(value) ? value : [value];
-};
-
-type WindowOptions = {
-	order?: "asc" | "desc";
-	limit?: number;
-	continuationToken?: string;
-	attributes?: Array<keyof ThreadMessageItem>;
-	excludeDeleted?: boolean;
-};
-
-type ThreadSearch = {
-	query?: string;
-	subject?: string;
-	from?: string;
-	unread?: boolean;
-	starred?: boolean;
-	attachments?: boolean;
-	category?: MessageCategory[];
-};
-
-/**
- * Minimal client surface `executeThreadSearch` needs. Declared structurally
- * (like `EnrichClient`) so the orchestration — index/window read, count, and
- * the off-row enrich/filter — is testable with an in-memory fake.
- */
-export interface ThreadSearchClient extends EnrichClient {
-	threadMessage: {
-		searchByMailboxWindow(
-			accountConfigId: string,
-			mailboxId: string,
-			search: ThreadSearch,
-			options?: WindowOptions,
-		): Promise<ResultList<ThreadMessageItem>>;
-		countByMailbox(
-			accountConfigId: string,
-			mailboxId: string,
-			search: ThreadSearch,
-			options?: {
-				excludeDeleted?: boolean;
-				order?: "asc" | "desc";
-			},
-		): Promise<number>;
-	};
-}
-
-export type ThreadSearchParams = {
-	continuationToken?: string;
-	order?: "asc" | "desc";
-	query?: string;
-	subject?: string;
-	from?: string;
-	unread?: boolean;
-	starred?: boolean;
-	attachments?: boolean;
-	senderTrust?: SenderTrust[];
-	category?: MessageCategory[];
-	dkimMismatch?: boolean;
-	count?: boolean;
-	results?: boolean;
-	limit?: number;
-};
-
-/**
- * Run a per-mailbox thread search: select the index/window read, optionally
- * count, and resolve off-row criteria by enriching+filtering the window. The
- * `results` toggle omits `items` (count-only) and `count` adds the match count.
- *
- * `count` names the whole match, never the page: a page size bounds the rows a
- * response carries and has no bearing on how many messages match (#509).
- *
- * An off-row criterion is the one shape that has no such number. `senderTrust`
- * and `dkimMismatch` are resolved by enriching a window, so counting them means
- * enriching every candidate row in the mailbox. `count` is therefore absent
- * (#305) — a page's post-filter length labelled `count` is a page length
- * presented as a total, which is the defect the field exists to avoid. Absence
- * is the same answer the response already gives for a count nobody asked for,
- * so no caller needs a second shape to read it. A count-only request under an
- * off-row criterion therefore reads nothing at all.
- */
-export const executeThreadSearch = async (
-	client: ThreadSearchClient,
-	accountConfigId: string,
-	mailboxId: string,
-	params: ThreadSearchParams,
-): Promise<ThreadSearchResponse> => {
-	const search = {
-		query: params.query,
-		subject: params.subject,
-		from: params.from,
-		unread: params.unread,
-		starred: params.starred,
-		attachments: params.attachments,
-		category: params.category,
-	};
-	const offRow = {
-		senderTrust: params.senderTrust,
-		dkimMismatch: params.dkimMismatch,
-	};
-	const wantCount = params.count === true;
-	const wantResults = params.results !== false;
-	const options = buildSearchThreadsOptions({
-		continuationToken: params.continuationToken,
-		order: params.order,
-		limit: params.limit,
-	});
-
-	if (hasOffRowCriteria(offRow)) {
-		if (!wantResults) return {};
-		const window = await client.threadMessage.searchByMailboxWindow(
-			accountConfigId,
-			mailboxId,
-			search,
-			options,
-		);
-		const enriched = await enrichThreadRows(
-			window.items,
-			client,
-			accountConfigId,
-		);
-		return {
-			items: filterByOffRowCriteria(enriched, offRow),
-			continuationToken: window.continuationToken,
-		};
-	}
-
-	const response: ThreadSearchResponse = {};
-
-	if (wantResults) {
-		const window = await client.threadMessage.searchByMailboxWindow(
-			accountConfigId,
-			mailboxId,
-			search,
-			options,
-		);
-		response.items = await enrichThreadRows(
-			window.items,
-			client,
-			accountConfigId,
-		);
-		response.continuationToken = window.continuationToken;
-	}
-
-	if (wantCount) {
-		response.count = await client.threadMessage.countByMailbox(
-			accountConfigId,
-			mailboxId,
-			search,
-			{ excludeDeleted: true, order: params.order },
-		);
-	}
-
-	return response;
-};
-
-/**
- * Build the `listByThread` options for the thread-messages handler. Same
- * #212 default as the listing handlers — a soft-deleted message inside a
- * conversation should not surface in the conversation pane either.
- *
- * A conversation is never scoped to one mailbox: the user's own replies live
- * in Sent, filed messages live in their folder, and all of them belong to the
- * same thread (#46).
- *
- * The default order is `asc`: a conversation is read in the order it happened,
- * so a reply follows the message it answers (#81). The ordering is the query's,
- * not the handler's — `listByThread` sorts on sentDate with `threadMessageId`
- * breaking ties, so it holds across pages rather than within one response.
- */
-export const buildListThreadMessagesOptions = (query: {
-	order?: "asc" | "desc";
-}) => ({
-	order: query.order ?? ("asc" as const),
-	excludeDeleted: true,
-});
-
-/**
- * Collapse rows that are the same piece of mail to one entry.
- *
- * A ThreadMessage row is keyed by (threadId, messageId), and a messageId is
- * derived from the account plus the RFC 5322 Message-ID, so the same mail
- * synced from two folders is one row — the mailbox a thread spans is not what
- * duplicates it. `MessageMoveService.copyMessage` is the exception: a copy is a
- * per-folder placement with its own derived id (`deriveCopyMessageId`), so a
- * copied message is a second row in the same thread carrying the same
- * `messageIdHeader`. Reading the whole thread rather than one mailbox of it
- * (#46) is what makes both rows visible at once, and two entries for one message
- * is never what a conversation should show.
- *
- * The oldest row wins, so the original outlives the copy, with `threadMessageId`
- * breaking ties. Both are independent of sort order, so `asc` and `desc` keep
- * the same message rather than each keeping a different copy of it.
- *
- * A row without a usable `messageIdHeader` is never merged: the fallback
- * identity for headerless mail is per-row by construction, so two such rows are
- * two distinct messages.
- */
-export const dedupeThreadMessages = <
-	T extends Pick<
-		ThreadMessageItem,
-		"threadMessageId" | "messageIdHeader" | "createdAt"
-	>,
->(
-	rows: T[],
-): T[] => {
-	const winners = new Map<string, T>();
-
-	for (const row of rows) {
-		if (!isValidMessageId(row.messageIdHeader)) continue;
-		const header = (row.messageIdHeader as string).trim();
-		const held = winners.get(header);
-		if (
-			!held ||
-			row.createdAt < held.createdAt ||
-			(row.createdAt === held.createdAt &&
-				row.threadMessageId < held.threadMessageId)
-		) {
-			winners.set(header, row);
-		}
-	}
-
-	return rows.filter((row) => {
-		if (!isValidMessageId(row.messageIdHeader)) return true;
-		return winners.get((row.messageIdHeader as string).trim()) === row;
-	});
-};
-
-export const ThreadOperations: Record<
-	ThreadOperationIds,
-	OperationHandler<ThreadOperationIds>
-> = {
-	ThreadOperations_listThreads: async (
-		context: Context,
-		...args: unknown[]
-	) => {
-		const event = args[0] as APIGatewayProxyEvent;
-		const accountConfigId = getAccountConfigIdFromEvent(event);
-		const { mailboxId } = context.request.params as { mailboxId: string };
-		const { continuationToken, order } = context.request.query as {
-			continuationToken?: string;
-			order?: "asc" | "desc";
-		};
-
-		const client = await getClient();
-		const result = await client.threadMessage.listByMailbox(
-			accountConfigId,
-			mailboxId,
-			buildListThreadsOptions({ continuationToken, order }),
-		);
-
-		const items = await enrichThreadRows(result.items, client, accountConfigId);
-
-		return {
-			items,
-			continuationToken: result.continuationToken,
-		};
-	},
-
-	ThreadOperations_searchThreads: async (
-		context: Context,
-		...args: unknown[]
-	) => {
-		const event = args[0] as APIGatewayProxyEvent;
-		const accountConfigId = getAccountConfigIdFromEvent(event);
-		const { mailboxId } = context.request.params as { mailboxId: string };
-		const raw = context.request.query as {
-			continuationToken?: string;
-			order?: "asc" | "desc";
-			query?: string;
-			subject?: string;
-			from?: string;
-			unread?: boolean;
-			starred?: boolean;
-			attachments?: boolean;
-			senderTrust?: SenderTrust | SenderTrust[];
-			category?: MessageCategory | MessageCategory[];
-			dkimMismatch?: boolean;
-			count?: boolean;
-			results?: boolean;
-			limit?: number;
-		};
-
-		return executeThreadSearch(await getClient(), accountConfigId, mailboxId, {
-			...raw,
-			senderTrust: toArray(raw.senderTrust),
-			category: toArray(raw.category),
-		});
-	},
-};
-
-export const ThreadDetailOperations: Record<
-	ThreadDetailOperationIds,
-	OperationHandler<ThreadDetailOperationIds>
-> = {
-	ThreadDetailOperations_listThreadMessages: async (
-		context,
-		...args: unknown[]
-	) => {
-		const event = args[0] as APIGatewayProxyEvent;
-		const accountConfigId = getAccountConfigIdFromEvent(event);
-		const { threadId } = context.request.params as { threadId: string };
-		const { order } = context.request.query as {
-			order?: "asc" | "desc";
-		};
-
-		const client = await getClient();
-		const result = await client.threadMessage.listByThread(
-			threadId,
-			accountConfigId,
-			buildListThreadMessagesOptions({ order }),
-		);
-
-		// Defense-in-depth: the query is already scoped to accountConfigId; assert
-		// no foreign row slips into the response. `read`-class → 404, no existence
-		// leak, consistent with the mailbox/message guards.
-		for (const row of result.items) {
-			if (row.accountConfigId !== accountConfigId) {
-				throw new NotFoundError(`Thread not found: ${threadId}`);
-			}
-		}
-
-		const items = await enrichThreadRows(
-			dedupeThreadMessages(result.items),
-			client,
-			accountConfigId,
-		);
-
-		return {
-			items,
-			continuationToken: result.continuationToken,
-		};
-	},
-};

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

@@ -1,197 +0,0 @@
-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],
-		);
-	});
-});