Currency conversion async

Introduction

Hi dear reader! This is one more project I did to practice a few technologies, so you'll see NestJS, NextJS, SQS, Tests, and MongoDB, all exciting technologies! I'm sure you'll enjoy this post and project as much as I did. Let's start!

Overview

The project

• Use this API for the conversions: https://apilayer.com/marketplace/currency_data-api;

• Use https://mailtrap.io for examples of sending;

• All orders must be saved inside a non-relational database;

Technologies and strategy 🗺

• NextJS
• SQS

• NestJS
• MongoDB
• SQS

Project Repository

nestjs-tests-lab/currency-conversion-async at master · henriqueweiand/nestjs-tests-lab

Contribute to henriqueweiand/nestjs-tests-lab development by creating an account on GitHub.

https://github.com/henriqueweiand/nestjs-tests-lab/tree/master/currency-conversion-async

Technical implementations 🧙‍♂️

backend ⚙️

Best Way to Structure Your Directory/Code (NestJS)

I’ve been building apps using NestJS for quite a while now and I want to share the best way to structure your directory/code with other…

https://medium.com/the-crowdlinker-chronicle/best-way-to-structure-your-directory-code-nestjs-a06c7a641401

backend
├── .docker
├── .github
│ └── workflows
├── localstack
├── scripts
└── src
├── config
│ ├── aws
│ ├── database
│ ├── mail
│ └── queue
├── models
│ └── orders
├── providers
│ ├── database
│ ├── mail
│ ├── queue
│ │ ├── consumer
│ │ └── producer
│ └── service
└── services
└── exchange

Data flow

On the image besides here, you can have the ideia of the data flow.

Our first step is SQS, in this case i am using Localstack, because my ideia is to have one local enviroment for developing without to have an AWS account for example. It because LocalStack is a service that provides the same interfaces and functionalites as AWS provider, so you can use this service as a “Local AWS”.

 

In case you want to run the application, follow the steps from the project's readme You'll find everything, plus docker files to run the solution locally.

Receiving the message from SQS

@Module({
  imports: [EventEmitterModule.forRoot(), QueueConfigModule],
  controllers: [],
  providers: [ConsumerHandler],
})
export class ConsumerModule implements OnModuleInit {
  constructor(private readonly service: ConsumerHandler) {}

  onModuleInit() {
    this.service.activateReceivers();
  }
}

public async ordersConsumer() {
    const queueUrl = this.queueConfigService.inputOrderUrl;
    const sqs = this.sqsIntance;
    const receiveParams = {
      QueueUrl: queueUrl,
      MaxNumberOfMessages: 10,
      WaitTimeSeconds: 5,
    };

    while (true) {
      const response: ReceiveMessageResult = await sqs
        .receiveMessage(receiveParams)
        .promise();
      const messages = response.Messages ?? [];

      for (const message of messages) {
        const queueMessage = JSON.parse(message.Body);
        const exchangeMessage: IExchangeMessage = queueMessage.body;

        this.eventEmitter.emit(EnumEventOrders.OrderCreated, exchangeMessage);

        await this.deleteMessage(queueUrl, message.ReceiptHandle);
      }
    }
  }

Documentation | NestJS - A progressive Node.js framework

Nest is a framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with TypeScript and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).

https://docs.nestjs.com/techniques/events

export interface IExchangeMessage {
  email: string;
  currencyFrom: string;
  currencyTo: string;
  amount: number;
  comment: string;
}

Processing the messages

• Receive the message;

• Use the exchange API;

• Save response inside the MongoDB;

• Send the email;

@Module({
  imports: [
    MailDatabaseProviderModule,
    ExchangeModule,
    MongooseModule.forFeature([{ name: Orders.name, schema: OrdersSchema }]),
  ],
  controllers: [],
  providers: [
    OrdersRepository,
    OrdersService,
    ProcessMessageUseCase,
    OrderCreatedListener,
  ],
  exports: [OrdersService],
})
export class OrdersModule {}

Ohh I didn't comment anything about the dependencies, but as you can see, there is a folder called config, and in there, we have modules that centralize the base configurations, and then we have other two ones called services and providers, which have the functionalities like send an email, or the integration logical with the API.

1. Call the API of exchange currencies;

2. Send the email;

3. Save the order inside the database;

Frontend 🎨

This is a traditional NextJS project; however, I did the folder and components organization as simply as possible. For example, we have the components folder that has the form component, which is the main and only form of the application.

There's not so much to say about this application because it has only one page and one endpoint that turns the user able to fill out the fields and send them to the backend.

Sending messages to the service

const sqs = new AWS.SQS({
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  region: process.env.AWS_REGION
});

export default async function handler(
  _req: IRequestOrder,
  res: NextApiResponse
) {
  const message = {
    MessageBody: JSON.stringify({
      id: 'id',
      body: {
        email: _req.body.email,
        currencyFrom: _req.body.from,
        currencyTo: _req.body.to,
        amount: _req.body.amount,
        comment: _req.body.comment,
      }
    }),
    QueueUrl: process.env.QUEUE_INPUT_ORDERS_URL as string,
  };

  await sqs
        .sendMessage(message)
        .promise();

  return res.status(200).send('ok')
}

Thinking right now maybe I could add zod as a validator of input fields… but it's ok too. 😅

Ok, to explain to you better, this is the form 👉🏻

 

After the customer fills and sends the backend, take the scene and do the magic 🧙‍♂️

 

 

Conclusion

Possible improvements

• Processing messages The strategy I applied may not be the best, at least when we talk about the ConsumerHandler. It is because after the EvventEmitter is called, I remove the message from the QUEUE, and we can have problems with the processing of the order, for example, we can have a problem when calling the exchange currency API.