Initial commit

Author: indistormborn

.babelrc

@@ -0,0 +1,30 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "16"
+        }
+      },
+    ],
+    "@babel/preset-typescript"
+  ],
+  "plugins": [
+    [
+      "module-resolver",
+      {
+        "alias": {
+          "contracts": "./src/contracts",
+          "infra": "./src/infra",
+          "usecases": "./src/usecases",
+          "services": "./src/services",
+          "controllers": "./src/controllers",
+          "entities": "./src/entities",
+          "common": "./src/common"
+        },
+        "cwd": "babelrc"
+      }
+    ]
+  ]
+}

.env-example

@@ -0,0 +1,4 @@
+MONGODB_URI
+RABBITMQ_URI
+SERVER_PORT
+LOG_LEVEL

.eslintrc.js

@@ -0,0 +1,25 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+      project: 'tsconfig.json',
+      sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint/eslint-plugin'],
+    extends: [
+      'plugin:@typescript-eslint/recommended',
+      'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+      node: true,
+      jest: true,
+    },
+    ignorePatterns: ['.eslintrc.js'],
+    rules: {
+      '@typescript-eslint/interface-name-prefix': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
+  };
+  

.gitignore

@@ -0,0 +1,6 @@
+/dist
+/node_modules
+/coverage
+.env
+
+.vscode/*

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

README.md

@@ -0,0 +1,18 @@
+# scaffold-service
+Este é um repositório base com estrutura inicial necessária para a construção dos serviços do projeto `TCC`
+___
+
+### Desenvolvimento
+Esse app é composto por
+- Express.js
+- RabbitMQ
+- MongoDB
+- Jest
+
+### Testes
+Executar 
+> npm run test
+
+### Execução
+Executar
+> npm run start

package-lock.json

@@ -0,0 +1,71 @@
+{
+  "name": "nome",
+  "version": "0.0.1",
+  "description": "descricao",
+  "author": "Indiara Camillo Menegat",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "npm run format && npm run lint && tsc --noEmit -p . && rimraf dist && babel src --extensions \".ts,.js\" --out-dir dist --copy-files --no-copy-ignored --source-maps",
+    "prebuild": "rimraf dist",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "start": "node dist/index.js",
+    "lint": "eslint \"{src,test}/**/*.ts\" --fix",
+    "test": "jest --runInBand",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand"
+  },
+  "dependencies": {
+    "@types/amqplib": "^0.8.2",
+    "amqplib": "^0.8.0",
+    "body-parser": "^1.20.0",
+    "dotenv": "^16.0.0",
+    "express": "^4.17.2",
+    "mongoose": "^6.1.10",
+    "winston": "^3.7.2"
+  },
+  "engines": {
+    "node": "16"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.17.10",
+    "@babel/core": "^7.17.12",
+    "@babel/node": "^7.17.10",
+    "@babel/preset-env": "^7.17.12",
+    "@babel/preset-typescript": "^7.17.12",
+    "@types/express": "^4.17.13",
+    "@types/jest": "27.0.2",
+    "@types/node": "^16.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^27.2.5",
+    "prettier": "^2.3.2",
+    "ts-jest": "^27.0.3",
+    "ts-loader": "^9.2.3",
+    "ts-node": "^10.7.0",
+    "tsconfig-paths": "^3.10.1",
+    "typescript": "^4.3.5"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package.json

@@ -0,0 +1,11 @@
+import { IHttpError } from 'contracts/server/Http';
+
+export class HttpError implements IHttpError {
+  readonly status: number;
+  readonly message: string;
+
+  constructor(props: IHttpError) {
+    this.status = props.status;
+    this.message = props.message;
+  }
+}

src/common/errors/HttpError.ts

@@ -0,0 +1,7 @@
+import { HttpRequest, HttpResponse } from 'contracts/server/Http';
+import { BaseUseCase } from 'contracts/usecases/BaseUseCase';
+
+export interface BaseController {
+  useCase: BaseUseCase;
+  handle: (request: HttpRequest) => Promise<HttpResponse>;
+}

src/contracts/controllers/BaseController.ts

@@ -0,0 +1,5 @@
+export interface ITest {
+  value: number;
+  word: string;
+  isItTrue: boolean;
+}

src/contracts/entities/ITest.ts

@@ -0,0 +1,20 @@
+export interface Query {
+  [key: string]: undefined | string | string[] | Query | Query[];
+}
+
+export interface HttpRequest {
+  headers?: Record<string, string | string[] | undefined>;
+  params?: Record<string, string>;
+  query?: Query;
+  body?: any;
+}
+
+export interface HttpResponse {
+  status: number;
+  body?: unknown;
+}
+
+export interface IHttpError {
+  status: number;
+  message: string;
+}

src/contracts/server/Http.ts

@@ -0,0 +1,3 @@
+export interface BaseUseCase {
+  execute: (input: any) => Promise<void>;
+}

src/contracts/usecases/BaseUseCase.ts

@@ -0,0 +1,32 @@
+import { HttpError } from 'common/errors/HttpError';
+import { BaseController } from 'contracts/controllers/BaseController';
+import { ITest } from 'contracts/entities/ITest';
+import { HttpRequest, HttpResponse } from 'contracts/server/Http';
+import { TestUseCase } from 'usecases/TestUseCase';
+
+export class TestController implements BaseController {
+  readonly useCase: TestUseCase;
+  constructor(useCase: TestUseCase) {
+    this.useCase = useCase;
+  }
+
+  async handle(request: HttpRequest): Promise<HttpResponse> {
+    try {
+      const input: ITest = {
+        isItTrue: request.body?.isItTrue || true,
+        value: request.body?.value || 100,
+        word: request.body?.word || 'banana',
+      };
+      await this.useCase.execute(input);
+      return {
+        status: 200,
+        body: 'everything is great!',
+      };
+    } catch (error) {
+      throw new HttpError({
+        message: 'Error while etc etc',
+        status: 400,
+      });
+    }
+  }
+}

src/controllers/TestController.ts

@@ -0,0 +1,13 @@
+import { ITest } from 'contracts/entities/ITest';
+
+export class Test implements ITest {
+  readonly value: number;
+  readonly word: string;
+  readonly isItTrue: boolean;
+
+  constructor(props: ITest) {
+    this.value = props.value;
+    this.word = props.word;
+    this.isItTrue = props.isItTrue;
+  }
+}

src/entities/Test.ts

@@ -0,0 +1,19 @@
+import { default as Database } from 'infra/database/Connection';
+import { default as Broker } from 'infra/message-broker/Manager';
+import { default as Server } from 'infra/server/Server';
+import { TestPublisher } from './infra/message-broker/publishers/TestPublisher';
+
+(async () => {
+  Promise.all([Database.init(), Broker.init(), Server.init()]).then(
+    async () => {
+      const test = new TestPublisher();
+      test.publish(
+        JSON.stringify({
+          word: 'mensgaem enviada',
+          isItTrue: false,
+          value: 654,
+        }),
+      );
+    },
+  );
+})();

src/index.ts

@@ -0,0 +1,16 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+export abstract class Config {
+  static readonly mongoURI = process.env.MONGODB_URI;
+  static readonly rabbitURI = process.env.RABBITMQ_URI;
+  static readonly serverPort = process.env.SERVER_PORT || 3000;
+  static readonly logLevel = process.env.LOG_LEVEL || 'info';
+  static readonly exchanges = [
+    {
+      name: 'test',
+      type: 'topic',
+      routingKeys: ['teste.key'],
+    },
+  ];
+}

src/infra/config.ts

@@ -0,0 +1,29 @@
+import { connect, connection } from 'mongoose';
+import { Config } from '../config';
+import { logger } from '../logger';
+
+class Database {
+  public readonly uri: string = Config.mongoURI;
+
+  async init(): Promise<void> {
+    try {
+      connection.on('disconnected', async () => {
+        logger.info('Trying to connect database again');
+        await connect(this.uri);
+      });
+
+      connection.on('error', async () => {
+        logger.error('Error connecting to database');
+        process.exit();
+      });
+
+      logger.info('Connecting to database with uri %s', this.uri);
+      await connect(this.uri);
+    } catch (error) {
+      logger.error('Error while connecting to database: %s', error.message);
+      throw error;
+    }
+  }
+}
+
+export default new Database();

src/infra/database/Connection.ts

@@ -0,0 +1,9 @@
+import { SchemaOptions } from 'mongoose';
+
+export const schemaOptions: SchemaOptions = {
+  versionKey: false,
+  timestamps: {
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
+  },
+};

src/infra/database/SchemaOptions.ts

@@ -0,0 +1,22 @@
+import { ITest } from 'contracts/entities/ITest';
+import { model, Schema } from 'mongoose';
+import { schemaOptions } from '../SchemaOptions';
+
+export const TestSchema = new Schema<ITest>(
+  {
+    value: {
+      type: Number,
+      default: 0,
+    },
+    word: {
+      type: String,
+      required: true,
+    },
+    isItTrue: {
+      type: Boolean,
+    },
+  },
+  schemaOptions,
+);
+
+export const TestModel = model<ITest>('Test', TestSchema);

src/infra/database/schemas/TestSchema.ts

@@ -0,0 +1,16 @@
+import { createLogger, transports, format } from 'winston';
+import { Config } from './config';
+
+export const logger = createLogger({
+  level: Config.logLevel,
+  transports: [new transports.Console()],
+  format: format.combine(
+    format.colorize(),
+    format.splat(),
+    format.metadata(),
+    format.timestamp(),
+    format.printf(({ timestamp, level, message, metadata }) => {
+      return `[${timestamp}] ${level}: ${message}. ${JSON.stringify(metadata)}`;
+    }),
+  ),
+});

src/infra/logger.ts

@@ -0,0 +1,35 @@
+import client, { Channel, Connection } from 'amqplib';
+import { Config } from '../config';
+import { logger } from '../logger';
+import { initSubscribers } from './subscribers';
+
+class MessageBroker {
+  private readonly uri: string = Config.rabbitURI;
+  private readonly exchanges = Config.exchanges;
+  connection: Connection;
+  channel: Channel;
+
+  async init(): Promise<void> {
+    try {
+      logger.info('Connecting to message broker');
+      this.connection = await client.connect(this.uri, { heartbeat: 60 });
+
+      this.channel = await this.connection.createChannel();
+
+      Promise.all(
+        this.exchanges.map((exchange) =>
+          this.channel.assertExchange(exchange.name, exchange.type, {
+            durable: true,
+          }),
+        ),
+      ).then(() => initSubscribers());
+
+      logger.info('Connected to message broker');
+    } catch (error) {
+      logger.error('Error while starting message broker: $s', error);
+      throw error;
+    }
+  }
+}
+
+export default new MessageBroker();

src/infra/message-broker/Manager.ts

@@ -0,0 +1,19 @@
+import { logger } from 'infra/logger';
+import { default as MessageBroker } from 'infra/message-broker/Manager';
+
+export class BasePublisher {
+  constructor(
+    protected exchange: { name: string; type: string },
+    protected routingKey: string,
+  ) {}
+
+  publish(msg: string): void {
+    const channel = MessageBroker.channel;
+    const content = Buffer.from(msg);
+    channel.publish(this.exchange.name, this.routingKey, content);
+    logger.info('Message published', {
+      exchange: this.exchange,
+      routingKey: this.routingKey,
+    });
+  }
+}

src/infra/message-broker/publishers/BasePublisher.ts

@@ -0,0 +1,13 @@
+import { Config } from 'infra/config';
+import { BasePublisher } from './BasePublisher';
+
+export class TestPublisher extends BasePublisher {
+  constructor() {
+    const exchange = {
+      name: Config.exchanges[0].name,
+      type: Config.exchanges[0].type,
+    };
+    const routingKey = Config.exchanges[0].routingKeys[0];
+    super(exchange, routingKey);
+  }
+}

src/infra/message-broker/publishers/TestPublisher.ts

@@ -0,0 +1,40 @@
+import { ConsumeMessage } from 'amqplib';
+import { BaseUseCase } from 'contracts/usecases/BaseUseCase';
+import { logger } from 'infra/logger';
+import { default as MessageBroker } from 'infra/message-broker/Manager';
+
+export class BaseSubscriber {
+  constructor(
+    private exchange: { name: string; type: string },
+    private routingKey: string,
+    private useCase: BaseUseCase,
+  ) {}
+
+  async consume(): Promise<void> {
+    const channel = MessageBroker.channel;
+    const queueName = `${this.routingKey}_queue`;
+
+    Promise.all([
+      channel.assertQueue(queueName),
+      channel.bindQueue(queueName, this.exchange.name, this.routingKey),
+      channel.prefetch(1),
+      channel.consume(queueName, (msg: ConsumeMessage) => {
+        if (msg.content) {
+          const parsedData = JSON.parse(msg.content.toString());
+          logger.info('Message consumed', {
+            exchange: this.exchange,
+            routingKey: this.routingKey,
+            content: parsedData,
+          });
+          this.useCase.execute(parsedData).then(() => channel.ack(msg));
+        }
+      }),
+    ]).catch((reason) => {
+      logger.error('Error while consuming message', {
+        exchange: this.exchange,
+        routingKey: this.routingKey,
+      });
+      throw new Error(reason);
+    });
+  }
+}

src/infra/message-broker/subscribers/BaseSubscriber.ts

@@ -0,0 +1,19 @@
+import { Config } from 'infra/config';
+import { TestService } from 'services/TestService';
+import { TestUseCase } from 'usecases/TestUseCase';
+import { BaseSubscriber } from './BaseSubscriber';
+
+class TestSubscriber extends BaseSubscriber {
+  constructor() {
+    const exchange = {
+      name: Config.exchanges[0].name,
+      type: Config.exchanges[0].type,
+    };
+    const routingKey = Config.exchanges[0].routingKeys[0];
+    const service = new TestService();
+    const useCase = new TestUseCase(service);
+    super(exchange, routingKey, useCase);
+  }
+}
+
+export default new TestSubscriber();

src/infra/message-broker/subscribers/TestSubscriber.ts

@@ -0,0 +1,8 @@
+/**  Neste arquivo serão importados todos os subscribers criados e
+ * será configurado para que ouçam uma determinada exchange/queue/routinKey*/
+
+import { default as TestSubscriber } from './TestSubscriber';
+
+export const initSubscribers = (): Promise<void>[] => {
+  return [TestSubscriber.consume()];
+};

src/infra/message-broker/subscribers/index.ts

@@ -0,0 +1,23 @@
+import { HttpError } from 'common/errors/HttpError';
+import { BaseController } from 'contracts/controllers/BaseController';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+
+export const requestHandlerMidd = (
+  controller: BaseController,
+): RequestHandler => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const httpResponse = await controller.handle(req);
+      res.status(httpResponse.status).json(httpResponse.body);
+    } catch (error) {
+      if (error instanceof HttpError)
+        return res.status(error.status).send(error.message);
+
+      return res
+        .status(500)
+        .send('An internal error occourred, try again later');
+    } finally {
+      next();
+    }
+  };
+};

src/infra/server/Middlewares.ts

@@ -0,0 +1,7 @@
+/** Arquivo pra cadastrar rotas caso exista um server */
+import { Express } from 'express';
+import { default as TestRouter } from './routes/TestRouter';
+
+export const initRoutes = (app: Express) => {
+  app.use('/test', TestRouter);
+};

src/infra/server/Routes.ts

@@ -0,0 +1,23 @@
+import bodyParser from 'body-parser';
+import express, { Express } from 'express';
+import { Config } from 'infra/config';
+import { logger } from 'infra/logger';
+import { initRoutes } from './Routes';
+
+class Server {
+  readonly app: Express = express();
+  readonly port = Config.serverPort;
+
+  async init(): Promise<void> {
+    this.app.use(express.json());
+    this.app.use(bodyParser.json({ limit: '50mb' }));
+
+    this.app.listen(this.port, () => {
+      logger.info('Server running on port ' + this.port);
+    });
+
+    initRoutes(this.app);
+  }
+}
+
+export default new Server();

src/infra/server/Server.ts

@@ -0,0 +1,14 @@
+import { TestController } from 'controllers/TestController';
+import { Router } from 'express';
+import { TestService } from 'services/TestService';
+import { TestUseCase } from 'usecases/TestUseCase';
+import { requestHandlerMidd } from '../Middlewares';
+
+const router = Router();
+
+router.get(
+  '/send-message',
+  requestHandlerMidd(new TestController(new TestUseCase(new TestService()))),
+);
+
+export default router;

src/infra/server/routes/TestRouter.ts

@@ -0,0 +1,55 @@
+import { logger } from 'infra/logger';
+import { HydratedDocument, Model, FilterQuery, UpdateQuery } from 'mongoose';
+
+export class BaseService<T> {
+  protected readonly model: Model<T>;
+
+  constructor(model: Model<T>) {
+    this.model = model;
+  }
+
+  async create(data: T): Promise<HydratedDocument<T>> {
+    try {
+      return this.model.create(data);
+    } catch (error) {
+      logger.error('Error while creating document on database', {
+        name: this.model.modelName,
+        data,
+      });
+    }
+  }
+
+  async update(query: FilterQuery<T>, update: UpdateQuery<T>): Promise<void> {
+    try {
+      await this.model.updateMany(query, update);
+    } catch (error) {
+      logger.error('Error while updating document on database', {
+        name: this.model.modelName,
+        query,
+        update,
+      });
+    }
+  }
+
+  async find(query: FilterQuery<T>): Promise<T[]> {
+    try {
+      return await this.model.find(query).lean();
+    } catch (error) {
+      logger.error('Error while trying to find documents on database', {
+        name: this.model.modelName,
+        query,
+      });
+    }
+  }
+
+  async delete(query: FilterQuery<T>): Promise<void> {
+    try {
+      await this.model.deleteMany(query);
+    } catch (error) {
+      logger.error('Error while deleting documents on database', {
+        name: this.model.modelName,
+        query,
+      });
+    }
+  }
+}

src/services/BaseService.ts

@@ -0,0 +1,9 @@
+import { ITest } from 'contracts/entities/ITest';
+import { TestModel } from 'infra/database/schemas/TestSchema';
+import { BaseService } from './BaseService';
+
+export class TestService extends BaseService<ITest> {
+  constructor() {
+    super(TestModel);
+  }
+}

src/services/TestService.ts

@@ -0,0 +1,40 @@
+import { ITest } from 'contracts/entities/ITest';
+import { BaseUseCase } from 'contracts/usecases/BaseUseCase';
+import { Test } from 'entities/Test';
+import { TestService } from 'services/TestService';
+
+export class TestUseCase implements BaseUseCase {
+  constructor(private readonly testService: TestService) {}
+
+  async execute(input: ITest): Promise<void> {
+    console.log('Printing message', input);
+
+    const entity = new Test(input);
+
+    const createdObjs = await Promise.all([
+      this.testService.create(entity),
+      this.testService.create(entity),
+      this.testService.create(entity),
+    ]);
+
+    console.log(createdObjs);
+
+    console.log(`Deletando com id ${createdObjs[0]._id}`);
+    await this.testService.delete({
+      _id: createdObjs[0]._id,
+    });
+
+    console.log(`Atualizando com id ${createdObjs[1]._id}`);
+    await this.testService.update(
+      {
+        _id: createdObjs[1]._id,
+      },
+      {
+        $set: { isItTrue: false, value: 1000000 },
+      },
+    );
+
+    const returned = await this.testService.find({ value: 654 });
+    console.log(returned);
+  }
+}

src/usecases/TestUseCase.ts

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+      "module": "commonjs",
+      "declaration": true,
+      "removeComments": true,
+      "emitDecoratorMetadata": true,
+      "experimentalDecorators": true,
+      "allowSyntheticDefaultImports": true,
+      "target": "es2017",
+      "sourceMap": true,
+      "outDir": "./dist",
+      "baseUrl": "./",
+      "incremental": true,
+      "skipLibCheck": true,
+      "strictNullChecks": false,
+      "noImplicitAny": false,
+      "strictBindCallApply": false,
+      "forceConsistentCasingInFileNames": false,
+      "noFallthroughCasesInSwitch": false,
+      "resolveJsonModule": true,
+      "paths": {
+        "common/*":["src/common/*"],
+        "contracts/*":["src/contracts/*"],
+        "controllers/*":["src/controllers/*"],
+        "entities/*":["src/entities/*"],
+        "infra/*":["src/infra/*"],
+        "services/*":["src/services/*"],
+        "usecases/*":["src/usecases/*"],
+      }
+    }
+  }