diff --git a/src/controllers/clientController.ts b/src/controllers/clientController.ts
index c9d1aa1..2813774 100644
--- a/src/controllers/clientController.ts
+++ b/src/controllers/clientController.ts
@@ -1,87 +1,111 @@
+import { Request, Response } from "express";
 import database from "../db";
 
-const create = async (request, response) => {
+const create = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    if (!request.body.client.name) return response.status(400).json({
-      success: false,
-      message: 'O campo nome é obrigatório'
-    })
+    if (!request.body.client.name)
+      return response.status(400).json({
+        success: false,
+        message: "O campo nome é obrigatório",
+      });
     return response.json({
       success: true,
-      client: await database.client.create(request.body.client)
+      client: await database.client.create(request.body.client),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const getAll = async (request, response) => {
+const getAll = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
     return response.json({
       success: true,
-      clients: await database.client.findAll()
+      clients: await database.client.findAll(),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const getOne = async (request, response) => {
+const getOne = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
     return response.json({
       success: true,
-      client: await database.client.findByPk(request.params.id)
+      client: await database.client.findByPk(request.params.id),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const edit = async (request, response) => {
+const edit = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    await database.client.update(request.body.client, { where: { idClient: request.params.id } })
+    await database.client.update(request.body.client, {
+      where: { idClient: request.params.id },
+    });
     return response.json({
-      success: true
+      success: true,
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const destroy = async (request, response) => {
+const destroy = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    await database.client.destroy({ where: { idClient: request.params.id } })
+    await database.client.destroy({ where: { idClient: request.params.id } });
     return response.json({
-      success: true
+      success: true,
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-export default { create, getAll, getOne, edit, destroy }
\ No newline at end of file
+export default { create, getAll, getOne, edit, destroy };
diff --git a/src/controllers/employeeController.ts b/src/controllers/employeeController.ts
index e9527a6..fa0f9f5 100644
--- a/src/controllers/employeeController.ts
+++ b/src/controllers/employeeController.ts
@@ -1,92 +1,118 @@
+import { Request, Response } from "express";
 import database from "../db";
 
-const create = async (request, response) => {
-    try {
-        const fieldsToValidate = ['cpf', 'name', 'occupation']
-        for (let field of fieldsToValidate) {
-            if (!request.body.employee[field]) {
-                return response.status(400).json({
-                    success: false,
-                    message: `O campo ${field} é obrigatório.`
-                });
-            }
-        }
-        return response.json({
-            success: true,
-            employee: await database.employee.create(request.body.employee)
-        });
-    } catch (error) {
-        console.log('ERROR --> ', error);
-        return response.status(500).json({
-            success: false,
-            message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-            error: error.toString()
-        });
-    }
-}
+const create = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
+  try {
+    const fieldsToValidate = ["cpf", "name", "occupation"];
 
-const getAll = async (request, response) => {
-    try {
-        return response.json({
-            success: true,
-            employees: await database.employee.findAll()
-        });
-    } catch (error) {
-        console.log('ERROR ---> ', error);
-        return response.status(500).json({
-            success: false,
-            message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-            error: error.toString()
+    fieldsToValidate.forEach((field: string): Response => {
+      if (!request.body.employee[field]) {
+        return response.status(400).json({
+          success: false,
+          message: `O campo ${field} é obrigatório.`,
         });
-    }
-}
+      }
+      return null;
+    });
 
-const getOne = async (request, response) => {
-    try {
-        return response.json({
-            success: true,
-            employee: await database.employee.findByPk(request.params.cpf)
-        });
-    } catch (error) {
-        console.log('ERROR ---> ', error);
-        return response.status(500).json({
-            success: false,
-            message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-            error: error.toString()
-        });
-    }
-}
+    return response.json({
+      success: true,
+      employee: await database.employee.create(request.body.employee),
+    });
+  } catch (error) {
+    console.log("ERROR --> ", error);
+    return response.status(500).json({
+      success: false,
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
+  }
+};
 
-const edit = async (request, response) => {
-    try {
-        await database.employee.update(request.body.employee, { where: { cpf: request.params.cpf } })
-        return response.json({
-            success: true
-        });
-    } catch (error) {
-        console.log('ERROR ---> ', error);
-        return response.status(500).json({
-            success: false,
-            message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-            error: error.toString()
-        });
-    }
-}
+const getAll = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
+  try {
+    return response.json({
+      success: true,
+      employees: await database.employee.findAll(),
+    });
+  } catch (error) {
+    console.log("ERROR ---> ", error);
+    return response.status(500).json({
+      success: false,
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
+  }
+};
 
-const destroy = async (request, response) => {
-    try {
-        await database.employee.destroy({ where: { cpf: request.params.cpf } })
-        return response.json({
-            success: true
-        });
-    } catch (error) {
-        console.log('ERROR ---> ', error);
-        return response.status(500).json({
-            success: false,
-            message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-            error: error.toString()
-        });
-    }
-}
+const getOne = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
+  try {
+    return response.json({
+      success: true,
+      employee: await database.employee.findByPk(request.params.cpf),
+    });
+  } catch (error) {
+    console.log("ERROR ---> ", error);
+    return response.status(500).json({
+      success: false,
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
+  }
+};
+
+const edit = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
+  try {
+    await database.employee.update(request.body.employee, {
+      where: { cpf: request.params.cpf },
+    });
+    return response.json({
+      success: true,
+    });
+  } catch (error) {
+    console.log("ERROR ---> ", error);
+    return response.status(500).json({
+      success: false,
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
+  }
+};
+
+const destroy = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
+  try {
+    await database.employee.destroy({ where: { cpf: request.params.cpf } });
+    return response.json({
+      success: true,
+    });
+  } catch (error) {
+    console.log("ERROR ---> ", error);
+    return response.status(500).json({
+      success: false,
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
+  }
+};
 
-export default { create, getAll, getOne, edit, destroy }
+export default { create, getAll, getOne, edit, destroy };
diff --git a/src/controllers/itemController.ts b/src/controllers/itemController.ts
index d3fce74..f38cfe1 100644
--- a/src/controllers/itemController.ts
+++ b/src/controllers/itemController.ts
@@ -1,100 +1,125 @@
+import { Request, Response } from "express";
 import database from "../db";
 
-const create = async (request, response) => {
+const create = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    const fieldsToValidate = ['name', 'price', 'description', 'category'];
-    for (let field of fieldsToValidate) {
+    const fieldsToValidate = ["name", "price", "description", "category"];
+
+    fieldsToValidate.forEach((field: string): Response => {
       if (!request.body.item[field]) {
         return response.status(400).json({
           success: false,
-          message: `O campo ${field} é obrigatório`
+          message: `O campo ${field} é obrigatório`,
         });
       }
-    }
+      return null;
+    });
+
     return response.json({
       success: true,
-      item: await database.item.create(request.body.item)
+      item: await database.item.create(request.body.item),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
     });
   }
-}
+};
 
-const getAll = async (request, response) => {
+const getAll = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    let filters = {}
-    if (request.query.category)
-      filters.category = request.query.category
+    const filters = {};
+    if (request.query.category) filters.category = request.query.category;
 
     return response.json({
       success: true,
       items: await database.item.findAll({
         where: {
-          ...filters
-        }
-      })
+          ...filters,
+        },
+      }),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const getOne = async (request, response) => {
+const getOne = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
     return response.json({
       success: true,
-      item: await database.item.findByPk(request.params.id)
+      item: await database.item.findByPk(request.params.id),
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const edit = async (request, response) => {
+const edit = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    await database.item.update(request.body.item, { where: { idItem: request.params.id } })
+    await database.item.update(request.body.item, {
+      where: { idItem: request.params.id },
+    });
     return response.json({
-      success: true
+      success: true,
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-const destroy = async (request, response) => {
+const destroy = async (
+  request: Request,
+  response: Response
+): Promise<Response> => {
   try {
-    await database.item.destroy({ where: { idItem: request.params.id } })
+    await database.item.destroy({ where: { idItem: request.params.id } });
     return response.json({
-      success: true
+      success: true,
     });
   } catch (error) {
-    console.log('ERROR ---> ', error);
+    console.log("ERROR ---> ", error);
     return response.status(500).json({
       success: false,
-      message: 'Ocorreu um erro ao realizar a operação, tente novamente mais tarde.',
-      error: error.toString()
-    })
+      message:
+        "Ocorreu um erro ao realizar a operação, tente novamente mais tarde.",
+      error: error.toString(),
+    });
   }
-}
+};
 
-export default { create, getAll, getOne, edit, destroy }
\ No newline at end of file
+export default { create, getAll, getOne, edit, destroy };
diff --git a/src/db/index.ts b/src/db/index.ts
index abe30d9..700b8f3 100644
--- a/src/db/index.ts
+++ b/src/db/index.ts
@@ -12,9 +12,13 @@ class Database {
   public connection: Sequelize;
 
   public order: OrderStatic;
+
   public item: ItemStatic;
+
   public client: ClientStatic;
+
   public employee: EmployeeStatic;
+
   public table: TableStatic;
 
   constructor(test: boolean) {
@@ -36,7 +40,7 @@ class Database {
   testConnection(): void {
     this.connection
       .authenticate()
-      .then(async() => {
+      .then(async () => {
         console.log("\n\n🗃️ Banco de Dados conectado!\n");
 
         this.order = OrderFactory(this.connection);
diff --git a/src/models/Client.ts b/src/models/Client.ts
index ba2b1ef..6400b2d 100644
--- a/src/models/Client.ts
+++ b/src/models/Client.ts
@@ -5,7 +5,6 @@ import {
   Sequelize,
   DATE,
   INTEGER,
-  ENUM,
   STRING,
 } from "sequelize";
 
@@ -13,11 +12,13 @@ interface ClientAttributes {
   idClient: number;
   name: string;
 }
-export interface ClientModel extends Model<ClientAttributes>, ClientAttributes { }
-export class Client extends Model<ClientModel, ClientAttributes> { }
+export interface ClientModel
+  extends Model<ClientAttributes>,
+    ClientAttributes {}
+export class Client extends Model<ClientModel, ClientAttributes> {}
 
 export type ClientStatic = typeof Model & {
-  new(values?: object, options?: BuildOptions): ClientModel;
+  new (values?: object, options?: BuildOptions): ClientModel;
 };
 
 export function ClientFactory(sequelize: Sequelize): ClientStatic {
@@ -29,11 +30,21 @@ export function ClientFactory(sequelize: Sequelize): ClientStatic {
         primaryKey: true,
         autoIncrement: true,
       },
-      name: STRING(50)
+      name: STRING(50),
+      createdAt: {
+        type: DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("now"),
+      },
+      updatedAt: {
+        type: DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("now"),
+      },
     },
     {
       freezeTableName: true,
-      timestamps: true,
+      timestamps: false,
       underscored: true,
     }
   );
diff --git a/src/models/Employee.ts b/src/models/Employee.ts
index edf10b6..a71d2e1 100644
--- a/src/models/Employee.ts
+++ b/src/models/Employee.ts
@@ -1,22 +1,18 @@
 /* eslint-disable @typescript-eslint/ban-types */
-import {
-  BuildOptions,
-  Model,
-  Sequelize,
-  ENUM,
-  STRING,
-} from "sequelize";
+import { BuildOptions, Model, Sequelize, ENUM, STRING } from "sequelize";
 
 interface EmployeeAttributes {
   cpf: number;
   name: string;
   occupation: string;
 }
-export interface EmployeeModel extends Model<EmployeeAttributes>, EmployeeAttributes { }
-export class Employee extends Model<EmployeeModel, EmployeeAttributes> { }
+export interface EmployeeModel
+  extends Model<EmployeeAttributes>,
+    EmployeeAttributes {}
+export class Employee extends Model<EmployeeModel, EmployeeAttributes> {}
 
 export type EmployeeStatic = typeof Model & {
-  new(values?: object, options?: BuildOptions): EmployeeModel;
+  new (values?: object, options?: BuildOptions): EmployeeModel;
 };
 
 export function EmployeeFactory(sequelize: Sequelize): EmployeeStatic {
@@ -30,8 +26,8 @@ export function EmployeeFactory(sequelize: Sequelize): EmployeeStatic {
       name: STRING(50),
       occupation: {
         type: ENUM("gerente", "cozinha", "garcom"),
-        allowNull: false
-      }
+        allowNull: false,
+      },
     },
     {
       freezeTableName: true,
diff --git a/src/models/Item.ts b/src/models/Item.ts
index dc7025e..7dabec0 100644
--- a/src/models/Item.ts
+++ b/src/models/Item.ts
@@ -3,7 +3,6 @@ import {
   BuildOptions,
   Model,
   Sequelize,
-  DATE,
   INTEGER,
   ENUM,
   STRING,
@@ -18,11 +17,11 @@ interface ItemAttributes {
   notes: string;
   category: string;
 }
-export interface ItemModel extends Model<ItemAttributes>, ItemAttributes { }
-export class Item extends Model<ItemModel, ItemAttributes> { }
+export interface ItemModel extends Model<ItemAttributes>, ItemAttributes {}
+export class Item extends Model<ItemModel, ItemAttributes> {}
 
 export type ItemStatic = typeof Model & {
-  new(values?: object, options?: BuildOptions): ItemModel;
+  new (values?: object, options?: BuildOptions): ItemModel;
 };
 
 export function ItemFactory(sequelize: Sequelize): ItemStatic {
@@ -40,8 +39,15 @@ export function ItemFactory(sequelize: Sequelize): ItemStatic {
       description: STRING(50),
       notes: STRING(50),
       category: {
-        type: ENUM("hamburgueres", "petiscos", "molhos adicionais", "saladas", "bebidas", "sobremesas"),
-        allowNull: false
+        type: ENUM(
+          "hamburgueres",
+          "petiscos",
+          "molhos adicionais",
+          "saladas",
+          "bebidas",
+          "sobremesas"
+        ),
+        allowNull: false,
       },
     },
     {
diff --git a/src/models/Order.ts b/src/models/Order.ts
index e8d65f8..3562641 100644
--- a/src/models/Order.ts
+++ b/src/models/Order.ts
@@ -10,38 +10,38 @@ import {
 } from "sequelize";
 
 interface OrderAttributes {
-  idOrder: number;
+  idComanda: number;
   status: string;
-  idTable: number;
-  idClient: number;
-  nameClient: string;
-  date: Date;
+  idMesa: number;
+  idCliente: number;
+  nomeCliente: string;
+  data: Date;
 }
-export interface OrderModel extends Model<OrderAttributes>, OrderAttributes { }
-export class Order extends Model<OrderModel, OrderAttributes> { }
+export interface OrderModel extends Model<OrderAttributes>, OrderAttributes {}
+export class Order extends Model<OrderModel, OrderAttributes> {}
 
 export type OrderStatic = typeof Model & {
-  new(values?: object, options?: BuildOptions): OrderModel;
+  new (values?: object, options?: BuildOptions): OrderModel;
 };
 
 export function OrderFactory(sequelize: Sequelize): OrderStatic {
   return <OrderStatic>sequelize.define(
     "orders",
     {
-      idOrder: {
+      idComanda: {
         type: INTEGER,
         primaryKey: true,
         autoIncrement: true,
       },
       status: {
-        type: ENUM("na fila", "na cozinha", "preparado", "na mesa"),
+        type: ENUM("na fila", "na cozinha", "preparando", "na mesa"),
         allowNull: false,
         defaultValue: "na fila",
       },
-      idTable: INTEGER,
-      idClient: INTEGER,
-      nameClient: STRING(50),
-      date: {
+      idMesa: INTEGER,
+      idCliente: INTEGER,
+      nomeCliente: STRING(50),
+      data: {
         type: DATE,
         allowNull: false,
         defaultValue: Sequelize.fn("now"),
@@ -49,7 +49,7 @@ export function OrderFactory(sequelize: Sequelize): OrderStatic {
     },
     {
       freezeTableName: true,
-      timestamps: true,
+      timestamps: false,
       underscored: true,
     }
   );
diff --git a/src/models/Table.ts b/src/models/Table.ts
index fb5a2b8..8049eca 100644
--- a/src/models/Table.ts
+++ b/src/models/Table.ts
@@ -1,24 +1,15 @@
 /* eslint-disable @typescript-eslint/ban-types */
-import {
-  BuildOptions,
-  Model,
-  Sequelize,
-  DATE,
-  INTEGER,
-  BIGINT,
-  ENUM,
-  STRING,
-} from "sequelize";
+import { BuildOptions, Model, Sequelize, INTEGER, STRING } from "sequelize";
 
 interface TableAttributes {
   idMesa: number;
   cpfGarcom: string;
 }
-export interface TableModel extends Model<TableAttributes>, TableAttributes { }
-export class Table extends Model<TableModel, TableAttributes> { }
+export interface TableModel extends Model<TableAttributes>, TableAttributes {}
+export class Table extends Model<TableModel, TableAttributes> {}
 
 export type TableStatic = typeof Model & {
-  new(values?: object, options?: BuildOptions): TableModel;
+  new (values?: object, options?: BuildOptions): TableModel;
 };
 
 export function TableFactory(sequelize: Sequelize): TableStatic {
@@ -32,7 +23,7 @@ export function TableFactory(sequelize: Sequelize): TableStatic {
       },
       cpfGarcom: {
         type: STRING(11),
-        references: {model: 'employees', key: 'cpf'}
+        references: { model: "employees", key: "cpf" },
       },
     },
     {
diff --git a/src/routes/client.ts b/src/routes/client.ts
index bd02397..44ff123 100644
--- a/src/routes/client.ts
+++ b/src/routes/client.ts
@@ -1,18 +1,27 @@
 import { Router } from "express";
 
-import clientController from '../controllers/clientController';
+import clientController from "../controllers/clientController";
 
 const routes = Router();
 
-routes.post("/", async (request, response) => await clientController.create(request, response));
+routes.post("/", (request, response) =>
+  clientController.create(request, response)
+);
 
-routes.get("/", async (request, response) => await clientController.getAll(request, response));
+routes.get("/", (request, response) =>
+  clientController.getAll(request, response)
+);
 
-routes.get("/:id", async (request, response) => await clientController.getOne(request, response));
+routes.get("/:id", (request, response) =>
+  clientController.getOne(request, response)
+);
 
-routes.put("/:id", async (request, response) => await clientController.edit(request, response));
-
-routes.delete("/:id", async (request, response) => await clientController.destroy(request, response));
+routes.put("/:id", (request, response) =>
+  clientController.edit(request, response)
+);
 
+routes.delete("/:id", (request, response) =>
+  clientController.destroy(request, response)
+);
 
 export default routes;
diff --git a/src/routes/employee.ts b/src/routes/employee.ts
index 8b3bebe..7db66c0 100644
--- a/src/routes/employee.ts
+++ b/src/routes/employee.ts
@@ -1,18 +1,27 @@
 import { Router } from "express";
 
-import clientController from '../controllers/employeeController';
+import clientController from "../controllers/employeeController";
 
 const routes = Router();
 
-routes.post("/", async (request, response) => await clientController.create(request, response));
+routes.post("/", (request, response) =>
+  clientController.create(request, response)
+);
 
-routes.get("/", async (request, response) => await clientController.getAll(request, response));
+routes.get("/", (request, response) =>
+  clientController.getAll(request, response)
+);
 
-routes.get("/:cpf", async (request, response) => await clientController.getOne(request, response));
+routes.get("/:cpf", (request, response) =>
+  clientController.getOne(request, response)
+);
 
-routes.put("/:cpf", async (request, response) => await clientController.edit(request, response));
-
-routes.delete("/:cpf", async (request, response) => await clientController.destroy(request, response));
+routes.put("/:cpf", (request, response) =>
+  clientController.edit(request, response)
+);
 
+routes.delete("/:cpf", (request, response) =>
+  clientController.destroy(request, response)
+);
 
 export default routes;
diff --git a/src/routes/item.ts b/src/routes/item.ts
index 4eb7562..41b4479 100644
--- a/src/routes/item.ts
+++ b/src/routes/item.ts
@@ -1,19 +1,27 @@
 import { Router } from "express";
 
-import itemController from '../controllers/itemController';
+import itemController from "../controllers/itemController";
 
 const routes = Router();
 
-routes.post("/", async (request, response) => await itemController.create(request, response));
+routes.post("/", (request, response) =>
+  itemController.create(request, response)
+);
 
-routes.get("/", async (request, response) => await itemController.getAll(request, response));
+routes.get("/", (request, response) =>
+  itemController.getAll(request, response)
+);
 
-routes.get("/:id", async (request, response) => await itemController.getOne(request, response));
+routes.get("/:id", (request, response) =>
+  itemController.getOne(request, response)
+);
 
-routes.put("/:id", async (request, response) => await itemController.edit(request, response));
-
-routes.delete("/:id", async (request, response) => await itemController.destroy(request, response));
+routes.put("/:id", (request, response) =>
+  itemController.edit(request, response)
+);
 
+routes.delete("/:id", (request, response) =>
+  itemController.destroy(request, response)
+);
 
 export default routes;
-