Padronização dos controllers

infra/controller.js

@@ -0,0 +1,26 @@
+import { InternalServerError, MethodNotAllowedError } from './errors'
+
+function onNoMatchHandler(request, response) {
+  const publicErrorObject = new MethodNotAllowedError()
+  console.error(publicErrorObject)
+  response.status(publicErrorObject.statusCode).json(publicErrorObject)
+}
+
+function onErrorHandler(error, request, response) {
+  const publicErrorObject = new InternalServerError({
+    statusCode: error.statusCode,
+    cause: error
+  })
+
+  console.error(publicErrorObject)
+  response.status(publicErrorObject.statusCode).json(publicErrorObject)
+}
+
+const controller = {
+  errorHandlers: {
+    onNoMatch: onNoMatchHandler,
+    onError: onErrorHandler
+  }
+}
+
+export default controller

infra/database.js

@@ -1,4 +1,5 @@
 import { Client } from 'pg'
+import { ServiceError } from './errors.js'
 
 async function query(queryObject) {
   let client
@@ -8,9 +9,11 @@ async function query(queryObject) {
     const result = await client.query(queryObject)
     return result
   } catch (error) {
-    console.log('\n Erro dentro do catch do database.js:')
-    console.error(error)
-    throw error
+    const serviceErrorObject = new ServiceError({
+      message: 'Erro na conexão com Banco ou na Query.',
+      cause: error
+    })
+    throw serviceErrorObject
   } finally {
     await client?.end()
   }

infra/errors.js

@@ -1,11 +1,50 @@
 export class InternalServerError extends Error {
-  constructor({ cause }) {
+  constructor({ cause, statusCode }) {
     super('Um erro interno não esperado aconteceu.', {
       cause
     })
     this.name = 'InternalServerError'
     this.action = 'Entre em contato com o suporte.'
-    this.statusCode = 500
+    this.statusCode = statusCode || 500
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      action: this.action,
+      status_code: this.statusCode
+    }
+  }
+}
+
+export class MethodNotAllowedError extends Error {
+  constructor() {
+    super('Método não permitido para este endpoint.')
+    this.name = 'MethodNotAllowedError'
+    this.action =
+      'Verifique se o método HTTP enviado é valido para este endpoint.'
+    this.statusCode = 405
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      action: this.action,
+      status_code: this.statusCode
+    }
+  }
+}
+
+export class ServiceError extends Error {
+  constructor({ cause, message }) {
+    super(message || 'Serviço indisponível no momento.', {
+      cause
+    })
+    this.name = 'ServiceError'
+    this.action = 'Verifique se o serviço está disponível.'
+    this.statusCode = 503
   }
 
   toJSON() {

package.json

@@ -3,6 +3,9 @@
   "version": "1.0.0",
   "description": "",
   "main": "index.js",
+  "imports": {
+    "@/*": "./src/*"
+  },
   "scripts": {
     "dev": "node infra/scripts/dev.js",
     "test": "npm run services:up && concurrently --names next,jest --hide next --kill-others --success command-jest \"next dev\" \"jest --runInBand --verbose\"",
@@ -28,6 +31,7 @@
     "dotenv": "16.4.5",
     "dotenv-expand": "11.0.6",
     "next": "14.2.5",
+    "next-connect": "1.0.0",
     "node-pg-migrate": "7.6.1",
     "pg": "8.12.0",
     "react": "18.3.1",

pages/api/v1/migrations/index.js

@@ -1,48 +1,58 @@
 import migrationRunner from 'node-pg-migrate'
 import { resolve } from 'node:path'
 import database from 'infra/database'
+import { createRouter } from 'next-connect'
+import controller from 'infra/controller'
 
-export default async function migrations(request, response) {
-  const allowedMethods = ['GET', 'POST']
-  if (!allowedMethods.includes(request.method)) {
-    return response.status(405).json({
-      error: `Method '${request.method}' not allowed`
-    })
+const router = createRouter()
+
+router.get(getHandler)
+router.post(postHandler)
+
+export default router.handler(controller.errorHandlers)
+
+async function defineMigrationsClientConfig() {
+  const dbClient = await database.getNewClient()
+
+  const defaultMigrationOptions = {
+    dbClient: dbClient,
+    dryRun: true,
+    dir: resolve('infra', 'migrations'),
+    direction: 'up',
+    verbose: true,
+    migrationsTable: 'pgmigrations'
   }
 
-  let dbClient
+  return { dbClient, defaultMigrationOptions }
+}
+
+async function getHandler(request, response) {
+  const { dbClient, defaultMigrationOptions } =
+    await defineMigrationsClientConfig()
 
   try {
-    dbClient = await database.getNewClient()
-
-    const defaultMigrationOptions = {
-      dbClient: dbClient,
-      dryRun: true,
-      dir: resolve('infra', 'migrations'),
-      direction: 'up',
-      verbose: true,
-      migrationsTable: 'pgmigrations'
-    }
-    if (request.method === 'GET') {
-      const pendingMigrations = await migrationRunner(defaultMigrationOptions)
-      return response.status(200).send(pendingMigrations)
-    }
+    const pendingMigrations = await migrationRunner(defaultMigrationOptions)
+    return response.status(200).send(pendingMigrations)
+  } finally {
+    await dbClient.end()
+  }
+}
 
-    if (request.method === 'POST') {
-      const migratedMigrations = await migrationRunner({
-        ...defaultMigrationOptions,
-        dryRun: false
-      })
+async function postHandler(request, response) {
+  const { dbClient, defaultMigrationOptions } =
+    await defineMigrationsClientConfig()
 
-      if (migratedMigrations.length > 0) {
-        return response.status(201).send(migratedMigrations)
-      }
+  try {
+    const migratedMigrations = await migrationRunner({
+      ...defaultMigrationOptions,
+      dryRun: false
+    })
 
-      return response.status(200).send(migratedMigrations)
+    if (migratedMigrations.length > 0) {
+      return response.status(201).send(migratedMigrations)
     }
-  } catch (error) {
-    console.error(error)
-    throw error
+
+    return response.status(200).send(migratedMigrations)
   } finally {
     await dbClient.end()
   }

pages/api/v1/status/index.js

@@ -1,51 +1,46 @@
+import { createRouter } from 'next-connect'
 import database from 'infra/database.js'
-import { InternalServerError } from 'infra/errors.js'
-
-async function status(request, response) {
-  try {
-    const updatedAt = new Date().toISOString()
-
-    // Server version
-    const databaseVersionResult = await database.query('SHOW server_version;')
-    const databaseVersionValue = databaseVersionResult.rows[0].server_version
-
-    // Max connections
-    const databaseMaxConnectionsResult = await database.query(
-      'SHOW max_connections;'
-    )
-    const databaseMaxConnectionsValue =
-      databaseMaxConnectionsResult.rows[0].max_connections
-
-    // Opened connections
-    const databaseName = process.env.POSTGRES_DB
-    const databaseOpenedConnectionsResult = await database.query({
-      text: 'SELECT COUNT(*)::int FROM pg_stat_activity WHERE datname = $1;',
-      values: [databaseName]
-    })
-    const databaseOpenedConnectionsValue =
-      databaseOpenedConnectionsResult.rows[0].count
-
-    const dependencies = {
-      database: {
-        version: databaseVersionValue,
-        max_connections: parseInt(databaseMaxConnectionsValue),
-        opened_connections: databaseOpenedConnectionsValue
-      }
+import controller from 'infra/controller'
+
+const router = createRouter()
+
+router.get(getHandler)
+
+export default router.handler(controller.errorHandlers)
+
+async function getHandler(request, response) {
+  const updatedAt = new Date().toISOString()
+
+  // Server version
+  const databaseVersionResult = await database.query('SHOW server_version;')
+  const databaseVersionValue = databaseVersionResult.rows[0].server_version
+
+  // Max connections
+  const databaseMaxConnectionsResult = await database.query(
+    'SHOW max_connections;'
+  )
+  const databaseMaxConnectionsValue =
+    databaseMaxConnectionsResult.rows[0].max_connections
+
+  // Opened connections
+  const databaseName = process.env.POSTGRES_DB
+  const databaseOpenedConnectionsResult = await database.query({
+    text: 'SELECT COUNT(*)::int FROM pg_stat_activity WHERE datname = $1;',
+    values: [databaseName]
+  })
+  const databaseOpenedConnectionsValue =
+    databaseOpenedConnectionsResult.rows[0].count
+
+  const dependencies = {
+    database: {
+      version: databaseVersionValue,
+      max_connections: parseInt(databaseMaxConnectionsValue),
+      opened_connections: databaseOpenedConnectionsValue
     }
-
-    response.status(200).send({
-      updated_at: updatedAt,
-      dependencies
-    })
-  } catch (error) {
-    const publicErrorObject = new InternalServerError({
-      cause: error
-    })
-
-    console.log('\n Erro dentro do catch do controller:')
-    console.error(publicErrorObject)
-    response.status(500).json(publicErrorObject)
   }
-}
 
-export default status
+  response.status(200).send({
+    updated_at: updatedAt,
+    dependencies
+  })
+}