Como enviar e-mails com Node.js usando SendGrid

A seguir, escreveremos o seguinte código para testar se podemos enviar e-mails com SendGrid:

 const sendGridMail=require ('@ sendgrid/mail');
sendGridMail.setApiKey (process.env.SENDGRID_API_KEY); function getMessage () { const body='Este é um e-mail de teste usando SendGrid do Node.js'; Retorna { para:'[email protected]', de:'[email protected]', assunto:'Testar e-mail com Node.js e SendGrid', texto: corpo, html: ` $ {body} `, };
} função assíncrona sendEmail () { tentar { aguarde sendGridMail.send (getMessage ()); console.log ('Email de teste enviado com sucesso'); } catch (erro) { console.error ('Erro ao enviar e-mail de teste'); console.error (erro); if (error.response) { console.error (error.response.body) } }
} (assíncrono ()=> { console.log ('Enviando e-mail de teste'); aguarde sendEmail ();
}) ();

Vamos revisar rapidamente o que o código acima está fazendo.

Em primeiro lugar, estamos incluindo o pacote @ sendgrid/mail e, em seguida, definimos a chave API da variável de ambiente.

Depois disso, temos uma função getMessage que constrói a mensagem de e-mail contendo para, de, assunto e corpo em formato de texto e HTML.

A seguir, adicionamos a função sendEmail , que obtém a mensagem e envia o e-mail usando o método send no pacote de e-mail SendGrid. Ele está envolvido em um try... catch para que possamos registrar quaisquer erros em potencial. Se for bem-sucedido, imprimimos um log dizendo Email de teste enviado com sucesso .

Está tudo colado com um ES8 assíncrono IIFE (expressão de função imediatamente invocada) para fazer tudo funcionar. Eu salvei como send-test-email.js na raiz do projeto.

Abaixo está uma captura de tela de como podemos executá-lo com node send-test-email.js :

Depois de alguns segundos, vi o e-mail na minha caixa de entrada:

Nesse momento, podemos ir para a página Atividade de e-mail no SendGrid e pesquisar pelo Para o endereço de e-mail . Veremos que o e-mail foi enviado e aberto, conforme mostrado abaixo:

Viva! Nossa prova de conceito está funcionando. Você pode ver todas as alterações de código feitas até este ponto na solicitação pull . Agora, vamos transformá-lo em uma API que podemos chamar para qualquer e-mail de transação. A título de exemplo, enviaremos um e-mail de confirmação do pedido.

Crie a API de envio de e-mail de confirmação de pedido

Para um exemplo mais prático da vida real, criaremos agora uma API de envio de e-mail de confirmação de pedido. Esta API será chamada sempre que um usuário fizer um pedido com sucesso. Digamos que tenhamos um método de salvamento de pedido que faz quatro coisas:

Nossa chamada de API de envio de confirmação de pedido seria chamada depois que o pedido do cliente fosse salvo com sucesso no armazenamento de dados.

Para transformar nosso script de teste em uma API, precisaremos de um framework web; para isso, usaremos Express.js. Para instalar Express.js, execute o seguinte na raiz do projeto:

 npm i-salvar expresso 

Em seguida, adicionaremos dois arquivos: index.js , o servidor web; e email.js , o serviço para enviar o e-mail. O arquivo index.js está abaixo:

 const express=require ('express');
const email=require ('./email'); const app=express ();
porta const=3000 || process.env.PORT; app.use (express.json ());
app.use (express.urlencoded ({extended: false})); app.get ('/', (req, res)=> { res.json ({mensagem:'vivo'});
}) app.post ('/api/email/order-confirmation', async (req, res, next)=> { tentar { res.json (await email.sendOrderConfirmation (req.body)); } catch (errar) { próximo (errar); }
}); app.use ((err, req, res, próximo)=> { const statusCode=err.statusCode || 500; console.error (err.message, err.stack); res.status (statusCode).json ({'mensagem': err.message}); Retorna;
}); app.listen (porta, ()=> { console.log (`Exemplo de API ouvindo em http://localhost: $ {port}`)
});

Vamos examinar algumas das partes principais do servidor da web Express acima.

Primeiro, precisamos do Express e inicializá-lo. Em seguida, usamos middlewares codificados por JSON e URL para nos permitir aceitar dados para o endpoint POST para o e-mail de confirmação do pedido.

Depois disso, criamos uma rota / que mostrará uma mensagem como alive . A seguir, temos o cerne da questão, onde definimos uma API POST em /api/email/order-confirmation . Isso chama o método sendOrderConfirmation no módulo email que definiremos mais tarde.

Posteriormente, vemos um middleware de manipulador de erros básico que pode lidar com quaisquer erros lançados nas rotas acima. Por fim, iniciamos o servidor com app.listen e registramos que o servidor foi iniciado.

A seguir, veremos como nosso arquivo email.js é escrito. Usei o plano gratuito Stripo.email para gerar o e-mail de confirmação de pedido simulado; faz parte do modelo fornecido. Abaixo está nosso arquivo email.js , que compila o e-mail e o envia usando SendGrid:

 const sendGridMail=require ('@ sendgrid/mail');
sendGridMail.setApiKey (process.env.SENDGRID_API_KEY); function getOrderConfirmationEmailHtml (customerName, orderNr) { return `                    96        
    
 
Put your preheader text here
 
 
SEE THIS EMAIL ONLINE
 
 
 
 
Your order is confirmed. 
 
Hi ${customerName}, we've received order № ${orderNr} and are working on it now.
We'll email you an update when we've shipped it.
 
View your order details
 
 
 
`;
} function getMessage(emailParams) { Retorna { to: emailParams.toEmail, from:'[email protected]', subject:'We have got your order, you will receive it soon', text: `Hey ${emailParams.name}, we have received your order ${emailParams.orderNr}. We will ship it soon`, html: getOrderConfirmationEmailHtml(emailParams.name, emailParams.orderNr), };
} async function sendOrderConfirmation(emailParams) { try { await sendGridMail.send(getMessage(emailParams)); return { message: `Order confirmation email sent successfully for orderNr: ${emailParams.orderNr}`}; } catch (error) { const message=`Error sending order confirmation email or orderNr: ${emailParams.orderNr}`; console.error(message); console.error(error); if (error.response) { console.error(error.response.body) } return {message}; }
} module.exports={ sendOrderConfirmation
}

Let’s take a deeper look at what email.js is doing.

First we include the sendGrid mail module and add the API key to it. After that, we see a long function getOrderConfirmationEmailHtml, which has the HTML template of our order confirmation email. It takes in two variables, customerName and orderNr, that are filled in dynamically.

Next, we have a getMessage method that puts together the email message with to, from, subject, text, and HTML body. The HTML body is pulled in from the above getOrderConfirmationEmailHtml method.

Consequently, we have the async sendOrderConfirmation function that glues everything together with error handling. Here, we call the send method on the sendGridMail module passing the correct parameters we get from the getMessage function.

If all goes well, we respond back with a positive message inside an object. If there are any errors, we log them and respond back with an error message to the caller, which in this case is the route.

Only the sendOrderConfirmation is exposed from this module at the end of the email.js file.

After we have set up both files correctly, we can start the server with node index.js, which will show us something like the below:

Now, we can test our order confirmation email API with the following cURL command:

curl-i-X POST-H'Accept: application/json'\ -H'Content-type: application/json'http://localhost:3000/api/email/order-confirmation \ --data'{"name":"YourName","orderNr":"12344","toEmail":"[email protected]"}'

If everything goes well with the cURL command, we will see a 200 response like below:

Then, we should be able to see that email in our inbox, too:

Congratulations! Our basic order confirmation email is working. As seen above, the two parameters — the customer’s name and order number — are dynamically placed in the email. All the code in this step with the Express.js web server is available in this pull request.

I know the HTML template for the email is a bit too long; we can replace it by using SendGrid’s Dynamic templates. This guide shows how to use it.

Scalability considerations

Depending on how many orders you get in a day, you might want to scale your email sending task. To do this, we mainly have two options.

The first is to use a queue system like RabbitMQ. Whenever a user successfully places an order, a producer will send a message to an exchange, which will be placed in one or more queues depending on the configuration.

Consumers would constantly listen to the queue and process the messages as they land in the queue. We can scale this approach by increasing the number of consumers as the number of messages grows.

Another low-maintenance way to scale the email sending task would be to use a serverless FaaS (function-as-a-service) — something like AWS Lambda or Vercel — to deploy our mini email sending service. The order placement logic can call this API in an async way so that even if the call fails, it is still OK.

The scalability here is handled by AWS, and as the resources are allocated per request, we don’t need to worry about resources, either. The cost factor might come into play if the scale is really big. I will leave further exploration on this topic to you. You may even find free Node.js hosting options that meet your needs.

Conclusão

We have seen how to send emails with Node.js using SendGrid in this step-by-step guide. The order confirmation is just one of many transactional emails we can send. If the email system is set up correctly and templates are dynamic, sending emails becomes a breeze with Node.js and SendGrid.

The post How to send emails with Node.js using SendGrid appeared first on LogRocket Blog.

Source link