Création d'une API avec TypeScript¶

Econoris_server
├── Database
│   ├── Dockerfile
│   ├── functions
│   │   └── 001-update_updated_at.sql
│   ├── migrations
│   ├── schema
│   │   └── 102-operations.sql
│   ├── seed
│   ├── triggers
│   │   └── 201-update_updated_at.sql
│   └── views
├── public
│   ├── econoris_logo-1024.png
│   ├── econoris_logo-144.png
│   ├── econoris_logo-16.png
│   ├── econoris_logo-192.png
│   ├── econoris_logo-512.png
│   ├── econoris_logo-72.png
│   ├── econoris_logo-96.png
│   ├── favicon.ico
│   └── favicon.png
├── src
│   ├── app.ts
│   ├── config
│   │   └── AppConfig.ts
│   ├── core
│   │   ├── cron
│   │   │   ├── generate_subscription_operations.job.ts
│   │   │   └── validate_operations.job.ts
│   │   ├── email
│   │   │   ├── error.email.ts
│   │   │   ├── mailer.ts
│   │   │   └── mailTemplate.ts
│   │   ├── middlewares
│   │   │   ├── default_route.middleware.ts
│   │   │   ├── error.middleware.ts
│   │   │   ├── helmet_http_headers.middleware.ts
│   │   │   ├── rate_limiter.middleware.ts
│   │   │   └── validators
│   │   │       ├── auth_validator.middleware.ts
│   │   │       ├── body_validator.middleware.ts
│   │   │       └── params_query_validator.middleware.ts
│   │   ├── models
│   │   │   ├── AppError.model.ts
│   │   │   └── Database.model.ts
│   │   └── utils
│   │       └── logger.ts
│   ├── modules
│   │   ├── auth
│   │   │   ├── auth.schema.ts
│   │   │   └── auth.types.ts
│   │   ├── operations
│   │   │   ├── operations.controller.ts
│   │   │   ├── operations.repository.ts
│   │   │   ├── operations.routes.ts
│   │   │   ├── operations.schema.ts
│   │   │   ├── operations.service.ts
│   │   │   ├── operations.swagger.ts
│   │   │   └── operations.types.ts
│   ├── server.ts
│   └── swagger
│       └── swagger.ts
├── tests
│   ├── modules
│   │   ├── auth
│   │   │   └── auth.spec.ts
│   │   └── operations
│   │       └── operations.spec.ts
│   └── setup.ts
├── docker-compose.dev.yml
├── docker-compose.yml
├── Dockerfile
├── tsconfig.json
├── jest.config.ts
├── package.json
├── package-lock.json
└── README.md

example_module
├── example_module.schema.ts     # Représente les schémas de validation Zod pour le module
├── example_module.types.ts      # Définit les types TypeScript spécifiques au module (à l'aide de z.infer(<ZodSchema>))
├── example_module.swagger.ts    # Définit la documentation Swagger pour le module
├── example_module.routes.ts     # URI routes pour le module avec les middlewares associés (validators, puis appel du controller)
├── example_module.controller.ts # Récupère les données de la requête, appelle le service approprié, puis renvoie la réponse au client
├── example_module.service.ts    # Contient la logique métier principale du module
└── example_module.repository.ts # Gère l'accès aux données et les opérations CRUD pour le module

import { z, ZodDate, ZodNumber } from "zod";



/*========*/
/* SELECT */
/*========*/
export const OperationsSchema = z.object({
    id: z.int().min(1),
    levy_date: z.date().default(new Date()),
    label: z.string().trim().min(1).max(255),
    amount: z.number(),
    category: z.string().trim().min(1).max(255),

    source: z.string().trim().max(255).nullable().default(null),
    destination: z.string().trim().max(255).nullable().default(null),
    costs: z.number().default(0.0),
    is_validate: z.boolean().default(false),

    user_id: z.int().min(1),
    subscription_id: z.int().min(1).nullable().default(null),

    created_at: z.date().readonly(),
    updated_at: z.date().readonly(),
});



/*========*/
/* INSERT */
/*========*/
export const OperationsInsertSchema = OperationsSchema.extend({
    user_id: OperationsSchema.shape.user_id.optional(),
    levy_date: z.preprocess<unknown, ZodDate>(
        (val) => typeof val === "string" ? new Date(val) : val,
        z.date(),
    ),
}).omit({
    id: true,

    created_at: true,
    updated_at: true,
});



/*========*/
/* UPDATE */
/*========*/
export const OperationsIdUpdateSchema = z.object({
    id: z.preprocess<unknown, ZodNumber>(
        (val) => typeof val === "string" ? Number(val.trim()) : val,
        z.int().min(1),
    ),
});

export const OperationsUpdateSchema = OperationsInsertSchema.extend({
    id: OperationsSchema.shape.id,
});



/*========*/
/* DELETE */
/*========*/
export const OperationsIdDeleteSchema = OperationsIdUpdateSchema;

import { z } from "zod";
import { OperationsSchema, OperationsInsertSchema, OperationsUpdateSchema, OperationsIdUpdateSchema, OperationsIdDeleteSchema } from "./operations.schema";


/* SELECT */
export type Operation = z.infer<typeof OperationsSchema>;

/* INSERT */
export type OperationInsert = z.infer<typeof OperationsInsertSchema>;

/* UPDATE */
export type OperationsIdUpdate = z.infer<typeof OperationsIdUpdateSchema>;
export type OperationUpdate = z.infer<typeof OperationsUpdateSchema>;

/* DELETE */
export type OperationsIdDelete = z.infer<typeof OperationsIdDeleteSchema>;

/*========*/
/* SELECT */
/*========*/
/**
 * @swagger
 * components:
 *   schemas:
 *     Operations:
 *       type: object
 *       required:
 *         - id
 *         - levy_date
 *         - label
 *         - amount
 *         - category
 *         - source
 *         - destination
 *         - costs
 *         - is_validate
 *         - user_id
 *         - subscription_id
 *         - created_at
 *         - updated_at
 *       properties:
 *         id:
 *           type: number
 *           exemple: 1
 *         levy_date:
 *           type: string
 *           exemple: "2024-01-01T00:00:00.000Z"
 *         label:
 *           type: string
 *           exemple: "Sample Operation"
 *         amount:
 *           type: number
 *           exemple: 100.00
 *         category:
 *           type: string
 *           exemple: "Income"
 *         source:
 *           type: string
 *           exemple: "Job"
 *         destination:
 *           type: string
 *           exemple: "Bank"
 *         costs:
 *           type: number
 *           exemple: 2.50
 *         is_validate:
 *           type: boolean
 *           exemple: true
 *         user_id:
 *           type: number
 *           exemple: 1
 *         subscription_id:
 *           type: number|null
 *           exemple: 1
 *         created_at:
 *           type: string
 *           exemple: "2024-01-01T00:00:00.000Z"
 *         updated_at:
 *           type: string
 *           exemple: "2024-01-01T00:00:00.000Z"
 */


/*========*/
/* INSERT */
/*========*/
/**
 * @swagger
 * components:
 *   schemas:
 *     OperationsInsert:
 *       type: object
 *       required:
 *         - levy_date
 *         - label
 *         - amount
 *         - category
 *       properties:
 *         levy_date:
 *           type: string
 *           exemple: "2024-01-01T00:00:00.000Z"
 *         label:
 *           type: string
 *           exemple: "Sample Operation"
 *         amount:
 *           type: number
 *           exemple: 100.00
 *         category:
 *           type: string
 *           exemple: "Income"
 *         source:
 *           type: string
 *           exemple: "Job"
 *         destination:
 *           type: string
 *           exemple: "Bank"
 *         costs:
 *           type: number
 *           exemple: 2.50
 *         is_validate:
 *           type: boolean
 *           exemple: true
 */


/*========*/
/* UPDATE */
/*========*/
/**
 * @swagger
 * components:
 *   schemas:
 *     OperationsUpdate:
 *       type: object
 *       required:
 *         - levy_date
 *         - label
 *         - amount
 *         - category
 *         - source
 *         - destination
 *         - costs
 *         - is_validate
 *       properties:
 *         levy_date:
 *           type: string
 *           exemple: "2024-01-01T00:00:00.000Z"
 *         label:
 *           type: string
 *           exemple: "Sample Operation"
 *         amount:
 *           type: number
 *           exemple: 100.00
 *         category:
 *           type: string
 *           exemple: "Income"
 *         source:
 *           type: string
 *           exemple: "Job"
 *         destination:
 *           type: string
 *           exemple: "Bank"
 *         costs:
 *           type: number
 *           exemple: 2.50
 *         is_validate:
 *           type: boolean
 *           exemple: true
 */

import { Router } from "express";
import * as OperationsController from "./operations.controller";
import { bodyValidator } from "../../core/middlewares/validators/body_validator.middleware";
import { OperationsIdDeleteSchema, OperationsIdUpdateSchema, OperationsInsertSchema, OperationsUpdateSchema } from "./operations.schema";
import { paramsQueryValidator } from "../../core/middlewares/validators/params_query_validator.middleware";

const router = Router();

/*========*/
/* SELECT */
/*========*/
/**
 * @swagger
 * /operations:
 *   get:
 *     tags:
 *       - Operations
 *     summary: Retrieve a list of operations of the authenticated user
 *     description: Retrieve a list of operations associated with the authenticated user.
 *     parameters:
 *       - in: headers
 *         name: Authorization
 *         required: true
 *         schema:
 *           type: string
 *           example: "Bearer <token>"
 *     responses:
 *       200:
 *         description: A list of operations
 *         content:
 *           application/json:
 *             schema:
 *               type: array
 *               items:
 *                 $ref: '#/components/schemas/Operations'
 *       204:
 *         description: No content. No operations found.
 *       401:
 *         description: Unauthorized access.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error401'
 *       500:
 *         description: Internal server error. Please create an issue on Github
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error500'
 */
router.get('/', OperationsController.selectOperations);


/*========*/
/* INSERT */
/*========*/
/**
 * @swagger
 * /operations:
 *   post:
 *     tags:
 *       - Operations
 *     summary: Create a new operation for the authenticated user
 *     description: Create a new operation associated with the authenticated user.
 *     parameters:
 *       - in: headers
 *         name: Authorization
 *         required: true
 *         schema:
 *           type: string
 *           example: "Bearer <token>"
 *       - in: body
 *         name: operation
 *         required: true
 *         description: Operation object that needs to be added
 *         schema:
 *           $ref: '#/components/schemas/OperationsInsert'
 *     responses:
 *       201:
 *         description: Created operation
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Operations'
 *       400:
 *         description: Bad request. Please check the input data.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error400'
 *       401:
 *         description: Unauthorized access.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error401'
 *       500:
 *         description: Internal server error. Please create an issue on Github
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error500'
 */
router.post('/', bodyValidator(OperationsInsertSchema), OperationsController.insertOperations);


/*========*/
/* UPDATE */
/*========*/
/**
 * @swagger
 * /operations:
 *   put:
 *     tags:
 *       - Operations
 *     summary: Update an existing operation for the authenticated user
 *     description: Update an existing operation associated with the authenticated user.
 *     parameters:
 *       - in: headers
 *         name: Authorization
 *         required: true
 *         schema:
 *           type: string
 *           example: "Bearer <token>"
 *       - in: path
 *         name: id
 *         required: true
 *         schema:
 *           type: integer
 *           example: 1
 *       - in: body
 *         name: operation
 *         required: true
 *         description: Operation object that needs to be updated
 *         schema:
 *           $ref: '#/components/schemas/OperationsUpdate'
 *     responses:
 *       200:
 *         description: Updated operation
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Operations'
 *       400:
 *         description: Bad request. Please check the input data.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error400'
 *       401:
 *         description: Unauthorized access.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error401'
 *       500:
 *         description: Internal server error. Please create an issue on Github
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error500'
 */
router.put('/:id', paramsQueryValidator(OperationsIdUpdateSchema), bodyValidator(OperationsUpdateSchema), OperationsController.updateOperations);


/*========*/
/* DELETE */
/*========*/
/**
 * @swagger
 * /operations:
 *   delete:
 *     tags:
 *       - Operations
 *     summary: Delete an existing operation for the authenticated user
 *     description: Delete an existing operation associated with the authenticated user.
 *     parameters:
 *       - in: headers
 *         name: Authorization
 *         required: true
 *         schema:
 *           type: string
 *           example: "Bearer <token>"
 *       - in: path
 *         name: id
 *         required: true
 *         schema:
 *           type: integer
 *           example: 1
 *     responses:
 *       200:
 *         description: Deleted operation
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Operations'
 *       400:
 *         description: Bad request. Please check the input data.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error400'
 *       401:
 *         description: Unauthorized access.
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error401'
 *       500:
 *         description: Internal server error. Please create an issue on Github
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/error500'
 */
router.delete('/:id', paramsQueryValidator(OperationsIdDeleteSchema), OperationsController.deleteOperations);

export default router;

import { Request, Response, NextFunction } from 'express';
import * as OperationsService from './operations.service';
import { OperationInsert, OperationUpdate } from './operations.types';



/*========*/
/* SELECT */
/*========*/
/**
 * Get all operations for a user.
 * @param req.body.user The user object containing the user ID.
 * @param res The response object.
 * @param next The next middleware function.
 */
export const selectOperations = async (req: Request, res: Response, next: NextFunction) => {
    try {
        const userId: number = req.body.user.id;

        const operations = await OperationsService.selectOperations(userId);
        res.status(operations.length ? 200 : 204).json(operations);
    } catch (error) {
        next(error);
    }
};


/*========*/
/* INSERT */
/*========*/
/**
 * Insert a new operation for a user.
 * @param req.body.user The user object containing the user ID.
 * @param req.body.validatedData.body The validated operation data to insert.
 * @param res The response object.
 * @param next The next middleware function.
 */
export const insertOperations = async (req: Request, res: Response, next: NextFunction) => {
    try {
        const operationData: OperationInsert = { ...req.body.validatedData.body, user_id: req.body.user.id };

        const newOperation = await OperationsService.insertOperations(operationData);
        res.status(201).json(newOperation);
    } catch (error) {
        next(error);
    }
};


/*========*/
/* UPDATE */
/*========*/
/**
 * Update an existing operation for a user.
 * @param req.body.user The user object containing the user ID.
 * @param req.body.validatedData.body The validated operation data to update.
 * @param res The response object.
 * @param next The next middleware function.
 */
export const updateOperations = async (req: Request, res: Response, next: NextFunction) => {
    try {
        const operationData: OperationUpdate = { ...req.body.validatedData.body, id: req.body.validatedData.params.id, user_id: req.body.user.id };

        const operations = await OperationsService.updateOperations(operationData);
        res.status(200).json(operations);
    } catch (error) {
        next(error);
    }
};


/*========*/
/* DELETE */
/*========*/
/**
 * Delete an operation for a user.
 * @param req.body.user The user object containing the user ID.
 * @param req.body.validatedData.params.id The ID of the operation to delete.
 * @param res The response object.
 * @param next The next middleware function.
 */
export const deleteOperations = async (req: Request, res: Response, next: NextFunction) => {
    try {
        const userId: number = req.body.user.id;
        const operationId: number = req.body.validatedData.params.id;

        const operations = await OperationsService.deleteOperations(userId, operationId);
        res.status(200).json(operations);
    } catch (error) {
        next(error);
    }
};

import { Operation, OperationInsert, OperationUpdate } from './operations.types';
import * as OperationsRepository from './operations.repository';
import { OperationsInsertSchema, OperationsSchema, OperationsUpdateSchema } from './operations.schema';
import { ZodError } from 'zod';
import { AppError } from '../../core/models/AppError.model';
import { addDays, addWeeks, addMonths, isAfter, endOfMonth } from 'date-fns';
import { updateSubscriptionsLastGeneratedAt } from '../subscriptions/subscriptions.service';
import { Subscription } from '../subscriptions/subscriptions.types';
import { SubscriptionsSchema } from '../subscriptions/subscriptions.schema';



/*========*/
/* SELECT */
/*========*/
/**
 * Get all operations for a user.
 * @param userId The ID of the user.
 * @returns An array of Operation objects.
 * @throws AppError if there is an issue retrieving the operations.
 */
export async function selectOperations(userId: number): Promise<Operation[]> {
    try {
        const operations = await OperationsRepository.selectOperations(userId);
        return OperationsSchema.array().parse(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operations", 500) : error;
    }
}

/**
 * Get all invalid operations.
 * @returns An array of Operation objects.
 * @throws AppError if there is an issue retrieving the operations.
 */
export async function selectAllOperationsInvalidate(): Promise<Operation[]> {
    try {
        const operations = await OperationsRepository.selectAllOperationsInvalidate();
        return OperationsSchema.array().parse(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operations", 500) : error;
    }
}


/*========*/
/* INSERT */
/*========*/
/**
 * Insert a new operation for a user.
 * @param operationData The operation data to insert.
 * @returns The newly created Operation object.
 * @throws AppError if there is an issue inserting the operation.
 */
export async function insertOperations(operationData: OperationInsert): Promise<Operation> {
    try {
        const operations = await OperationsRepository.insertOperations(operationData);
        return OperationsSchema.parse(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operation (operation inserted successfully)", 500) : error;
    }
}

/**
 * Insert multiple operations for a user in bulk.
 * @param operations The array of operation data to insert.
 * @throws AppError if there is an issue inserting the operations.
 */
export async function insertBulkOperations(operationsData: OperationInsert[]): Promise<void> {
    if (operationsData.length === 0) return;

    try {
        const operations: OperationInsert[] = OperationsInsertSchema.array().parse(operationsData);

        const chunkSize = 500;
        if (operations.length > chunkSize) {
            const chunks: OperationInsert[][] = [];
            for (let i = 0; i < operations.length; i += chunkSize) {
                chunks.push(operations.slice(i, i + chunkSize));
            }
            await Promise.all(chunks.map((chunk: OperationInsert[]) => OperationsRepository.insertBulkOperations(chunk)));
            return;
        }

        await OperationsRepository.insertBulkOperations(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operations bulk", 500) : error;
    }
}

/**
 * Generate missing operations for a subscription up to the current date.
 * @param subscription The subscription object.
 * @throws AppError if there is an issue generating the operations.
 */
export async function insertMissingOperations(subscription: Subscription): Promise<void> {
    let parsedSubscription: Subscription;
    try {
        parsedSubscription = SubscriptionsSchema.parse(subscription);
    } catch (error) {
        throw new AppError("Failed to parse subscription", 500);
    }

    try {
        const operationsToInsert: OperationInsert[] = [];

        let currentDate: Date = parsedSubscription.last_generated_at ?? parsedSubscription.start_date;
        const now: Date = new Date();

        const endOfCurrentMonth: Date = endOfMonth(now);

        // Ajout de l'opération pour le mois de début si aucune opération n'a encore été générée
        if (!parsedSubscription.last_generated_at) {
            let is_validate = currentDate <= now;
            operationsToInsert.push({
                levy_date: currentDate,
                label: parsedSubscription.label,
                amount: parsedSubscription.amount,
                category: parsedSubscription.category,
                source: parsedSubscription.source,
                destination: parsedSubscription.destination,
                costs: parsedSubscription.costs,
                is_validate,
                subscription_id: parsedSubscription.id,
                user_id: parsedSubscription.user_id,
            });
        }

        while (true) {
            let nextDate = getNextDate(currentDate, parsedSubscription.interval_unit, parsedSubscription.interval_value);

            if (parsedSubscription.interval_unit === 'months' && parsedSubscription.day_of_month) {
                nextDate.setDate(parsedSubscription.day_of_month);
            }

            if (parsedSubscription.end_date && isAfter(nextDate, parsedSubscription.end_date)) break;
            if (isAfter(nextDate, endOfCurrentMonth)) break;

            let is_validate = nextDate <= now;
            operationsToInsert.push({
                levy_date: nextDate,
                label: parsedSubscription.label,
                amount: parsedSubscription.amount,
                category: parsedSubscription.category,
                source: parsedSubscription.source,
                destination: parsedSubscription.destination,
                costs: parsedSubscription.costs,
                is_validate,
                subscription_id: parsedSubscription.id,
                user_id: parsedSubscription.user_id,
            });

            currentDate = nextDate;
        }

        if (operationsToInsert.length > 0) {
            await insertBulkOperations(operationsToInsert);
            await updateSubscriptionsLastGeneratedAt(parsedSubscription.id, currentDate);
        }
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to generate missing operations", 500);
    }
}


/*========*/
/* UPDATE */
/*========*/
/**
 * Update an existing operation for a user.
 * @param operationData The operation data to update.
 * @returns The updated Operation object.
 */
export async function updateOperations(operationData: OperationUpdate): Promise<Operation> {
    try {
        const operations = await OperationsRepository.updateOperations(operationData);
        return OperationsSchema.parse(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operation (operation updated successfully)", 500) : error;
    }
}

/**
 * Update multiple operations validate status in bulk.
 * @param operations The array of operation data to update.
 * @param isValidate The validate status to set.
 * @throws AppError if there is an issue updating the operations.
 */
export async function updateBulkOperationsValidate(operations: OperationUpdate[], isValidate: boolean): Promise<void> {
    try {
        const parsedOperations = OperationsUpdateSchema.array().parse(operations);

        const chunkSize = 500;
        if (parsedOperations.length > chunkSize) {
            const chunks: OperationUpdate[][] = [];
            for (let i = 0; i < parsedOperations.length; i += chunkSize) {
                chunks.push(parsedOperations.slice(i, i + chunkSize));
            }
            await Promise.all(chunks.map((chunk: OperationUpdate[]) => OperationsRepository.updateBulkOperationsValidate(chunk, isValidate)));
            return;
        }

        await OperationsRepository.updateBulkOperationsValidate(parsedOperations, isValidate);
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to update operations validate status", 500);
    }
}


/*========*/
/* DELETE */
/*========*/
/**
 * Delete an operation for a user.
 * @param userId The ID of the user.
 * @param operationId The ID of the operation to delete.
 * @returns The deleted Operation object.
 * @throws AppError if there is an issue deleting the operation.
 */
export async function deleteOperations(userId: number, operationId: number): Promise<Operation> {
    try {
        const operations = await OperationsRepository.deleteOperations(userId, operationId);
        return OperationsSchema.parse(operations);
    } catch (error) {
        throw (error instanceof ZodError) ? new AppError("Failed to parse operation (operation deleted successfully)", 500) : error;
    }
}


/*===========*/
/* UTILITIES */
/*===========*/
/**
 * Get the next date based on the current date, interval unit, and value.
 * @param current Current date
 * @param unit Interval unit ('days', 'weeks', 'months')
 * @param value Interval value
 * @returns The next date
 * @throws AppError if the interval unit is unsupported
 */
function getNextDate(current: Date, unit: string, value: number): Date {
    switch (unit) {
        case 'days':
            return addDays(current, value);
        case 'weeks':
            return addWeeks(current, value);
        case 'months':
            return addMonths(current, value);
        default:
            throw new AppError(`Unsupported interval unit : ${unit}`, 400);
    }
}

import { AppError } from "../../core/models/AppError.model";
import { Database } from "../../core/models/Database.model";
import { Operation, OperationInsert, OperationUpdate } from "./operations.types";



/*========*/
/* SELECT */
/*========*/
/**
 * Get all operations for a user.
 * @param userId The ID of the user.
 * @returns An array of Operation objects.
 * @throws AppError if there is an issue retrieving the operations.
 */
export async function selectOperations(userId: number): Promise<Operation[]> {
    try {
        let query = "SELECT * FROM operations WHERE user_id = $1;";
        let values = [userId];

        const operations = await Database.execute<Operation>({ text: query, values: values });

        /* Automatic conversion of amount and costs fields to Number */
        operations.forEach(op => {
            if (typeof op.amount === 'string') op.amount = Number(op.amount);
            if (typeof op.costs === 'string') op.costs = Number(op.costs);
        });

        return operations
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to retrieve operations", 500);
    }
}

/**
 * Get all invalid operations.
 * @returns An array of Operation objects.
 * @throws AppError if there is an issue retrieving the operations.
 */
export async function selectAllOperationsInvalidate(): Promise<Operation[]> {
    try {
        const query = "SELECT * FROM operations WHERE is_validate = false AND levy_date <= CURRENT_DATE;";

        const operations = await Database.execute<Operation>({ text: query, values: [] });

        /* Automatic conversion of amount and costs fields to Number */
        operations.forEach(op => {
            if (typeof op.amount === 'string') op.amount = Number(op.amount);
            if (typeof op.costs === 'string') op.costs = Number(op.costs);
        });

        return operations;
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to retrieve invalid operations", 500);
    }
}


/*========*/
/* INSERT */
/*========*/
/**
 * Insert a new operation for a user.
 * @param operationData The operation data to insert.
 * @returns The newly created Operation object.
 * @throws AppError if there is an issue inserting the operation.
 */
export async function insertOperations(operationData: OperationInsert): Promise<Operation> {
    try {
        const keys = Object.keys(operationData);
        const columns = keys.join(", ");
        const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");

        const values = keys.map(key => (operationData as any)[key]);
        const query = `INSERT INTO operations (${columns}) VALUES (${placeholders}) RETURNING *;`;

        const rows = await Database.execute<Operation>({ text: query, values: values });
        if (rows.length === 0) { throw new AppError("No operation inserted", 500); }

        /* Automatic conversion of amount and costs fields to Number */
        const result = { ...rows[0] };
        if (typeof result.amount === 'string') result.amount = Number(result.amount);
        if (typeof result.costs === 'string') result.costs = Number(result.costs);

        return result;
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to insert operations", 500);
    }
}

/**
 * Insert multiple operations for a user in bulk.
 * @param operations The array of operation data to insert.
 * @returns void
 * @throws AppError if there is an issue inserting the operations.
 */
export async function insertBulkOperations(operations: OperationInsert[]): Promise<void> {
    if (operations.length === 0) return;

    try {
        const keys = Object.keys(operations[0]);
        const columns = keys.join(", ");
        let query = `INSERT INTO operations (${columns}) VALUES `;
        const values: any[] = [];

        let valueIndex = 1;
        for (const operation of operations) {
            const placeholders = keys.map((_, i) => `$${valueIndex++}`).join(", ");
            query += `(${placeholders}), `;
            values.push(...keys.map(key => (operation as any)[key]));
        }

        query = query.slice(0, -2) + ";";
        await Database.execute({ text: query, values });
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to insert bulk operations", 500);
    }
}


/*========*/
/* UPDATE */
/*========*/
/**
 * Update an existing operation for a user.
 * @param operationData The operation data to update.
 * @returns The updated Operation object.
 */
export async function updateOperations(operationData: OperationUpdate): Promise<Operation> {
    try {
        /* Extract id and user_id, prepare fields to update */
        const { id, user_id, ...fieldsToUpdate } = operationData;
        const keys = Object.keys(fieldsToUpdate);

        if (!id || !user_id || keys.length === 0) {
            throw new AppError("Missing data to update", 400);
        }

        /* Build SET clause and values */
        const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
        const values = keys.map(key => (fieldsToUpdate as any)[key]);

        /* Append id and user_id to values for WHERE clause */
        const query = `UPDATE operations SET ${setClause} WHERE id = $${values.length + 1} AND user_id = $${values.length + 2} RETURNING *;`;
        values.push(id, user_id);

        /* Execute query */
        const rows = await Database.execute<Operation>({ text: query, values });
        if (rows.length === 0) { throw new AppError("No operation updated", 404); }

        /* Automatic conversion of amount and costs fields to Number */
        const result = { ...rows[0] };
        if (typeof result.amount === 'string') result.amount = Number(result.amount);
        if (typeof result.costs === 'string') result.costs = Number(result.costs);

        return result;
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to update operations", 500);
    }
}

/**
 * Update multiple operations validate status in bulk.
 * @param operations The array of operation data to update.
 * @param isValidate The validate status to set.
 * @throws AppError if there is an issue updating the operations.
 */
export async function updateBulkOperationsValidate(operations: OperationUpdate[], isValidate: boolean): Promise<void> {
    try {
        const query = "UPDATE operations SET is_validate = $1 WHERE ";
        const values: any[] = [isValidate];

        const conditions = operations.map<string>((operation, _index) => {
            values.push(operation.id, operation.user_id);
            return `(id = $${values.length - 1} AND user_id = $${values.length})`;
        }).join(" OR ");

        const finalQuery = query + conditions + ";";
        await Database.execute({ text: finalQuery, values });
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to update operations validate status", 500);
    }
}


/*========*/
/* DELETE */
/*========*/
/**
 * Delete an operation for a user.
 * @param userId The ID of the user.
 * @param operationId The ID of the operation to delete.
 * @returns The deleted Operation object.
 * @throws AppError if there is an issue deleting the operation.
 */
export async function deleteOperations(userId: number, operationId: number): Promise<Operation> {
    try {
        const query = `DELETE FROM operations WHERE id = $1 AND user_id = $2 RETURNING *;`;
        const values = [operationId, userId];

        const rows = await Database.execute<Operation>({ text: query, values });
        if (rows.length === 0) { throw new AppError("No operation deleted", 404); }

        /* Automatic conversion of amount and costs fields to Number */
        const result = { ...rows[0] };
        if (typeof result.amount === 'string') result.amount = Number(result.amount);
        if (typeof result.costs === 'string') result.costs = Number(result.costs);

        return result;
    } catch (error) {
        throw (error instanceof AppError) ? error : new AppError("Failed to delete operations", 500);
    }
}