@remit/mailbox-service 0.0.111 → 0.0.112

package/src/mime-walker.ts

@@ -263,13 +263,13 @@ const toRecord = (
  * safe default rather than throwing — one malformed part must never drop the
  * whole message.
  *
- * **Part-path uniqueness**: some IMAP servers (and the `message/rfc822`
- * inner-body convention) return child nodes with an empty `part` field.
- * Assigning ROOT_PART_PATH to every such node would produce duplicate keys
- * and make `upsertBodyParts` write the same body part twice. Non-root nodes
- * without a `part` therefore receive a
- * synthetic path `<parentPath>.<siblingIndex>` that is stable across
- * repeated syncs of the same message.
+ * **Part-path uniqueness**: imapflow gives the root of a message/rfc822
+ * node's encapsulated message the same `part` as the node itself, and some
+ * servers give it none. That root is stored as `<messagePath>.0` — the
+ * encapsulated message's own ROOT_PART_PATH — so it can neither overwrite the
+ * message/rfc822 row nor collide with its children (`<messagePath>.1`, ...).
+ * Any other non-root node without a `part` receives a synthetic path
+ * `<parentPath>.<siblingIndex>` that is stable across repeated syncs.
  */
 export const walkMimeStructure = (root: MimeNode): BodyPartRecord[] => {
 	const out: BodyPartRecord[] = [];
@@ -277,29 +277,30 @@ export const walkMimeStructure = (root: MimeNode): BodyPartRecord[] => {
 	const visit = (
 		node: MimeNode,
 		parentPath: string | null,
+		parentIsMessage: boolean,
 		siblingIndex: number,
 	) => {
 		let partPath: string;
-		if (node.part && node.part.length > 0) {
+		if (parentIsMessage && parentPath !== null) {
+			partPath = `${parentPath}.${ROOT_PART_PATH}`;
+		} else if (node.part && node.part.length > 0) {
 			partPath = node.part;
 		} else if (parentPath === null) {
 			// True root of the BODYSTRUCTURE tree.
 			partPath = ROOT_PART_PATH;
 		} else {
-			// Non-root node without an IMAP part path — synthesise one so
-			// the body-part keys remain unique. This happens most commonly
-			// for the body of a message/rfc822 attachment, whose inner
-			// structure imapflow attaches as a childNode with part="".
 			partPath = `${parentPath}.${siblingIndex}`;
 		}
-		out.push(toRecord(node, partPath, parentPath));
+		const record = toRecord(node, partPath, parentPath);
+		out.push(record);
+		const isMessage = record.mediaType === MediaType.Message;
 		const children = node.childNodes ?? [];
 		for (let i = 0; i < children.length; i++) {
 			// biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
-			visit(children[i]!, partPath, i + 1);
+			visit(children[i]!, partPath, isMessage, i + 1);
 		}
 	};
 
-	visit(root, null, 0);
+	visit(root, null, false, 0);
 	return out;
 };

package/src/organize-job.ts

@@ -0,0 +1,93 @@
+import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import type {
+	CreateOrganizeJobRequestInput,
+	IOrganizeJobRequestRepository,
+	OrganizeJobRequestItem,
+} from "@remit/data-ports";
+import { FilterMatchOperator } from "@remit/domain-enums";
+import { createQueueProducer } from "@remit/sqs-client/producer";
+import { NO_ACTION } from "./filters/match.js";
+
+const ORGANIZE_JOB_TTL_SECONDS = 7 * 24 * 60 * 60;
+
+export interface OrganizeJobOwner {
+	accountConfigId: string;
+	userId: string;
+}
+
+export type OrganizeJobPredicate = Pick<
+	CreateOrganizeJobRequestInput,
+	"matchOperator" | "literalClauses" | "actionLabelId" | "actionMailboxId"
+>;
+
+export type OrganizeJobRequest = OrganizeJobOwner &
+	({ predicate: OrganizeJobPredicate } | { filterId: string });
+
+export interface OrganizeJobLogger {
+	info(obj: Record<string, unknown>, msg: string): void;
+}
+
+export interface OrganizeJobDeps {
+	organizeJobRequest: Pick<IOrganizeJobRequestRepository, "create">;
+	sqsQueueUrl: string;
+	logger: OrganizeJobLogger;
+}
+
+const producers = new Map<string, SQSClient>();
+
+const producerFor = (queueUrl: string): SQSClient => {
+	const existing = producers.get(queueUrl);
+	if (existing) return existing;
+	const producer = createQueueProducer({ queueUrl });
+	producers.set(queueUrl, producer);
+	return producer;
+};
+
+const jobColumns = (
+	request: OrganizeJobRequest,
+): Omit<CreateOrganizeJobRequestInput, keyof OrganizeJobOwner | "ttl"> => {
+	if ("filterId" in request) {
+		return {
+			filterId: request.filterId,
+			matchOperator: FilterMatchOperator.And,
+			literalClauses: [],
+			actionLabelId: NO_ACTION,
+			actionMailboxId: NO_ACTION,
+		};
+	}
+	return { filterId: NO_ACTION, ...request.predicate };
+};
+
+// A filter job names only the filter; the worker reads it when it runs.
+export const queueOrganizeJob = async (
+	deps: OrganizeJobDeps,
+	request: OrganizeJobRequest,
+): Promise<OrganizeJobRequestItem> => {
+	const job = await deps.organizeJobRequest.create({
+		accountConfigId: request.accountConfigId,
+		userId: request.userId,
+		...jobColumns(request),
+		ttl: Math.floor(Date.now() / 1000) + ORGANIZE_JOB_TTL_SECONDS,
+	});
+
+	await producerFor(deps.sqsQueueUrl).send(
+		new SendMessageCommand({
+			QueueUrl: deps.sqsQueueUrl,
+			MessageBody: JSON.stringify({
+				type: "OrganizeJob",
+				accountConfigId: job.accountConfigId,
+				organizeJobId: job.organizeJobId,
+			}),
+		}),
+	);
+
+	deps.logger.info(
+		{
+			accountConfigId: job.accountConfigId,
+			organizeJobId: job.organizeJobId,
+			filterId: job.filterId,
+		},
+		"Organize back-apply job initiated",
+	);
+	return job;
+};