Integrar diferentes gateways de pagamento em uma aplicação pode ser uma tarefa complexa devido às várias APIs e suas peculiaridades. Utilizando o padrão de projeto Adapter, podemos criar uma interface unificada para diferentes serviços de pagamento, facilitando a manutenção e a expansão do sistema.
Neste artigo vamos explorar como integrar um gateway de pagamento utilizando Node.js e Fastify. Aqui, você vai aprender a gerar cobranças PIX usando a API da Woovi e muito mais.
Esse artigo faz parte das aulas do CrazyStack Node.js, onde criamos do zero uma API REST usando Node.js e Fastify. O começo do tutorial está nesse vídeo AQUI
Estrutura do Projeto
Vamos estruturar o projeto de forma que cada gateway tenha sua própria implementação, mas todas compartilhem um contrato comum. Usaremos TypeScript para garantir a tipagem estática e a segurança do código.
Diretórios e Arquivos
src/
contracts/
PaymentGateway.ts
adapters/
WooviAdapter.ts
StripeAdapter.ts
PagarmeAdapter.ts
index.ts
config/
env.ts
Contrato de Gateway de Pagamento
Primeiro, definimos um contrato que todos os gateways de pagamento devem implementar. Isso garante que todos os gateways possuam as mesmas funções com a mesma assinatura.
export abstract class PaymentGateway {
abstract createCharge(data: any): Promise<any>;
abstract deleteCharge(id: string): Promise<any>;
abstract getCharge(id: string): Promise<any>;
abstract createSubscription(data: any): Promise<any>;
abstract getSubscription(id: string): Promise<any>;
abstract createCustomer(data: any): Promise<any>;
abstract getCustomer(id: string): Promise<any>;
abstract getChargeByCustomer(data: any): Promise<any>;
}
Adapters para Gateways de Pagamento
Woovi Payment Gateway
A implementação do adapter para Woovi usa a biblioteca axios para realizar chamadas HTTP.
import axios from “axios“;
import { PaymentGateway } from “../contracts“;
import { env } from “../config“;
export class WooviPaymentGateway extends PaymentGateway {
private apiKey: string;
constructor(paymentKey: string) {
super();
this.apiKey = paymentKey;
}
async deleteCharge(id: string): Promise<any> {
try {
const response = await axios.delete(
`https://api.openpix.com.br/api/v1/charge/${id}`,
{
headers: { Authorization: this.apiKey },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getCharge(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.openpix.com.br/api/v1/charge/${id}`,
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async createCharge(data: any): Promise<any> {
const { correlationID, value, comment } = data;
try {
const { data } = await axios.post(
“https://api.openpix.com.br/api/v1/charge?return_existing=true“,
{ correlationID, value, comment },
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return data;
} catch (e: any) {
return e?.response?.data;
}
}
async createSubscription(body: any): Promise<any> {
try {
const { data } = await axios.post(
“https://api.openpix.com.br/api/v1/subscriptions“,
body,
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return data;
} catch (e: any) {
return e?.response?.data;
}
}
async getSubscription(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.openpix.com.br/api/v1/subscriptions/${id}`,
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async createCustomer(body: any): Promise<any> {
try {
const { data } = await axios.post(
“https://api.openpix.com.br/api/v1/customer“,
body,
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return data;
} catch (e: any) {
return e?.response?.data;
}
}
async getCustomer(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.openpix.com.br/api/v1/customer/${id}`,
{
headers: { Authorization: this.apiKey, “content-type“: “application/json“ },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getChargeByCustomer(correlationID: string): Promise<any> {
try {
const response = await axios.get(
`https://api.openpix.com.br/api/v1/charge?customer=${correlationID}&status=ACTIVE`,
{
headers: { Authorization
: this.apiKey, “content-type“: “application/json“ },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
}
export const makeWooviAdapter = () => {
return new WooviPaymentGateway(env.wooviKey);
};
Stripe Payment Gateway
Para o Stripe, usamos o SDK oficial stripe.
import { PaymentGateway } from “../contracts“;
import { env } from “../config“;
import Stripe from “stripe“;
export class StripePaymentGateway extends PaymentGateway {
private stripe: Stripe;
constructor(paymentKey: string) {
super();
this.stripe = new Stripe(paymentKey, {
apiVersion: “2023-10-16“,
typescript: true,
});
}
async createPrice(amount: number): Promise<any> {
try {
const price = await this.stripe.prices.create({
currency: “brl“,
unit_amount: amount,
recurring: { interval: “month“ },
product_data: { name: “Gold Plan“ },
});
return { price };
} catch (e: any) {
return e?.response?.data;
}
}
async createSubscription(data: any): Promise<any> {
try {
const subscription = await this.stripe.subscriptions.create({
customer: data?.customer?.id ?? data?.customer?.correlationID,
items: [{ price: data?.priceId }],
});
return { subscription };
} catch (e: any) {
return e?.response?.data;
}
}
async getSubscription(id: string): Promise<any> {
try {
const subscription = await this.stripe.subscriptions.retrieve(id);
return { subscription };
} catch (e: any) {
return e?.response?.data;
}
}
async deleteCharge(id: string): Promise<any> {
try {
const charge = await this.stripe.paymentIntents.update(id, {
metadata: { status: “canceled“ },
});
return { charge, status: “OK“ };
} catch (e: any) {
return e?.response?.data;
}
}
async getCharge(id: string): Promise<any> {
try {
const charge = await this.stripe.paymentIntents.retrieve(id);
return { charge };
} catch (e: any) {
return e?.response?.data;
}
}
async createCharge(data: any): Promise<any> {
try {
const charge = await this.stripe.paymentIntents.create({
amount: Number(data?.value),
currency: “brl“,
metadata: { metadata: JSON.stringify(data) },
automatic_payment_methods: { enabled: true },
});
return { charge };
} catch (e: any) {
return e?.response?.data;
}
}
async createCustomer(data: any): Promise<any> {
const { email, description } = data;
try {
const customer: Stripe.Customer = await this.stripe.customers.create({
description,
email,
});
return { customer };
} catch (e: any) {
return e?.response?.data;
}
}
async getCustomer(id: string): Promise<any> {
try {
const customer = await this.stripe.customers.retrieve(id);
return { customer };
} catch (e: any) {
return e?.response?.data;
}
}
}
export const makeStripeAdapter = () => {
return new StripePaymentGateway(env.stripeKeySecret);
};
Pagar.me Payment Gateway
A implementação para Pagar.me também utiliza axios para chamadas HTTP.
import axios from “axios“;
import { PaymentGateway } from “../contracts“;
import { env } from “../config“;
export class PagarmePaymentGateway extends PaymentGateway {
private apiKey: string;
constructor(paymentKey: string) {
super();
this.apiKey = paymentKey;
}
async createCharge(data: any): Promise<any> {
try {
const response = await axios.post(
“https://api.pagar.me/1/transactions“,
data,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async deleteCharge(id: string): Promise<any> {
try {
const response = await axios.delete(
`https://api.pagar.me/1/transactions/${id}`,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getCharge(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.pagar.me/1/transactions/${id}`,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async createSubscription(data: any): Promise<any> {
try {
const response = await axios.post(
“https://api.pagar.me/1/subscriptions“,
data,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getSubscription(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.pagar.me/1/subscriptions/${id}`,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async createCustomer(data: any): Promise<any> {
try {
const response = await axios.post(
“https://api.pagar.me/1/customers“,
data,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getCustomer(id: string): Promise<any> {
try {
const response = await axios.get(
`https://api.pagar.me/1/customers/${id}`,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
async getChargeByCustomer(correlationID: string): Promise<any> {
try {
const response = await axios.get(
`https://api.pagar.me/1/transactions?customer=${correlationID}`,
{
headers: { Authorization: `Bearer ${this.apiKey}` },
}
);
return response?.data;
} catch (e: any) {
return e?.response?.data;
}
}
}
export const makePagarmeAdapter = () => {
return new PagarmePaymentGateway(env.pagarmeKey);
};
Conclusão
Implementar gateways de pagamento utilizando o padrão Adapter em TypeScript facilita a integração e a manutenção do código. Ao seguir esta abordagem, você garante flexibilidade e modularidade no seu sistema, podendo facilmente adicionar ou substituir gateways conforme necessário.
Para uma compreensão mais detalhada e prática de como implementar um gateway de pagamento com Node.js e Fastify, assista ao nosso vídeo tutorial completo na Aula 99 do CrazyStack Node.js. Não perca essa oportunidade de aprofundar seu conhecimento e dominar as melhores práticas de desenvolvimento de sistemas de pagamento.
🔗 Links Importantes:
Curso CrazyStack TypeScript: crazystack.com.br
🔔 Não se esqueça de se inscrever no canal e ativar as notificações para não perder nenhum vídeo!
Link do curso no udemy:
https://www.udemy.com/course/nextjs-avancado-atomic-design/
Link da branch criada na aula:
https://github.com/gumiranda/CrazyStackNodeJs/tree/aula99
Link do repositório oficial:
https://github.com/gumiranda/CrazyStackNodeJs
O CrazyStack é um treinamento online, totalmente prático e intensivo, no formato de bootcamp. Durante o desenvolvimento de um sistema completo de agendamentos online, o aluno aprende de maneira avançada todo o ecossistema da tecnologia NodeJS usando Mongo DB e Fastify.
O curso não é gravado por um programador comum usando sua própria voz normal. Ao longo de cada vídeo você será envolvido pela voz de grandes personagens brasileiros da nossa cultura popular como Faustão, Silvio Santos, Serjão Berranteiro e vários outros.
O Bootcamp do DevDoido é um curso sem duração definida por ser incrementado continuamente com base em um único projeto. Continuamente teremos conteúdo publicado, a ideia é ter um curso em constante evolução e término indeterminado. Quanto mais cedo você comprar o curso mais ele irá valorizar ao longo do tempo, pois mais conteúdo vai sendo adicionado. O acesso ao curso é vitalício, sem turmas e sem restrições de tempo ou número de alunos, proporcionando assim um belíssimo investimento a longo prazo podendo ser concluído a qualquer tempo.
O curso coloca em prática conteúdos avançados como: Design Patterns, Clean Vertical Sliced Architecture, TDD e DDD, Testes unitários e de integração desenvolvendo aplicações reais e extensas, sendo necessário do aluno uma base sólida em lógica de programação, orientação a objetos e um domínio no uso da linguagem JavaScript.
Com foco no público pleno/sênior, o curso surgiu de um desejo ardente em compartilhar conhecimento avançado o suficiente para evoluir a forma como você escreve código. Concluindo o módulo Node.js você será capaz de criar e melhorar uma extensa base de código, além de poder transformá-la em um novo negócio usando cada feature desenvolvida. Tudo o que cursos comuns básicos e intermediários não conseguem oferecer atualmente.
Com muita dedicação e sabedoria você será capaz de enxergar o verdadeiro poder de saber programar um código limpo e legível. E o que é possível lançar ao mundo quando se tem o conhecimento necessário nas mãos.
