@c9up/rover 0.1.13 → 0.1.15

package/src/transports/ResendTransport.ts

@@ -47,7 +47,7 @@ export class ResendTransport implements MailTransport {
 			typeof config.apiKey === "string" ? normalizeConfig(config.apiKey) : "";
 		if (!apiKey) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"Resend transport requires apiKey",
 				{ hint: "Set { apiKey } in your mail config." },
 			);
@@ -62,7 +62,7 @@ export class ResendTransport implements MailTransport {
 			message.bcc.length === 0
 		) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"Mail message has no recipients",
 				{ hint: "Set at least one `to`, `cc`, or `bcc` before sending." },
 			);
@@ -127,7 +127,7 @@ export class ResendTransport implements MailTransport {
 			};
 			if (retryAfter) ctx.retryAfter = retryAfter;
 			throw new RoverError(
-				"MAIL_PROVIDER_ERROR",
+				"E_MAIL_PROVIDER_ERROR",
 				`Resend returned ${res.status}`,
 				{
 					hint: "Inspect `context.upstreamStatus` to decide retry eligibility. `context.retryAfter` (when set) carries the provider's backoff hint in seconds.",

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,118 +21,111 @@ 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 =
 			typeof config.apiKey === "string" ? normalizeConfig(config.apiKey) : "";
 		if (!apiKey) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"SendGrid transport requires apiKey",
 				{ hint: "Set { apiKey } in your mail config." },
 			);
 		}
 
-		// 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;
 	}
 }
 
@@ -148,7 +138,7 @@ function assertHasRecipients(message: MailMessage): void {
 		message.bcc.length === 0
 	) {
 		throw new RoverError(
-			"MAIL_PROVIDER_CONFIG",
+			"E_MAIL_PROVIDER_CONFIG",
 			"Mail message has no recipients",
 			{ hint: "Set at least one `to`, `cc`, or `bcc` before sending." },
 		);
@@ -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;
@@ -215,7 +207,7 @@ function wrapSendGridError(err: unknown): RoverError {
 	const retryAfter = anyErr.response?.headers?.["retry-after"];
 	if (retryAfter) ctx.retryAfter = retryAfter;
 	return new RoverError(
-		"MAIL_PROVIDER_ERROR",
+		"E_MAIL_PROVIDER_ERROR",
 		`SendGrid returned ${status || "unknown"}`,
 		{
 			hint: "Inspect `context.upstreamStatus` (HTTP) or `context.networkCode` (ECONNRESET/etc.) to decide retry eligibility. `context.retryAfter` (when set) carries the provider's backoff hint in seconds.",
@@ -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(
-		"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/SesTransport.ts

@@ -65,14 +65,14 @@ export class SesTransport implements MailTransport {
 				: "";
 		if (!accessKeyId || !secretAccessKey || !rawRegion) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"SES transport requires accessKeyId, secretAccessKey, and region",
 				{ hint: "Set all three in your mail config." },
 			);
 		}
 		if (!REGION_RE.test(rawRegion)) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				`SES region "${rawRegion}" is not a valid AWS region identifier`,
 				{
 					hint: "Use the lowercase canonical form, e.g. 'us-east-1'. Uppercase breaks the SigV4 signing scope.",
@@ -92,7 +92,7 @@ export class SesTransport implements MailTransport {
 			message.bcc.length === 0
 		) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"Mail message has no recipients",
 				{ hint: "Set at least one `to`, `cc`, or `bcc` before sending." },
 			);
@@ -132,7 +132,7 @@ export class SesTransport implements MailTransport {
 			};
 			if (retryAfter) ctx.retryAfter = retryAfter;
 			throw new RoverError(
-				"MAIL_PROVIDER_ERROR",
+				"E_MAIL_PROVIDER_ERROR",
 				`SES returned ${res.status}`,
 				{
 					hint: "Inspect `context.upstreamStatus` to decide retry eligibility. `context.retryAfter` (when set) carries the provider's backoff hint in seconds.",

package/src/transports/SparkPostTransport.ts

@@ -59,7 +59,7 @@ export class SparkPostTransport implements MailTransport {
 					: "";
 		if (!apiKey) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"SparkPost transport requires apiKey",
 				{ hint: "Set { apiKey } in your mail config." },
 			);
@@ -78,7 +78,7 @@ export class SparkPostTransport implements MailTransport {
 			message.bcc.length === 0
 		) {
 			throw new RoverError(
-				"MAIL_PROVIDER_CONFIG",
+				"E_MAIL_PROVIDER_CONFIG",
 				"Mail message has no recipients",
 				{ hint: "Set at least one `to`, `cc`, or `bcc` before sending." },
 			);
@@ -148,7 +148,7 @@ export class SparkPostTransport implements MailTransport {
 			};
 			if (retryAfter) ctx.retryAfter = retryAfter;
 			throw new RoverError(
-				"MAIL_PROVIDER_ERROR",
+				"E_MAIL_PROVIDER_ERROR",
 				`SparkPost returned ${res.status}`,
 				{
 					hint: "Inspect `context.upstreamStatus` to decide retry eligibility. `context.retryAfter` (when set) carries the provider's backoff hint in seconds.",

package/src/transports/fetchError.ts

@@ -1,7 +1,7 @@
 import { RoverError } from "../RoverError.js";
 
 /**
- * Wrap a `fetch()` rejection into the uniform `MAIL_PROVIDER_ERROR` shape
+ * Wrap a `fetch()` rejection into the uniform `E_MAIL_PROVIDER_ERROR` shape
  * so the retry classifier can recognise transient network failures
  * (ECONNRESET / ENOTFOUND / EAI_AGAIN / ...).
  *
@@ -32,7 +32,7 @@ export function wrapFetchNetworkError(
 	};
 	if (networkCode) ctx.networkCode = networkCode;
 	return new RoverError(
-		"MAIL_PROVIDER_ERROR",
+		"E_MAIL_PROVIDER_ERROR",
 		`${provider} fetch failed${networkCode ? ` (${networkCode})` : ""}`,
 		{
 			hint: "Inspect `context.networkCode` (ECONNRESET / ENOTFOUND / ...) — the retry classifier treats known transient errnos as retryable.",
@@ -50,7 +50,7 @@ const DEFAULT_TIMEOUT_MS = 30_000;
  * Without one, a stalled provider connection never settles: the send hangs,
  * the queue worker holding it hangs with it, and enough of them stop mail going
  * out at all — with no error to explain the silence. A timeout surfaces as the
- * same `MAIL_PROVIDER_ERROR` shape the retry classifier already understands, so
+ * same `E_MAIL_PROVIDER_ERROR` shape the retry classifier already understands, so
  * it is retried like any other transient network failure.
  */
 export async function fetchWithTimeout(
@@ -68,7 +68,7 @@ export async function fetchWithTimeout(
 	} catch (err) {
 		if (err instanceof Error && err.name === "TimeoutError") {
 			throw new RoverError(
-				"MAIL_PROVIDER_ERROR",
+				"E_MAIL_PROVIDER_ERROR",
 				`${provider} did not answer within ${timeoutMs}ms.`,
 				{
 					context: { provider, upstreamStatus: "0", networkCode: "ETIMEDOUT" },