feat: transactions updates

feat: transactions updates

Author: ilyaskarim

src/utils/middlewares.ts

@@ -21,7 +21,7 @@ export const validateYupSchemaAgainstAnObject = async function (schema: any, obj
 
 export const middlewareValidateYupSchemaAgainstReqBody = function (schema: any) {
   return async function (req: any, res: any, next: any) {
-    let validate = await validateYupSchemaAgainstAnObject(schema, req.body);
+    let validate = await validateYupSchemaAgainstAnObject(schema, req.body.input);
     if (validate.length > 0) {
       return res.status(400).json({
         message: "Validation Error",

src/v1/routes.ts

@@ -11,21 +11,21 @@ import {
   getTransactionsByUser,
   updateTransaction,
 } from "./transaction";
-import { transactionSchema } from "./transaction.validation";
+import { createTransactionSchema, updateTransactionSchema } from "./transaction.validation";
 
 const v1Routes = express.Router();
 
 v1Routes.post(
   "/createTransaction",
   validateUserExistsSentThroughReqBody("body.user_id"),
-  middlewareValidateYupSchemaAgainstReqBody(transactionSchema),
+  middlewareValidateYupSchemaAgainstReqBody(createTransactionSchema),
   createTransaction,
 );
 
 v1Routes.put(
   "/updateTransaction/:id",
   validateUserExistsSentThroughReqBody("body.user_id"),
-  middlewareValidateYupSchemaAgainstReqBody(transactionSchema),
+  middlewareValidateYupSchemaAgainstReqBody(updateTransactionSchema),
   updateTransaction,
 );
 

src/v1/transaction.ts

@@ -6,7 +6,7 @@ export const createTransaction = async (req: Request, res: Response) => {
   try {
     // Check if wallet_id exists
     const wallet = await prisma.wallet.findUnique({
-      where: { id: req.body.wallet_id },
+      where: { id: req.body.input.wallet_id },
     });
     if (!wallet) {
       return res.status(400).json({ message: "Wallet not found" });
@@ -15,10 +15,10 @@ export const createTransaction = async (req: Request, res: Response) => {
     // Create transaction
     let response = await prisma.transaction.create({
       data: {
-        transaction_type: req.body.transaction_type,
-        user_id: req.body.user_id,
-        wallet_id: req.body.wallet_id,
-        amount: req.body.amount,
+        transaction_type: req.body.input.transaction_type,
+        user_id: req.body.input.user_id,
+        wallet_id: req.body.input.wallet_id,
+        amount: req.body.input.amount,
       },
     });
 
@@ -34,7 +34,7 @@ export const createTransaction = async (req: Request, res: Response) => {
 export const updateTransaction = async (req: Request, res: Response) => {
   try {
     const { id } = req.params;
-    const updateData = req.body;
+    const updateData = req.body.input;
 
     // Check if transaction exists
     const existingTransaction = await prisma.transaction.findUnique({
@@ -46,7 +46,7 @@ export const updateTransaction = async (req: Request, res: Response) => {
 
     if (updateData.wallet_id) {
       const wallet = await prisma.wallet.findUnique({
-        where: { id: updateData.wallet_id },
+        where: { id: existingTransaction.wallet_id },
       });
       if (!wallet) {
         return res.status(400).json({ message: "Wallet not found" });
@@ -140,7 +140,10 @@ export const getTransactionsByUser = async (req: Request, res: Response) => {
       },
     });
 
-    res.status(200).json(transactions);
+    res.status(200).json({
+      transactions: transactions,
+      message: "Transactions retrieved successfully",
+    });
   } catch (e) {
     generateError(res, e);
   }

src/v1/transaction.validation.ts

@@ -1,42 +1,33 @@
-import * as yup from "yup";
+import { object, string, number, InferType, date } from "yup";
 
-// Define the transaction validation schema
-export const transactionSchema = yup.object({
-  transaction_type: yup
-    .string()
+export const createTransactionSchema = object({
+  transaction_type: string()
     .required("Transaction type is required")
     .oneOf(["credit", "debit"], "Transaction type must be either credit or debit"),
-  user_id: yup
-    .number()
+  user_id: number()
     .required("User ID is required")
     .positive("User ID must be a positive integer")
     .integer("User ID must be an integer"),
-  wallet_id: yup
-    .number()
+  wallet_id: number()
     .required("Wallet ID is required")
     .positive("Wallet ID must be a positive integer")
     .integer("Wallet ID must be an integer"),
-  amount: yup
-    .number()
+  amount: number()
     .required("Amount is required")
     .positive("Amount must be a positive integer")
     .integer("Amount must be an integer"),
-  created_at: yup
-    .date()
+  created_at: date()
     .default(() => new Date())
     .required("Creation date is required"),
-  updated_at: yup
-    .date()
+  updated_at: date()
     .default(() => new Date())
     .required("Update date is required"),
 });
+export type CreateTransactionSchema = InferType<typeof createTransactionSchema>;
 
-// Define the type for the expected shape of the transaction data
-export interface TransactionData {
-  transaction_type: "credit" | "debit";
-  user_id: number;
-  wallet_id: number;
-  amount: number;
-  created_at: Date;
-  updated_at: Date;
-}
+export const updateTransactionSchema = object({
+  transaction_type: string().optional().oneOf(["credit", "debit"], "Transaction type must be either credit or debit"),
+  user_id: number().optional().positive("User ID must be a positive integer").integer("User ID must be an integer"),
+  amount: number().optional().positive("Amount must be a positive integer").integer("Amount must be an integer"),
+});
+export type UpdateTransactionSchema = InferType<typeof updateTransactionSchema>;

src/v1/user.validation.ts

@@ -1,4 +1,4 @@
-import { object, string, number, date, InferType } from "yup";
+import { object, string, number, InferType } from "yup";
 
 export const createUserSchema = object({
   username: string().required("Username is required"),