@c9up/rover 0.1.14 → 0.1.16

package/src/transports/MailgunTransport.ts

@@ -1,6 +1,3 @@
-import formData from "form-data";
-// mailgun.js is UMD-bundled; the class lives on `.default` under NodeNext.
-import MailgunModule from "mailgun.js";
 import {
 	type MailMessage,
 	type MailSendOutcome,
@@ -9,6 +6,7 @@ import {
 } from "../Mail.js";
 import { attachmentsFor, headerValue } from "../MessageBuilder.js";
 import { RoverError } from "../RoverError.js";
+import { fetchWithTimeout, wrapFetchNetworkError } from "./fetchError.js";
 
 const stripCrlf = (v: string): string => v.replace(/[\r\n]/g, "");
 const normalizeConfig = (v: string): string => stripCrlf(v).trim();
@@ -23,19 +21,10 @@ const redactSecrets = (s: string): string =>
 		.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [REDACTED]")
 		.replace(/Basic\s+[A-Za-z0-9+/=]+/g, "Basic [REDACTED]");
 
-/** Minimal mailgun.js client surface — matches the subset we need. */
-interface MailgunClientLike {
-	messages: {
-		create(
-			domain: string,
-			data: Record<string, unknown>,
-		): Promise<{ id?: string; message?: string; status?: number }>;
-	};
-}
-
 export class MailgunTransport implements MailTransport {
-	#client: MailgunClientLike;
+	#apiKey: string;
 	#domain: string;
+	#baseUrl: string;
 
 	constructor(config: Record<string, unknown>) {
 		const apiKey =
@@ -78,24 +67,11 @@ export class MailgunTransport implements MailTransport {
 				? "https://api.eu.mailgun.net"
 				: "https://api.mailgun.net";
 
-		// Dependency injection for tests: `_client` wins over real SDK. Guarded
-		// against non-object and non-shape inputs so a typo'd config can't
-		// silently bypass the real client.
-		const injected = config._client;
-		if (
-			injected &&
-			typeof injected === "object" &&
-			"messages" in (injected as object) &&
-			typeof (injected as MailgunClientLike).messages?.create === "function"
-		) {
-			this.#client = injected as MailgunClientLike;
-		} else {
-			// mailgun.js ships a UMD-style default export; the class constructor
-			// lives on `.default` in the typings (`static get default`).
-			const MailgunCtor = MailgunModule.default;
-			const mailgun = new MailgunCtor(formData);
-			this.#client = mailgun.client({ username: "api", key: apiKey, url });
-		}
+		this.#apiKey = apiKey;
+		this.#baseUrl =
+			typeof config.baseUrl === "string" && config.baseUrl.length > 0
+				? normalizeConfig(config.baseUrl).replace(/\/+$/, "")
+				: url;
 	}
 
 	async send(message: MailMessage): Promise<MailSendOutcome> {
@@ -134,38 +110,70 @@ export class MailgunTransport implements MailTransport {
 				? v.map(stripCrlf).join(", ")
 				: stripCrlf(v);
 		}
-		if (attachmentsFor(message).length > 0) {
-			data.attachment = attachmentsFor(message).map((att) => {
-				const entry: { filename: string; data: Buffer; contentType?: string } =
-					{
-						filename: stripCrlf(att.filename),
-						data: Buffer.from(att.content as Buffer | string),
-					};
-				if (att.contentType) {
-					entry.contentType = stripCrlf(att.contentType);
-				}
-				return entry;
-			});
+		// Mailgun takes `multipart/form-data`; Node builds it, and `fetch` sets
+		// the boundary. Scalars first, then one file part per attachment.
+		const form = new FormData();
+		for (const [key, value] of Object.entries(data)) {
+			form.append(key, Array.isArray(value) ? value.join(", ") : String(value));
+		}
+		for (const att of attachmentsFor(message)) {
+			const bytes = Buffer.from(att.content as Buffer | string);
+			const blob = att.contentType
+				? new Blob([bytes], { type: stripCrlf(att.contentType) })
+				: new Blob([bytes]);
+			form.append("attachment", blob, stripCrlf(att.filename));
 		}
 
+		let res: Response;
 		try {
-			const res = await this.#client.messages.create(this.#domain, data);
-			if (res.id) return { providerId: res.id };
-			return undefined;
+			res = await fetchWithTimeout(
+				"Mailgun",
+				`${this.#baseUrl}/v3/${encodeURIComponent(this.#domain)}/messages`,
+				{
+					method: "POST",
+					headers: {
+						// HTTP Basic, the username is literally `api`.
+						Authorization: `Basic ${Buffer.from(`api:${this.#apiKey}`).toString("base64")}`,
+						Accept: "application/json",
+					},
+					body: form,
+				},
+			);
 		} catch (err) {
-			throw wrapMailgunError(err);
+			throw wrapFetchNetworkError("mailgun", err);
+		}
+
+		const raw = await res.text();
+		if (!res.ok) {
+			throw wrapMailgunError({
+				status: res.status,
+				message: raw,
+				headers: Object.fromEntries(res.headers.entries()),
+			});
+		}
+		// A 200 carries `{ id, message }`; anything unparseable is still a
+		// success on the wire, so it is not turned into an error.
+		try {
+			const parsed: unknown = JSON.parse(raw);
+			const id =
+				typeof parsed === "object" && parsed !== null
+					? Reflect.get(parsed, "id")
+					: undefined;
+			return typeof id === "string" ? { providerId: id } : undefined;
+		} catch {
+			return undefined;
 		}
 	}
 }
 
 /**
- * mailgun.js's own error shape is `{ status, details | message, ... }`.
- * Map it to our uniform `E_MAIL_PROVIDER_ERROR` so retry + observability
- * consumers don't need to branch on provider.
+ * Map an upstream refusal onto the uniform `E_MAIL_PROVIDER_ERROR` every
+ * transport raises, so retry and observability never branch on the provider.
  *
- * Bare `Error` (no `status`) — typical for network/ECONNRESET failures from
- * mailgun.js — surface the original errno (`code`) in context so the retry
- * predicate can still classify it as transient.
+ * The shape is what the HTTP response gives: a status, the body as the
+ * message, and the response headers — `Retry-After` among them, which the
+ * backoff honours. A network failure never reaches here; `wrapFetchNetworkError`
+ * carries the errno so the retry predicate can still see it.
  */
 function wrapMailgunError(err: unknown): RoverError {
 	if (err instanceof RoverError) return err;
@@ -176,8 +184,8 @@ function wrapMailgunError(err: unknown): RoverError {
 		code?: string;
 		headers?: Record<string, string | string[]>;
 	};
-	// Coerce string-typed status ("401") into number — mailgun.js is
-	// inconsistent across versions.
+	// Coerce a string-typed status into a number: the field is built here, but
+	// a caller injecting a fake response may still hand one over as text.
 	const statusNum = Number(anyErr.status);
 	const status = Number.isFinite(statusNum) ? statusNum : 0;
 	const providerMessage = redactSecrets(

package/src/transports/SendGridTransport.ts

@@ -1,7 +1,3 @@
-import sgMail, {
-	type MailDataRequired,
-	type MailService,
-} from "@sendgrid/mail";
 import {
 	type MailMessage,
 	type MailSendOutcome,
@@ -10,6 +6,7 @@ import {
 } from "../Mail.js";
 import { attachmentsFor, headerValue } from "../MessageBuilder.js";
 import { RoverError } from "../RoverError.js";
+import { fetchWithTimeout, wrapFetchNetworkError } from "./fetchError.js";
 
 const stripCrlf = (v: string): string => v.replace(/[\r\n]/g, "");
 const normalizeConfig = (v: string): string => stripCrlf(v).trim();
@@ -24,26 +21,9 @@ const redactSecrets = (s: string): string =>
 		.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [REDACTED]")
 		.replace(/Basic\s+[A-Za-z0-9+/=]+/g, "Basic [REDACTED]");
 
-/**
- * Minimal slice of the SendGrid client we depend on. A per-transport client
- * instance is created in the constructor so concurrent transports with
- * different API keys cannot race each other — the original module-level
- * `sgMail.setApiKey()` would have been a multi-tenant foot-gun.
- */
-interface SendGridClientLike {
-	setApiKey(apiKey: string): void;
-	send(
-		data: MailDataRequired,
-	): Promise<
-		[
-			{ statusCode: number; headers: Record<string, string | string[]> },
-			unknown,
-		]
-	>;
-}
-
 export class SendGridTransport implements MailTransport {
-	#client: SendGridClientLike;
+	#apiKey: string;
+	#baseUrl: string;
 
 	constructor(config: Record<string, unknown>) {
 		const apiKey =
@@ -56,86 +36,96 @@ export class SendGridTransport implements MailTransport {
 			);
 		}
 
-		// Dependency injection for tests — stronger guard than the old version
-		// (require both `send` AND `setApiKey` to pass through).
-		const injected = config._client;
-		if (
-			injected &&
-			typeof injected === "object" &&
-			typeof (injected as SendGridClientLike).send === "function" &&
-			typeof (injected as SendGridClientLike).setApiKey === "function"
-		) {
-			this.#client = injected as SendGridClientLike;
-		} else {
-			// Per-instance MailService (not the shared `sgMail` singleton) so
-			// `setApiKey` can't race across multiple transports.
-			this.#client = new (resolveMailServiceCtor(sgMail))();
-		}
-		this.#client.setApiKey(apiKey);
+		this.#apiKey = apiKey;
+		this.#baseUrl =
+			typeof config.baseUrl === "string" && config.baseUrl.length > 0
+				? normalizeConfig(config.baseUrl).replace(/\/+$/, "")
+				: "https://api.sendgrid.com";
 	}
 
 	async send(message: MailMessage): Promise<MailSendOutcome> {
 		assertHasRecipients(message);
-		const content = buildSendGridContent(message);
 
-		// CRLF stripping at the wire boundary (defence-in-depth, matches the
-		// Dev Notes anti-pattern: never trust the SDK to handle it).
-		const data: MailDataRequired = {
-			from: stripCrlf(message.from),
-			to: message.to.map(stripCrlf),
+		// CRLF is stripped at the wire boundary regardless of what the provider
+		// promises — a header injected through a recipient or a subject is the
+		// one thing a transport must never pass on.
+		const address = (value: string): { email: string } => ({
+			email: stripCrlf(value),
+		});
+		const personalization: Record<string, unknown> = {
+			// `to` may be empty when a message is bcc-only, which SendGrid allows.
+			to: message.to.map(address),
+		};
+		if (message.cc.length) personalization.cc = message.cc.map(address);
+		if (message.bcc.length) personalization.bcc = message.bcc.map(address);
+
+		const body: Record<string, unknown> = {
+			// The v3 API groups recipients under `personalizations`; the SDK's
+			// flat shape was its own, and this is what actually goes on the wire.
+			personalizations: [personalization],
+			from: address(message.from),
 			subject: stripCrlf(message.subject),
-			content,
-			...(message.cc.length ? { cc: message.cc.map(stripCrlf) } : {}),
-			...(message.bcc.length ? { bcc: message.bcc.map(stripCrlf) } : {}),
-			...(message.replyTo ? { replyTo: stripCrlf(message.replyTo) } : {}),
-			...(Object.keys(message.headers).length
-				? {
-						headers: Object.fromEntries(
-							Object.entries(message.headers).map(([k, raw]) => {
-								const v = headerValue(raw);
-								return [
-									stripCrlf(k),
-									Array.isArray(v) ? v.map(stripCrlf).join(", ") : stripCrlf(v),
-								];
-							}),
-						),
-					}
-				: {}),
-			...(attachmentsFor(message).length
-				? {
-						attachments: attachmentsFor(message).map((att) => {
-							const entry: {
-								filename: string;
-								content: string;
-								type?: string;
-								disposition: "attachment";
-							} = {
-								filename: stripCrlf(att.filename),
-								content: Buffer.from(att.content as Buffer | string).toString(
-									"base64",
-								),
-								disposition: "attachment" as const,
-							};
-							if (att.contentType) entry.type = stripCrlf(att.contentType);
-							return entry;
-						}),
-					}
-				: {}),
+			content: buildSendGridContent(message),
 		};
+		if (message.replyTo) body.reply_to = address(message.replyTo);
+		if (Object.keys(message.headers).length) {
+			body.headers = Object.fromEntries(
+				Object.entries(message.headers).map(([k, raw]) => {
+					const v = headerValue(raw);
+					return [
+						stripCrlf(k),
+						Array.isArray(v) ? v.map(stripCrlf).join(", ") : stripCrlf(v),
+					];
+				}),
+			);
+		}
+		const attachments = attachmentsFor(message);
+		if (attachments.length > 0) {
+			body.attachments = attachments.map((att) => {
+				const entry: Record<string, string> = {
+					filename: stripCrlf(att.filename),
+					content: Buffer.from(att.content as Buffer | string).toString(
+						"base64",
+					),
+					disposition: "attachment",
+				};
+				if (att.contentType) entry.type = stripCrlf(att.contentType);
+				return entry;
+			});
+		}
 
+		let res: Response;
 		try {
-			const result = await this.#client.send(data);
-			// Guard against non-standard SDK responses: `[]`, `[undefined]`, etc.
-			const response = Array.isArray(result) ? result[0] : undefined;
-			const msgId = response?.headers?.["x-message-id"];
-			const idStr = Array.isArray(msgId) ? msgId[0] : msgId;
-			if (idStr && typeof idStr === "string" && idStr.length > 0) {
-				return { providerId: idStr };
-			}
-			return undefined;
+			res = await fetchWithTimeout(
+				"SendGrid",
+				`${this.#baseUrl}/v3/mail/send`,
+				{
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${this.#apiKey}`,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify(body),
+				},
+			);
 		} catch (err) {
-			throw wrapSendGridError(err);
+			throw wrapFetchNetworkError("sendgrid", err);
 		}
+
+		if (!res.ok) {
+			// Shaped as the mapper already reads it, so the mapping stays one
+			// piece of logic rather than two that can drift.
+			throw wrapSendGridError({
+				response: {
+					statusCode: res.status,
+					body: await res.text(),
+					headers: Object.fromEntries(res.headers.entries()),
+				},
+			});
+		}
+		// A 202 carries no body; the id is in the header.
+		const id = res.headers.get("x-message-id");
+		return id !== null && id.length > 0 ? { providerId: id } : undefined;
 	}
 }
 
@@ -158,7 +148,7 @@ function assertHasRecipients(message: MailMessage): void {
 /**
  * Build the SendGrid v3 `content[]`: text/plain when text is set, text/html when
  * html is set, always at least one entry (SendGrid rejects empty content). The
- * non-empty tuple type lets the SDK's MailDataRequired see `content[0]` exists.
+ * At least one entry always: SendGrid refuses a message with empty content.
  */
 function buildSendGridContent(
 	message: MailMessage,
@@ -177,7 +167,9 @@ function buildSendGridContent(
 
 function wrapSendGridError(err: unknown): RoverError {
 	if (err instanceof RoverError) return err;
-	// @sendgrid/mail throws `{ code, message, response: { body, headers, statusCode } }`
+	// Built from the HTTP response here, but the older SDK shape
+	// (`{ code, message, response: { body, headers, statusCode } }`) is still
+	// accepted so an injected fake or a wrapped error maps the same way.
 	const anyErr = err as {
 		code?: number | string;
 		message?: string;
@@ -224,27 +216,4 @@ function wrapSendGridError(err: unknown): RoverError {
 	);
 }
 
-/**
- * Type-guard resolver for the `MailService` constructor attached to the
- * module's default export at runtime. The cerebrum forbids `as unknown as T`;
- * here we receive `sgMail` through a parameter typed `unknown`, narrow with
- * runtime `typeof` checks, and return a single cast to a precise callable
- * type. No double-cast chain, no `as unknown` anchor.
- */
-function resolveMailServiceCtor(mod: unknown): new () => MailService {
-	if (mod && typeof mod === "object" && "MailService" in mod) {
-		const candidate = (mod as { MailService: unknown }).MailService;
-		if (typeof candidate === "function") {
-			return candidate as new () => MailService;
-		}
-	}
-	throw new RoverError(
-		"E_MAIL_PROVIDER_CONFIG",
-		"@sendgrid/mail runtime does not expose `.MailService` — upgrade to v8+",
-		{
-			hint: "Expected `module.exports.MailService` to be the MailService class (index.js attaches it).",
-		},
-	);
-}
-
 registerTransport("sendgrid", (config) => new SendGridTransport(config));

package/src/transports/SparkPostTransport.ts

@@ -177,9 +177,12 @@ export class SparkPostTransport implements MailTransport {
 function parseAddress(input: string): { email: string; name?: string } {
 	const s = stripCrlf(input).trim();
 	const match = s.match(/^(.*)<([^>]+)>\s*$/);
-	if (match) {
-		const email = match[2].trim();
-		const name = match[1].trim().replace(/^"|"$/g, "").trim();
+	// Both groups are required by the pattern, so a match carries both —
+	// named rather than indexed, which is what says so.
+	const [, rawName, rawEmail] = match ?? [];
+	if (rawEmail !== undefined) {
+		const email = rawEmail.trim();
+		const name = (rawName ?? "").trim().replace(/^"|"$/g, "").trim();
 		return name ? { email, name } : { email };
 	}
 	return { email: s };

package/src/webhooks/context.ts

@@ -37,5 +37,13 @@ export type WebhookMiddleware = (
 ) => Promise<void>;
 
 export interface WebhookEmitter {
-	emit(event: string, data: unknown): void;
+	/**
+	 * `unknown`, not `void`. `@adonisjs/events` declares
+	 * `emit(): Promise<void>` and rethrows when a listener fails and no error
+	 * handler is registered — and a `void` return ACCEPTS a promise-returning
+	 * function, so the call site reads as if there were nothing to handle.
+	 * Duck-typed, so it stays wider than Adonis's own class: a Node
+	 * EventEmitter returns boolean.
+	 */
+	emit(event: string, data: unknown): unknown;
 }

package/src/webhooks/mailgun.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createHmac, timingSafeEqual } from "node:crypto";
+import { emitSafely } from "../emitSafely.js";
 import type {
 	WebhookEmitter,
 	WebhookHttpContext,
@@ -94,7 +95,7 @@ export function createMailgunWebhookHandler(
 		const eventName = EVENT_MAP[data.event];
 		if (eventName) {
 			try {
-				emitter.emit(eventName, {
+				emitSafely(emitter, eventName, {
 					messageId: data.message?.headers?.["message-id"] ?? "",
 					to: data.recipient ?? "",
 					reason: data.reason,

package/src/webhooks/resend.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createHmac, timingSafeEqual } from "node:crypto";
+import { emitSafely } from "../emitSafely.js";
 import type {
 	WebhookEmitter,
 	WebhookHttpContext,
@@ -176,7 +177,7 @@ function emitMappedEvent(
 		? (payload.data.to[0] ?? "")
 		: (payload.data?.to ?? "");
 	try {
-		emitter.emit(mapped, {
+		emitSafely(emitter, mapped, {
 			messageId: payload.data?.email_id ?? "",
 			to,
 			reason: payload.data?.reason,

package/src/webhooks/sendgrid.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createPublicKey, verify } from "node:crypto";
+import { emitSafely } from "../emitSafely.js";
 import type {
 	WebhookEmitter,
 	WebhookHttpContext,
@@ -101,7 +102,7 @@ export function createSendGridWebhookHandler(
 			const mapped = EVENT_MAP[ev.event];
 			if (!mapped) continue;
 			try {
-				emitter.emit(mapped, {
+				emitSafely(emitter, mapped, {
 					messageId: ev.sg_message_id ?? "",
 					to: ev.email ?? "",
 					reason: ev.reason,