Enviando e -mail usando o Node.js – SitePoint

Takeaways -chave

• O NodeMailer é o módulo NPM mais popular para enviar e -mails dos aplicativos Node.js, com mais de três milhões de downloads por semana. Requer um servidor SMTP para enviar emails.
• A criação de e -mails HTML para diferentes clientes de email pode ser um desafio devido a vários mecanismos de renderização e limitações. Ferramentas e recursos como modelos pré-criados, ferramentas de design e linguagens de marcação por e-mail podem simplificar o processo.
• Para garantir a confiabilidade, é recomendável enviar dados de email para uma fila de tarefas em vez de enviar e -mails diretamente no aplicativo Node.js. Isso permite que o usuário continue usando o aplicativo enquanto o email está sendo processado.
• A leitura de e -mails recebidos nos aplicativos Node.js é possível usando módulos como o IMAPFlow. Isso pode ser útil para lidar com o registro de serviços, solicitações de cancelamento de inscrição, suporte automatizado e muito mais.

A maioria dos aplicativos da Web precisa enviar email. Pode ser para registro, redefinições de senha, relatórios de status, embora para campanhas de marketing completas, como boletins e promoções. Este tutorial explica como enviar email no Node.js, mas os conceitos e desafios se aplicam aos sistemas que você está usando.

Você encontrará muitos módulos relacionados a e-mails em npm. O mais popular é NodeMailerque recebe mais de três milhões de downloads toda semana.

Para usá -lo, você precisará de um servidor SMTP que possa enviar email. Você pode usar seu próprio provedor de e -mail, mas, para os fins desta demonstração, estou usando o grátis Servidor SMTP de teste wpoven.

Crie uma nova pasta do projeto:

mkdir emailtest
cd emailtest

Em seguida, crie um novo package.json Arquivo com o seguinte conteúdo JSON:

{
  "name": "emailtest",
  "type": "module",
  "main": "index.js",
  "dependencies": {
    "nodemailer": "^6.0.0"
  }
}

Instale os módulos (NodeMailer):

npm install

e crie o seguinte index.js código:

import nodemailer from 'nodemailer';

const transporter = nodemailer.createTransport({
  host: 'smtp.freesmtpservers.com',
  port: 25
});

try {

  const send = await transporter.sendMail({
    from: '"Test Email" ',  
    to: 'someone@example.com',              
    subject: 'Hello!',                      
    text: 'Hello world!',                   
    html: '
Hello world!
',            
  });

  console.dir(send, { depth: null, color: true });

}
catch(e) {

  console.dir(e, { depth: null, color: true });

}

(Considere mudar o to: Endereço para algo único para que você possa examinar seus próprios e -mails de teste!)

Execute o código. Você deve ver um resultado com um 250 OK response e a messageId:

$ node index.js
{
  accepted: ( 'someone@example.com' ),
  rejected: (),
  ehlo: ( 'SIZE 33554432', '8BITMIME', 'SMTPUTF8', 'HELP' ),
  envelopeTime: 486,
  messageTime: 289,
  messageSize: 595,
  response: '250 OK',
  envelope: {
    from: 'test@email.com',
    to: ( 'someone@example.com' )
  },
  messageId: '<4673597e-a9e4-e422-85f7-4422edf31774@email.com>'
}

Verifique a caixa de entrada do to: endereço que você usou inserindo -o no Página do servidor SMTP de teste wpoven e clicando Caixa de entrada de acesso. Clique no “Olá!” mensagem para examinar o conteúdo.

NodeMailer Basics

Para enviar e -mails, você deve criar um noilador transportador Objeto de definir o tipo de serviço. SMTP é mais comum, mas outros estão disponíveis Para serviços alternativos. Geralmente é necessário um ID de usuário e a senha de autenticação:

import nodemailer from 'nodemailer';

const transporter = nodemailer.createTransport({
  host: 'smtp.yourserver.com',
  port: 587,
  auth: {
    user: 'myid@yourserver.com',
    pass: 'my-password'
  },
});

Você pode enviar e -mails para um ou mais destinatários usando o transportador sendMail() método:

const send = await transporter.sendMail({
  from: '"Test Email" ',          
  to: 'someone@example.com, sometwo@example.com', 
  cc: 'somethree@example.com',
  bcc: 'somefour@example.com',
  subject: 'Hello!',                              
  text: 'Plain text version of the message',      
  html: '
HTML version of the message
',     
});

Todos os clientes de email suportam mensagens de texto simples. Você também pode enviar uma versão rica da mesma mensagem usada quando o cliente de email suporta HTML (mais sobre isso abaixo).

NodeMailer fornece bastante Outras opções de mensagensmas o mais comum é anexos. Uma variedade de objetos define nomes de arquivos e conteúdo. Por exemplo:

const send = await transporter.sendMail({
  
  attachments: (
    { 
      filename: 'text1.txt',
      path: '/path/to/file1.txt'
    },
    {  
      filename: 'text2.txt',
      path: 'https://myserver.com/text2.txt'
    },
    { 
      filename: 'text3.txt',
      content: 'This is the file content!'
    },
    { 
      filename: 'text4.txt',
      path: 'data:text/plain;base64,SGVsbG8gd29ybGQh'
    }
  )
});

Envio de serviços

É fácil enviar e-mails únicos simples, mas não subestime o desafio à medida que seus requisitos evoluem.

1. Você pode não ter um servidor SMTP. Nem todos os serviços de email fornecem SMTP (o Google é Retirando o suporte básico de SMTP no Gmail).

2. A maioria dos serviços limita os e -mails de saída. Se você estiver enviando muitos e -mails, poderá atingir o limite do seu provedor. Nesse ponto, todos os e -mails que passam pelo mesmo serviço fracassarão: esse é o seu boletim informativo e mensagens pessoais e comerciais.

3. Você pode se tornar um spammer. É fácil para os destinatários marcar seu e -mail como “lixo” – mesmo quando não é. Quando um número suficiente de pessoas faz isso, você pode descobrir que todos os e -mails do seu domínio ficam bloqueados na Internet.

É melhor usar um serviço de email dedicado em vez do seu próprio servidor de email. Os serviços a seguir reduzem os problemas em potencial e alguns oferecem planos gratuitos para aqueles com baixos requisitos de uso:

Arquitetura de aplicativos assíncronos

Enviar um único e -mail geralmente é rápido, mas:

• O servidor SMTP pode estar diminuindo para que as tentativas sejam necessárias, ou
• A mensagem pode ser pega no meio de uma postagem de boletim informativo em massa

Em vez de enviar e -mails diretamente no seu aplicativo Node.js, geralmente é melhor enviar os dados para um fila de tarefas. O usuário final não precisa esperar por uma resposta e pode continuar a usar o aplicativo.

Outro processo pode monitorar a fila de email, enviar a próxima mensagem e requer itens quando ocorrer uma falha.

Criação de e -mails HTML

HTML5 e CSS3 funcionam consistentemente bem nos navegadores modernos. Os clientes de email são outro assunto, levando -nos de volta aos frustrantes dias dos dias dos anos 90 de tabelas e estilos em linha.

Estes são alguns dos problemas que você enfrentará:

• Existem dezenas de clientes de email nativos e baseados na Web, incluindo Gmail, Yahoo Mail, Apple Mail, iOS Mail, Android Mail, Windows Mail, Outlook, Outlook.com, (novo) Outlook, Thunderbird, AOL, Garws, Roundcube e, portanto, assim sobre.

• Todos usam seus próprios motores de renderização estranhos e maravilhosos com problemas e bugs únicos. Um pouco bizarramente, o Outlook usou o Microsoft Word para renderizar HTML desde 2007 (embora a nova versão de visualização seja baseada no navegador).

• A maioria dos clientes bloqueia ou limita fontes, imagens, rastreadores, consultas de mídia, iframes, vídeos, áudio, formulários e scripts.

• Mesmo os clientes de email baseados na Web em execução no navegador devem remover HTML, CSS e JavaScript que são perigosos ou que podem afetar o layout da interface do usuário. Por exemplo, não deve ser possível para um email clicar automaticamente seus próprios links ou posicionar absolutamente um elemento sobre um botão de exclusão.

• Os clientes de email podem reformar seu HTML para garantir que seja uma única coluna ou adere às preferências do modo claro/escuro do usuário.

É possível Código de mão HTML E-mails Mas, a menos que seu layout seja simples, é difícil, frustrante e propenso a erros. As seções a seguir sugerem ferramentas e recursos que podem facilitar sua vida.

Modelos de e-mail pré-criados

Os sites a seguir fornecem modelos de e -mail robustos gratuitos e comerciais que você pode visualizar, baixar e usar com o mínimo esforço:

Ferramentas de design de modelo de e -mail

As seguintes ferramentas de design sem código permitem criar seus próprios modelos de e-mail HTML usando um editor Wyswyg mais simples:

Alguns desses serviços também fornecem instalações de validação e teste de código.

Conversão de modelo de email

Preparador é uma ferramenta da Web que pega um URL da página ou código-fonte colado e o transforma em modelos de texto HTML e texto sem formatação compatíveis por email. Há um Rest API e Node.js premailer-api módulo Se você precisar automatizar o processo.

Ferramentas semelhantes incluem:

Ferramentas de marcação de modelo de e -mail

CerberusAssim, Estrutura de emailAssim, Esqueleto de e -maile Bom código de e -mail Forneça trechos de componentes HTML que você pode copiar e adaptar em seus próprios modelos.

Heml e Mjml são idiomas de marcação por e -mail. Eles são semelhantes ao HTML, mas impedem problemas de compatibilidade típicos. Maizizle adota uma abordagem semelhante usando Tailwind CSS.

Parcela é um editor de código que entende a formatação de email e pode mostrar visualizações. Você também encontrará muito Extensões de email para o código VS.

Caniemail.com é o equivalente de email da página da web caniuse.com e relata se um recurso HTML ou CSS específico é utilizável em vários clientes. Finalmente, Email acessível fornece recursos e links associados.

Ferramentas de teste de email

Embora um email HTML possa funcionar em seus próprios aplicativos de e -mail, você pode ter certeza de que ele funciona em outras pessoas? As ferramentas a seguir ajudarão, mas não há substituto para testar uma variedade de dispositivos reais, sistemas operacionais e e -mails.

Verificação de email em HTML e MailTrap Validar seu código -fonte e relatar problemas que você pode encontrar em clientes específicos.

EmailPreviewAssim, Mailosaure Serviços de visualização por e -mail Forneça instalações de visualização de layout para que você possa verificar como seu design parecerá uma variedade de clientes.

Finalmente, Tornassus e E -mail em ácido Tenha uma variedade de ferramentas para validar o código, verificar a acessibilidade, visualizar entre clientes, registrar análises e executar campanhas de marketing completas.

Aprenda a codificar e -mails da maneira certa

Como vimos acima, existem muitas ferramentas que podem ajudá -lo a criar layouts de email que funcionam nos muitos clientes de e -mail. Mas não há nada como entender como codificar sozinho, especialmente quando você precisa resolver os bugs inevitáveis ​​que surgem.

Se você quiser aprender os meandros da codificação por e -mail (mesmo que seja apenas como um backup), confira Criação de e -mail HTMLpor Rémi Parmentier. Ele abrange perspectivas modernas sobre a construção de seus próprios modelos de e -mail, práticas recomendadas essenciais, como adicionar interatividade aos e -mails e como tornar seus modelos acessíveis. Até o leva a um estudo de caso para ver tudo isso na prática.

Lendo e -mail recebido

A maioria dos aplicativos precisa apenas enviar e -mails, mas pode haver ocasiões em que você deseja examinar e -mails recebidos – para itens como registro de serviço, contratação de inscrição, suporte automatizado e assim por diante. Embora esteja além do escopo deste tutorial, módulos Node.js IMAPFLOW Permita que seu aplicativo se conecte a uma caixa de entrada IMAP, busque mensagens e processe uma resposta:

import ImapFlow from 'imapflow';

const client = new ImapFlow({
    host: 'imap.email',
    port: 993,
    secure: true,
    auth: {
        user: 'account@imap.email',
        pass: 'mypassword'
    }
});

try {

  
  await client.connect();

  
  const lock = await client.getMailboxLock('INBOX');

  
  const msg = await client.fetchOne(client.mailbox.exists, { source: true });
  console.log( msg.source.toString() );

  
  lock.release();

  
  await client.logout();

}
catch (e) {
  console.log(e);
}

Conclusão

O envio de e -mails do Node.JS Web Apps é fácil. Enviar e -mails que parecem bons, trabalham de maneira confiável em todos os clientes de email, não interrompem o usuário e não causam problemas de spam pode ser consideravelmente mais difícil.

Eu recomendo que você mantenha e -mails simples para começar, talvez optando por mensagens de texto simples pouco frequentes. Obviamente, seus clientes e departamento de marketing em breve desejam cores e animações sofisticadas, mas você pode entregar isso amanhã!

Perguntas frequentes (perguntas frequentes) sobre o envio de e -mails usando o node.js

let mailOptions = {
from: 'sender@example.com',
to: 'receiver@example.com',
subject: 'Hello',
text: 'Hello world',
attachments: (
{
filename: 'file.txt',
path: '/path/to/file.txt'
}
)
};

let mailOptions = {
from: 'sender@example.com',
to: 'receiver@example.com',
subject: 'Hello',
html: ''
};

let mailOptions = {
from: 'sender@example.com',
to: 'receiver1@example.com, receiver2@example.com',
subject: 'Hello',
text: 'Hello world'
};

transporter.sendMail(mailOptions, function(error, info){
if (error) {
console.log(error);
} else {console.log('Email sent: ' + info.response);
}
});

let transporter = nodemailer.createTransport({
host: 'smtp.gmail.com',
port: 587,
auth: {
user: 'your-email@gmail.com',
pass: 'your-password'
}
});

transporter.sendMail(mailOptions)
.then(info => console.log('Email sent: ' + info.response))
.catch(error => console.log(error));

let transporter = nodemailer.createTransport({
host: 'smtp.example.com',
port: 587,
auth: {
user: 'username',
pass: 'password'
}
});

let mailOptions = {
from: 'sender@example.com',
to: 'receiver@example.com',
subject: 'Hello',
text: 'Hello world',
charset: 'UTF-8'
};

let mailOptions = {
from: 'sender@example.com',
to: 'receiver@example.com',
subject: 'Hello',
text: 'Hello world'
contentType: 'text/plain
};

let mailOptions = {
from: 'sender@example.com',
to: 'receiver@example.com',
subject: 'Hello',
text: 'Hello world',
encoding: 'base64'
};