@remit/smtp-worker 0.0.1

package/src/handlers/send-message.ts

@@ -0,0 +1,167 @@
+import { randomUUID } from "node:crypto";
+import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { AwsQueryProtocol } from "@aws-sdk/core/protocols";
+import { deriveAddressId, deriveMessageId } from "@remit/data-ports/id";
+import type { ConnectionState } from "@remit/domain-enums";
+import type { Logger } from "@remit/logger-lambda";
+import {
+	createMailOAuthService,
+	microsoftProviderConfig,
+} from "@remit/mail-oauth-service";
+// Subpath import, not the package root: the root barrel re-exports the whole
+// IMAP sync surface (mailbox/flag/message sync, snippet/heuristics text
+// processing), which drags `natural` and friends into a bundle that only
+// ever calls resolveConnectionCredentials.
+import {
+	type AccountCredentialsDeps,
+	resolveConnectionCredentials,
+} from "@remit/mailbox-service/account-credentials";
+import {
+	createKmsDataKeyProvider,
+	createSecretsService,
+} from "@remit/secrets-service";
+import { sendMail } from "@remit/smtp-service";
+import { resolveSqsCredentials } from "@remit/sqs-client";
+import { env } from "expect-env";
+import { buildDataPortsFromEnv } from "../data-ports.js";
+import type { SendMessageEvent } from "../events.js";
+import { sendMessage } from "./send-message-core.js";
+
+const ports = await buildDataPortsFromEnv();
+const dataKeyProvider = createKmsDataKeyProvider(env.KMS_KEY_ID);
+const secrets = createSecretsService(dataKeyProvider);
+
+// Lazy OAuth service (only instantiated when an OAuth account sends mail)
+let _tokenService: ReturnType<typeof createMailOAuthService> | undefined;
+const getTokenService = () => {
+	if (!_tokenService) {
+		_tokenService = createMailOAuthService(
+			microsoftProviderConfig({
+				clientId: process.env.MSOAUTH_CLIENT_ID ?? "",
+				clientSecret: process.env.MSOAUTH_CLIENT_SECRET ?? "",
+				overrides: process.env.MSOAUTH_TOKEN_ENDPOINT
+					? { tokenEndpoint: process.env.MSOAUTH_TOKEN_ENDPOINT }
+					: undefined,
+			}),
+		);
+	}
+	return _tokenService;
+};
+
+const accountService = ports.account;
+const outboxService = ports.outboxMessage;
+const addressService = ports.address;
+const messageService = ports.message;
+const envelopeService = ports.envelope;
+
+// APPEND_SENT_MESSAGE is processed by the IMAP worker via the
+// message-management queue (see remit-imap-worker/src/emit.ts).
+const messageMgmtQueueUrl = env.SQS_QUEUE_URL_MESSAGE_MGMT;
+const isLocalQueue = messageMgmtQueueUrl.startsWith("http://localhost");
+
+const messageMgmtSqs = new SQSClient({
+	endpoint: isLocalQueue ? new URL(messageMgmtQueueUrl).origin : undefined,
+	...(isLocalQueue && { protocol: AwsQueryProtocol }),
+	credentials: resolveSqsCredentials(),
+});
+
+const emitAppendSentMessage = async (
+	accountId: string,
+	outboxMessageId: string,
+): Promise<void> => {
+	const event = {
+		type: "APPEND_SENT_MESSAGE" as const,
+		accountId,
+		outboxMessageId,
+		eventId: randomUUID(),
+		timestamp: Date.now(),
+	};
+
+	await messageMgmtSqs.send(
+		new SendMessageCommand({
+			QueueUrl: messageMgmtQueueUrl,
+			MessageBody: JSON.stringify(event),
+		}),
+	);
+};
+
+const findMessageByHeader = async (
+	accountId: string,
+	messageIdHeader: string,
+) => {
+	const messageId = deriveMessageId(accountId, messageIdHeader);
+	return messageService.get(messageId).catch((error: unknown) => {
+		if ((error as { name?: string })?.name === "NotFoundError") return null;
+		throw error;
+	});
+};
+
+const getEnvelopeFromEmail = async (
+	messageId: string,
+): Promise<string | null> => {
+	const data = await envelopeService
+		.getMessageData(messageId)
+		.catch((error: unknown) => {
+			if ((error as { name?: string })?.name === "NotFoundError") return null;
+			throw error;
+		});
+	if (!data) return null;
+	const fromEntry = data.envelopeAddress.find(
+		(addr) => addr.addressRole === "from",
+	);
+	return fromEntry?.normalizedEmail ?? null;
+};
+
+/**
+ * Build AccountCredentialsDeps for the SMTP send path.
+ * Uses resolveConnectionCredentials — the single authType branch in the codebase.
+ * Rotation is persisted via accountService.update so the next IMAP sync picks
+ * up the new token without needing a separate refresh.
+ */
+const buildCredentialDeps = (): AccountCredentialsDeps => ({
+	secrets,
+	tokenService: getTokenService(),
+	persistRotatedToken: async (accountId, encryptedHash, updatedAt) => {
+		await accountService.update(accountId, {
+			oauthRefreshTokenHash: encryptedHash,
+			oauthTokenUpdatedAt: updatedAt,
+		});
+	},
+});
+
+export const handleSendMessage = (
+	event: SendMessageEvent,
+	log: Logger,
+): Promise<void> => {
+	const credentialDeps = buildCredentialDeps();
+	return sendMessage(event, log, {
+		getOutbox: (accountConfigId, id) => outboxService.get(accountConfigId, id),
+		getAccount: (id) => accountService.get(id),
+		updateOutbox: (accountConfigId, id, patch) =>
+			outboxService.update(accountConfigId, id, patch),
+		updateOutboxStatus: (accountConfigId, id, status) =>
+			outboxService.updateStatus(accountConfigId, id, status),
+		markOutboxSent: (accountConfigId, id, fields) =>
+			outboxService.markSent(accountConfigId, id, fields),
+		secrets,
+		resolveCredentials: (account) =>
+			resolveConnectionCredentials(account, credentialDeps),
+		updateConnectionState: async (id, state) => {
+			await accountService.update(id, {
+				connectionState:
+					state as (typeof ConnectionState)[keyof typeof ConnectionState],
+			});
+		},
+		send: sendMail,
+		emitAppendSentMessage,
+		engagement: {
+			resolveAddressId: deriveAddressId,
+			incrementOutboundCount: (accountConfigId, addressId, now) =>
+				addressService.incrementOutboundCount(accountConfigId, addressId, now),
+			incrementReplyCount: (accountConfigId, addressId, now) =>
+				addressService.incrementReplyCount(accountConfigId, addressId, now),
+			findMessageByHeader,
+			getEnvelopeFromEmail,
+		},
+	});
+};

package/src/index.ts

@@ -0,0 +1,51 @@
+import { inspect } from "node:util";
+import {
+	createLogger,
+	MetricUnit,
+	metrics,
+	withTelemetry,
+} from "@remit/logger-lambda";
+import type { SQSBatchResponse, SQSEvent } from "aws-lambda";
+import type { SmtpEvent } from "./events.js";
+import { processEvent } from "./processor.js";
+
+const log = createLogger();
+
+export const handler = withTelemetry(
+	async (event: SQSEvent): Promise<SQSBatchResponse> => {
+		const batchItemFailures: { itemIdentifier: string }[] = [];
+
+		for (const record of event.Records) {
+			const smtpEvent: SmtpEvent = JSON.parse(record.body);
+			log.info("Processing SMTP event", {
+				eventType: smtpEvent.type,
+				eventId: smtpEvent.eventId,
+			});
+
+			const sendStart = Date.now();
+			const failed = await processEvent(smtpEvent, log)
+				.then(() => {
+					metrics.addMetric(
+						"smtpSendLatency",
+						MetricUnit.Milliseconds,
+						Date.now() - sendStart,
+					);
+					return false;
+				})
+				.catch((error) => {
+					log.error("SMTP event processing failed", {
+						error: inspect(error),
+						messageId: record.messageId,
+					});
+					metrics.addMetric("smtpSendFailures", MetricUnit.Count, 1);
+					return true;
+				});
+
+			if (failed) {
+				batchItemFailures.push({ itemIdentifier: record.messageId });
+			}
+		}
+
+		return { batchItemFailures };
+	},
+);

package/src/poller.ts

@@ -0,0 +1,18 @@
+import { createLogger } from "@remit/logger-lambda";
+import { runQueuePoller } from "@remit/sqs-client/poller";
+import { env } from "expect-env";
+import { handler } from "./index.js";
+
+/** Production queue poller — the deployed form of `e2e-processor-shim.ts`. */
+const log = createLogger();
+
+await runQueuePoller({
+	log,
+	targets: [
+		{
+			queueUrl: env.SQS_QUEUE_URL_SMTP,
+			handler,
+			functionName: "smtp-worker",
+		},
+	],
+});

package/src/processor.ts

@@ -0,0 +1,22 @@
+import type { Logger } from "@remit/logger-lambda";
+import type { SmtpEvent } from "./events.js";
+import { handleSendMessage } from "./handlers/send-message.js";
+
+export const processEvent = async (
+	event: SmtpEvent,
+	log: Logger,
+): Promise<void> => {
+	switch (event.type) {
+		case "SEND_MESSAGE":
+			return handleSendMessage(event, log);
+		case "PROCESS_OUTBOX":
+			// Future: batch process all queued messages
+			log.info(
+				{ accountId: event.accountId },
+				"PROCESS_OUTBOX not yet implemented",
+			);
+			return;
+		default:
+			throw new Error(`Unknown event type: ${(event as SmtpEvent).type}`);
+	}
+};

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "../../tsconfig.json",
+	"compilerOptions": {
+		"rootDir": "src",
+		"outDir": "dist"
+	},
+	"include": ["src/**/*"]
+}