typedmailer 1.0.0

package/dist/index.js

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { MailError, normalizeProviderError } from './errors.js';
+import { mailInputSchema, normalizeAddresses } from './config.js';
+const baseOptions = z.object({
+    from: z.union([
+        z.string().email(),
+        z.string().regex(/^.+ <[^<>\s]+@[^<>\s]+>$/, 'Use a valid email address or "Name <email@example.com>".'),
+        z.object({ email: z.string().email(), name: z.string().optional() }).strict(),
+    ]),
+});
+const providerOptions = {
+    resend: baseOptions.extend({ provider: z.literal('resend'), apiKey: z.string().min(1) }),
+    brevo: baseOptions.extend({ provider: z.literal('brevo'), apiKey: z.string().min(1) }),
+    postmark: baseOptions.extend({ provider: z.literal('postmark'), apiKey: z.string().min(1) }),
+    sendgrid: baseOptions.extend({ provider: z.literal('sendgrid'), apiKey: z.string().min(1) }),
+    mailgun: baseOptions.extend({
+        provider: z.literal('mailgun'),
+        apiKey: z.string().min(1),
+        domain: z.string().min(1),
+        region: z.enum(['us', 'eu']).default('us'),
+    }),
+    ses: baseOptions.extend({ provider: z.literal('ses'), region: z.string().min(1) }),
+    smtp: baseOptions
+        .extend({
+        provider: z.literal('smtp'),
+        host: z.string().min(1),
+        port: z.number().int().min(1).max(65535),
+        secure: z.boolean(),
+        user: z.string().min(1).optional(),
+        password: z.string().min(1).optional(),
+        connectionTimeout: z.number().int().positive().default(8_000),
+        greetingTimeout: z.number().int().positive().default(8_000),
+        socketTimeout: z.number().int().positive().default(15_000),
+    })
+        .refine((options) => Boolean(options.user) === Boolean(options.password), {
+        message: 'SMTP user and password must be configured together.',
+        path: ['user'],
+    }),
+};
+async function loadProvider(options) {
+    try {
+        switch (options.provider) {
+            case 'resend': {
+                const { createResendProvider } = await import('./providers/resend.js');
+                return createResendProvider(options);
+            }
+            case 'brevo': {
+                const { createBrevoProvider } = await import('./providers/brevo.js');
+                return createBrevoProvider(options);
+            }
+            case 'postmark': {
+                const { createPostmarkProvider } = await import('./providers/postmark.js');
+                return createPostmarkProvider(options);
+            }
+            case 'sendgrid': {
+                const { createSendGridProvider } = await import('./providers/sendgrid.js');
+                return createSendGridProvider(options);
+            }
+            case 'mailgun': {
+                const { createMailgunProvider } = await import('./providers/mailgun.js');
+                return createMailgunProvider(options);
+            }
+            case 'ses': {
+                const { createSesProvider } = await import('./providers/ses.js');
+                return createSesProvider(options);
+            }
+            case 'smtp': {
+                const { createSmtpProvider } = await import('./providers/smtp.js');
+                return createSmtpProvider({
+                    host: options.host,
+                    port: options.port,
+                    secure: options.secure,
+                    ...(options.user ? { user: options.user } : {}),
+                    ...(options.password ? { password: options.password } : {}),
+                    connectionTimeout: options.connectionTimeout,
+                    greetingTimeout: options.greetingTimeout,
+                    socketTimeout: options.socketTimeout,
+                });
+            }
+        }
+    }
+    catch (error) {
+        const moduleNotFound = error;
+        if (moduleNotFound?.code === 'ERR_MODULE_NOT_FOUND') {
+            const dependencies = {
+                brevo: '@getbrevo/brevo',
+                mailgun: 'mailgun.js and form-data',
+                postmark: 'postmark',
+                resend: 'resend',
+                sendgrid: '@sendgrid/mail',
+                ses: '@aws-sdk/client-sesv2',
+                smtp: 'nodemailer',
+            };
+            const dependency = dependencies[options.provider];
+            throw new MailError(`Install the optional provider package "${dependency}" to use ${options.provider}.`, 'configuration', options.provider, false, { cause: error });
+        }
+        throw error;
+    }
+}
+export function createMailer(input) {
+    let providerPromise;
+    let closed = false;
+    let closePromise;
+    let activeOperations = 0;
+    let resolveOperationsIdle;
+    const parsedOptions = z
+        .discriminatedUnion('provider', [
+        providerOptions.resend,
+        providerOptions.brevo,
+        providerOptions.postmark,
+        providerOptions.sendgrid,
+        providerOptions.mailgun,
+        providerOptions.ses,
+        providerOptions.smtp,
+    ])
+        .parse(input);
+    const assertOpen = () => {
+        if (closed)
+            throw new MailError('Mailer has been closed.', 'configuration', parsedOptions.provider, false);
+    };
+    const getProvider = () => {
+        assertOpen();
+        providerPromise ??= loadProvider(parsedOptions);
+        return providerPromise;
+    };
+    const runWithProvider = async (operation) => {
+        assertOpen();
+        activeOperations += 1;
+        try {
+            return await operation(await getProvider());
+        }
+        finally {
+            activeOperations -= 1;
+            if (activeOperations === 0) {
+                resolveOperationsIdle?.();
+                resolveOperationsIdle = undefined;
+            }
+        }
+    };
+    return {
+        async send(input) {
+            assertOpen();
+            const parsed = mailInputSchema.parse(input);
+            const normalized = {
+                from: (parsed.from ?? parsedOptions.from),
+                to: (normalizeAddresses(parsed.to) ?? []),
+                subject: parsed.subject,
+                ...(parsed.messageId ? { messageId: parsed.messageId } : {}),
+                ...(parsed.text !== undefined ? { text: parsed.text } : {}),
+                ...(parsed.html !== undefined ? { html: parsed.html } : {}),
+                ...(parsed.headers ? { headers: parsed.headers } : {}),
+                ...(parsed.attachments
+                    ? {
+                        attachments: parsed.attachments.map((item) => ({
+                            filename: item.filename,
+                            content: item.content,
+                            ...(item.contentType ? { contentType: item.contentType } : {}),
+                            ...(item.contentId ? { contentId: item.contentId } : {}),
+                        })),
+                    }
+                    : {}),
+                ...(parsed.idempotencyKey ? { idempotencyKey: parsed.idempotencyKey } : {}),
+                ...(parsed.metadata ? { metadata: parsed.metadata } : {}),
+                ...(normalizeAddresses(parsed.cc)
+                    ? { cc: normalizeAddresses(parsed.cc) }
+                    : {}),
+                ...(normalizeAddresses(parsed.bcc)
+                    ? { bcc: normalizeAddresses(parsed.bcc) }
+                    : {}),
+                ...(parsed.replyTo ? { replyTo: parsed.replyTo } : {}),
+            };
+            try {
+                const result = await runWithProvider((provider) => provider.send(normalized));
+                return {
+                    provider: parsedOptions.provider,
+                    messageId: result.messageId,
+                    acceptedAt: new Date(),
+                };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, parsedOptions.provider, 'send');
+            }
+        },
+        async verifyConnection() {
+            try {
+                await runWithProvider((provider) => provider.verifyConnection());
+            }
+            catch (error) {
+                throw normalizeProviderError(error, parsedOptions.provider);
+            }
+        },
+        async close() {
+            closed = true;
+            closePromise ??= (async () => {
+                if (activeOperations > 0) {
+                    await new Promise((resolve) => {
+                        resolveOperationsIdle = resolve;
+                    });
+                }
+                const provider = await providerPromise?.catch(() => undefined);
+                await provider?.close();
+            })();
+            await closePromise;
+        },
+    };
+}
+export { MailError } from './errors.js';

package/dist/providers/brevo.d.ts

@@ -0,0 +1,4 @@
+import type { MailProvider } from '../types.js';
+export declare function createBrevoProvider(options: {
+    apiKey: string;
+}): MailProvider;

package/dist/providers/brevo.js

@@ -0,0 +1,55 @@
+import { BrevoClient } from '@getbrevo/brevo';
+import { Buffer } from 'node:buffer';
+import { MailError, normalizeProviderError } from '../errors.js';
+import { addressWithName } from '../config.js';
+export function createBrevoProvider(options) {
+    const client = new BrevoClient({ apiKey: options.apiKey });
+    return {
+        async send(input) {
+            try {
+                if (input.messageId) {
+                    throw new MailError('Custom message IDs are only supported by the SMTP adapter.', 'unsupported', 'brevo', false);
+                }
+                if (input.idempotencyKey) {
+                    throw new MailError('Brevo idempotency keys are not supported by this adapter.', 'unsupported', 'brevo', false);
+                }
+                if (input.attachments?.some((attachment) => attachment.contentId)) {
+                    throw new MailError('Inline attachment content IDs are not supported by the Brevo adapter.', 'unsupported', 'brevo', false);
+                }
+                const result = await client.transactionalEmails.sendTransacEmail({
+                    sender: addressWithName(input.from),
+                    to: input.to.map(addressWithName),
+                    subject: input.subject,
+                    ...(input.text !== undefined ? { textContent: input.text } : {}),
+                    ...(input.html !== undefined ? { htmlContent: input.html } : {}),
+                    ...(input.replyTo ? { replyTo: addressWithName(input.replyTo) } : {}),
+                    ...(input.cc ? { cc: input.cc.map(addressWithName) } : {}),
+                    ...(input.bcc ? { bcc: input.bcc.map(addressWithName) } : {}),
+                    ...(input.headers ? { headers: input.headers } : {}),
+                    ...(input.metadata ? { tags: Object.entries(input.metadata).map(([key, value]) => `${key}=${value}`) } : {}),
+                    ...(input.attachments
+                        ? {
+                            attachment: input.attachments.map((attachment) => ({
+                                name: attachment.filename,
+                                content: Buffer.from(typeof attachment.content === 'string' ? attachment.content : Buffer.from(attachment.content)).toString('base64'),
+                            })),
+                        }
+                        : {}),
+                });
+                if (!result.messageId) {
+                    throw new MailError('Brevo accepted no message identifier.', 'provider', 'brevo', false, {
+                        deliveryUnknown: true,
+                    });
+                }
+                return { messageId: result.messageId };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, 'brevo');
+            }
+        },
+        async verifyConnection() {
+            throw new MailError('Brevo connection verification is not exposed by this adapter yet.', 'unsupported', 'brevo', false);
+        },
+        async close() { },
+    };
+}

package/dist/providers/mailgun.d.ts

@@ -0,0 +1,8 @@
+import type { MailProvider } from '../types.js';
+interface MailgunOptions {
+    apiKey: string;
+    domain: string;
+    region: 'us' | 'eu';
+}
+export declare function createMailgunProvider(options: MailgunOptions): MailProvider;
+export {};

package/dist/providers/mailgun.js

@@ -0,0 +1,77 @@
+import { Buffer } from 'node:buffer';
+import FormData from 'form-data';
+import Mailgun from 'mailgun.js';
+import { addressWithName } from '../config.js';
+import { MailError, normalizeProviderError } from '../errors.js';
+export function createMailgunProvider(options) {
+    const mailgun = new Mailgun(FormData);
+    const client = mailgun.client({
+        username: 'api',
+        key: options.apiKey,
+        url: options.region === 'eu' ? 'https://api.eu.mailgun.net' : 'https://api.mailgun.net',
+    });
+    return {
+        async send(input) {
+            try {
+                if (input.messageId || input.idempotencyKey) {
+                    throw new MailError('Mailgun does not support custom message IDs or idempotency keys through this adapter.', 'unsupported', 'mailgun', false);
+                }
+                const content = input.text !== undefined
+                    ? { text: input.text, ...(input.html !== undefined ? { html: input.html } : {}) }
+                    : input.html !== undefined
+                        ? { html: input.html }
+                        : undefined;
+                if (!content) {
+                    throw new MailError('Provide text or HTML content.', 'configuration', 'mailgun', false);
+                }
+                const message = {
+                    from: formatAddress(input.from),
+                    to: input.to.map(formatAddress),
+                    subject: input.subject,
+                    ...content,
+                    ...(input.cc ? { cc: input.cc.map(formatAddress) } : {}),
+                    ...(input.bcc ? { bcc: input.bcc.map(formatAddress) } : {}),
+                    ...(input.replyTo ? { 'h:Reply-To': formatAddress(input.replyTo) } : {}),
+                    ...Object.fromEntries(Object.entries(input.headers ?? {}).map(([key, value]) => [`h:${key}`, value])),
+                    ...Object.fromEntries(Object.entries(input.metadata ?? {}).map(([key, value]) => [`v:${key}`, value])),
+                    ...(input.attachments?.length
+                        ? {
+                            attachment: input.attachments
+                                .filter((attachment) => !attachment.contentId)
+                                .map((attachment) => ({
+                                data: Buffer.from(attachment.content),
+                                filename: attachment.filename,
+                                ...(attachment.contentType ? { contentType: attachment.contentType } : {}),
+                            })),
+                            inline: input.attachments
+                                .filter((attachment) => Boolean(attachment.contentId))
+                                .map((attachment) => ({
+                                data: Buffer.from(attachment.content),
+                                filename: attachment.contentId,
+                                ...(attachment.contentType ? { contentType: attachment.contentType } : {}),
+                            })),
+                        }
+                        : {}),
+                };
+                const response = await client.messages.create(options.domain, message);
+                if (!response.id) {
+                    throw new MailError('Mailgun accepted no message identifier.', 'provider', 'mailgun', false, {
+                        deliveryUnknown: true,
+                    });
+                }
+                return { messageId: response.id };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, 'mailgun');
+            }
+        },
+        async verifyConnection() {
+            throw new MailError('Mailgun does not support connection verification. Send a provider test message instead.', 'unsupported', 'mailgun', false);
+        },
+        async close() { },
+    };
+}
+function formatAddress(address) {
+    const normalized = addressWithName(address);
+    return normalized.name ? `${normalized.name} <${normalized.email}>` : normalized.email;
+}

package/dist/providers/postmark.d.ts

@@ -0,0 +1,4 @@
+import type { MailProvider } from '../types.js';
+export declare function createPostmarkProvider(options: {
+    apiKey: string;
+}): MailProvider;

package/dist/providers/postmark.js

@@ -0,0 +1,57 @@
+import { Buffer } from 'node:buffer';
+import { ServerClient } from 'postmark';
+import { addressWithName } from '../config.js';
+import { MailError, normalizeProviderError } from '../errors.js';
+export function createPostmarkProvider(options) {
+    const client = new ServerClient(options.apiKey);
+    return {
+        async send(input) {
+            try {
+                if (input.messageId || input.idempotencyKey) {
+                    throw new MailError('Postmark does not support custom message IDs or idempotency keys through this adapter.', 'unsupported', 'postmark', false);
+                }
+                const response = await client.sendEmail({
+                    From: formatAddress(input.from),
+                    To: input.to.map(formatAddress).join(','),
+                    Subject: input.subject,
+                    ...(input.text !== undefined ? { TextBody: input.text } : {}),
+                    ...(input.html !== undefined ? { HtmlBody: input.html } : {}),
+                    ...(input.replyTo ? { ReplyTo: formatAddress(input.replyTo) } : {}),
+                    ...(input.cc ? { Cc: input.cc.map(formatAddress).join(',') } : {}),
+                    ...(input.bcc ? { Bcc: input.bcc.map(formatAddress).join(',') } : {}),
+                    ...(input.headers
+                        ? { Headers: Object.entries(input.headers).map(([Name, Value]) => ({ Name, Value })) }
+                        : {}),
+                    ...(input.metadata ? { Metadata: input.metadata } : {}),
+                    ...(input.attachments
+                        ? {
+                            Attachments: input.attachments.map((attachment) => ({
+                                Name: attachment.filename,
+                                Content: Buffer.from(attachment.content).toString('base64'),
+                                ContentType: attachment.contentType ?? 'application/octet-stream',
+                                ContentID: attachment.contentId ?? null,
+                            })),
+                        }
+                        : {}),
+                });
+                if (!response.MessageID) {
+                    throw new MailError('Postmark accepted no message identifier.', 'provider', 'postmark', false, {
+                        deliveryUnknown: true,
+                    });
+                }
+                return { messageId: response.MessageID };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, 'postmark');
+            }
+        },
+        async verifyConnection() {
+            throw new MailError('Postmark does not support connection verification. Send a provider test message instead.', 'unsupported', 'postmark', false);
+        },
+        async close() { },
+    };
+}
+function formatAddress(address) {
+    const normalized = addressWithName(address);
+    return normalized.name ? `${normalized.name} <${normalized.email}>` : normalized.email;
+}

package/dist/providers/resend.d.ts

@@ -0,0 +1,4 @@
+import type { MailProvider } from '../types.js';
+export declare function createResendProvider(options: {
+    apiKey: string;
+}): MailProvider;

package/dist/providers/resend.js

@@ -0,0 +1,59 @@
+import { Resend } from 'resend';
+import { Buffer } from 'node:buffer';
+import { MailError, normalizeProviderError } from '../errors.js';
+import { emailOf } from '../config.js';
+export function createResendProvider(options) {
+    const client = new Resend(options.apiKey);
+    const formatFrom = (address) => {
+        if (typeof address === 'string')
+            return address;
+        return address.name ? `${address.name} <${address.email}>` : address.email;
+    };
+    return {
+        async send(input) {
+            if (input.messageId) {
+                throw new MailError('Custom message IDs are only supported by the SMTP adapter.', 'unsupported', 'resend', false);
+            }
+            const payload = {
+                from: formatFrom(input.from),
+                to: input.to.map(emailOf),
+                subject: input.subject,
+                ...(input.text !== undefined ? { text: input.text } : {}),
+                ...(input.html !== undefined ? { html: input.html } : {}),
+                ...(input.replyTo ? { replyTo: emailOf(input.replyTo) } : {}),
+                ...(input.cc ? { cc: input.cc.map(emailOf) } : {}),
+                ...(input.bcc ? { bcc: input.bcc.map(emailOf) } : {}),
+                ...(input.headers ? { headers: input.headers } : {}),
+                ...(input.attachments
+                    ? {
+                        attachments: input.attachments.map((attachment) => ({
+                            filename: attachment.filename,
+                            content: typeof attachment.content === 'string' ? attachment.content : Buffer.from(attachment.content),
+                            ...(attachment.contentType ? { contentType: attachment.contentType } : {}),
+                            ...(attachment.contentId ? { contentId: attachment.contentId } : {}),
+                        })),
+                    }
+                    : {}),
+                ...(input.metadata ? { tags: Object.entries(input.metadata).map(([name, value]) => ({ name, value })) } : {}),
+            };
+            const options = input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : undefined;
+            const response = options
+                ? await client.emails.send(payload, options)
+                : await client.emails.send(payload);
+            const { data, error } = response;
+            if (error)
+                throw normalizeProviderError(error, 'resend');
+            if (!data?.id) {
+                throw new MailError('Resend accepted no message identifier.', 'provider', 'resend', false, {
+                    deliveryUnknown: true,
+                });
+            }
+            return { messageId: data.id };
+        },
+        async verifyConnection() {
+            // Resend does not expose a side-effect-free credential check in its SDK.
+            throw new MailError('Resend does not support connection verification. Send a provider test message instead.', 'unsupported', 'resend', false);
+        },
+        async close() { },
+    };
+}

package/dist/providers/sendgrid.d.ts

@@ -0,0 +1,4 @@
+import type { MailProvider } from '../types.js';
+export declare function createSendGridProvider(options: {
+    apiKey: string;
+}): MailProvider;

package/dist/providers/sendgrid.js

@@ -0,0 +1,69 @@
+import { Buffer } from 'node:buffer';
+import { MailService } from '@sendgrid/mail';
+import { addressWithName } from '../config.js';
+import { MailError, normalizeProviderError } from '../errors.js';
+export function createSendGridProvider(options) {
+    const client = new MailService();
+    client.setApiKey(options.apiKey);
+    return {
+        async send(input) {
+            try {
+                if (input.messageId || input.idempotencyKey) {
+                    throw new MailError('SendGrid does not support custom message IDs or idempotency keys through this adapter.', 'unsupported', 'sendgrid', false);
+                }
+                const content = input.text !== undefined
+                    ? { text: input.text, ...(input.html !== undefined ? { html: input.html } : {}) }
+                    : input.html !== undefined
+                        ? { html: input.html }
+                        : undefined;
+                if (!content) {
+                    throw new MailError('Provide text or HTML content.', 'configuration', 'sendgrid', false);
+                }
+                const payload = {
+                    from: addressWithName(input.from),
+                    to: input.to.map(addressWithName),
+                    subject: input.subject,
+                    ...content,
+                    ...(input.replyTo ? { replyTo: addressWithName(input.replyTo) } : {}),
+                    ...(input.cc ? { cc: input.cc.map(addressWithName) } : {}),
+                    ...(input.bcc ? { bcc: input.bcc.map(addressWithName) } : {}),
+                    ...(input.headers ? { headers: { ...input.headers } } : {}),
+                    ...(input.metadata ? { customArgs: { ...input.metadata } } : {}),
+                    ...(input.attachments
+                        ? {
+                            attachments: input.attachments.map((attachment) => ({
+                                filename: attachment.filename,
+                                content: Buffer.from(attachment.content).toString('base64'),
+                                ...(attachment.contentType ? { type: attachment.contentType } : {}),
+                                ...(attachment.contentId ? { contentId: attachment.contentId, disposition: 'inline' } : {}),
+                            })),
+                        }
+                        : {}),
+                };
+                const [response] = await client.send(payload);
+                const messageId = getHeader(response.headers, 'x-message-id');
+                if (!messageId) {
+                    throw new MailError('SendGrid accepted no message identifier.', 'provider', 'sendgrid', false, {
+                        deliveryUnknown: true,
+                    });
+                }
+                return { messageId };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, 'sendgrid');
+            }
+        },
+        async verifyConnection() {
+            throw new MailError('SendGrid does not support connection verification. Send a provider test message instead.', 'unsupported', 'sendgrid', false);
+        },
+        async close() { },
+    };
+}
+function getHeader(headers, name) {
+    const header = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name)?.[1];
+    if (typeof header === 'string')
+        return header;
+    if (Array.isArray(header) && typeof header[0] === 'string')
+        return header[0];
+    return undefined;
+}

package/dist/providers/ses.d.ts

@@ -0,0 +1,6 @@
+import type { MailProvider } from '../types.js';
+interface SesOptions {
+    region: string;
+}
+export declare function createSesProvider(options: SesOptions): MailProvider;
+export {};

package/dist/providers/ses.js

@@ -0,0 +1,72 @@
+import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';
+import { addressWithName, emailOf } from '../config.js';
+import { MailError, normalizeProviderError } from '../errors.js';
+export function createSesProvider(options) {
+    const client = new SESv2Client({ region: options.region });
+    return {
+        async send(input) {
+            try {
+                if (input.messageId || input.idempotencyKey) {
+                    throw new MailError('Amazon SES does not support custom message IDs or idempotency keys through this adapter.', 'unsupported', 'ses', false);
+                }
+                const response = await client.send(new SendEmailCommand({
+                    FromEmailAddress: formatAddress(input.from),
+                    Destination: {
+                        ToAddresses: input.to.map(emailOf),
+                        ...(input.cc ? { CcAddresses: input.cc.map(emailOf) } : {}),
+                        ...(input.bcc ? { BccAddresses: input.bcc.map(emailOf) } : {}),
+                    },
+                    ...(input.replyTo ? { ReplyToAddresses: [emailOf(input.replyTo)] } : {}),
+                    ...(input.metadata
+                        ? { EmailTags: Object.entries(input.metadata).map(([Name, Value]) => ({ Name, Value })) }
+                        : {}),
+                    Content: {
+                        Simple: {
+                            Subject: { Data: input.subject, Charset: 'UTF-8' },
+                            Body: {
+                                ...(input.text !== undefined ? { Text: { Data: input.text, Charset: 'UTF-8' } } : {}),
+                                ...(input.html !== undefined ? { Html: { Data: input.html, Charset: 'UTF-8' } } : {}),
+                            },
+                            ...(input.headers
+                                ? { Headers: Object.entries(input.headers).map(([Name, Value]) => ({ Name, Value })) }
+                                : {}),
+                            ...(input.attachments
+                                ? {
+                                    Attachments: input.attachments.map((attachment) => ({
+                                        RawContent: typeof attachment.content === 'string'
+                                            ? new TextEncoder().encode(attachment.content)
+                                            : attachment.content,
+                                        FileName: attachment.filename,
+                                        ContentType: attachment.contentType ?? 'application/octet-stream',
+                                        ContentDisposition: attachment.contentId ? 'INLINE' : 'ATTACHMENT',
+                                        ContentTransferEncoding: 'BASE64',
+                                        ...(attachment.contentId ? { ContentId: attachment.contentId } : {}),
+                                    })),
+                                }
+                                : {}),
+                        },
+                    },
+                }));
+                if (!response.MessageId) {
+                    throw new MailError('Amazon SES accepted no message identifier.', 'provider', 'ses', false, {
+                        deliveryUnknown: true,
+                    });
+                }
+                return { messageId: response.MessageId };
+            }
+            catch (error) {
+                throw normalizeProviderError(error, 'ses');
+            }
+        },
+        async verifyConnection() {
+            throw new MailError('Amazon SES does not support connection verification. Send a provider test message instead.', 'unsupported', 'ses', false);
+        },
+        async close() {
+            client.destroy();
+        },
+    };
+}
+function formatAddress(address) {
+    const normalized = addressWithName(address);
+    return normalized.name ? `${normalized.name} <${normalized.email}>` : normalized.email;
+}

package/dist/providers/smtp.d.ts

@@ -0,0 +1,13 @@
+import type { MailProvider } from '../types.js';
+interface SmtpOptions {
+    host: string;
+    port: number;
+    secure: boolean;
+    user?: string;
+    password?: string;
+    connectionTimeout: number;
+    greetingTimeout: number;
+    socketTimeout: number;
+}
+export declare function createSmtpProvider(options: SmtpOptions): MailProvider;
+export {};