@tasolutions/express-core/utils/v1Response.js

All libs for express

'use strict';
const { logger } = require('../loggers');
const { httpStatus } = require('./httpStatus');
const { messageSuccess, messageError } = require('./responseMessage');

module.exports = {
    success: async function (req, res, data, message = {}, crudOptions = { type: 'DEFAULT', action: 'DEFAULT', typeName: 'default', options: {} }) {
        const statusCode = req.method === 'POST' ? httpStatus.CREATED : httpStatus.OK;

        try {
            logger.info(`Success received request: ${req.method} ${req.originalUrl}`, {
                method: req.method,
                url: req.originalUrl,
                body: req.body,
                query: req.query,
                headers: req.headers,
                message: message.toString(),
                time: new Date().toISOString()
            });

            const { type, action, typeName, options } = crudOptions;
            const defaultMessageTemplate = createDefaultMessageTemplate(message, type, action, typeName);
            const formattedData = formatData(data, crudOptions.action, typeName, options);
            const mes = await messageSuccess(
                defaultMessageTemplate.layer,
                defaultMessageTemplate.class_name,
                defaultMessageTemplate.function_name,
                defaultMessageTemplate.case_name,
                defaultMessageTemplate.message,
                statusCode,
                data,
                req.headers['accept-language'] || 'en'
            );

            return res.status(statusCode).json({
                message: mes.message,
                meta: formattedData.meta || {},
                data: formattedData.data || {},
                debug: mes
            });
        } catch (error) {
            console.error("Error in success handler:", error);
            return this.error(req, res, error);
        }
    },

    error: async function (req, res, e, crudOptions = { type: 'DEFAULT', action: 'DEFAULT', typeName: 'default', options: {} }) {
        const message = e.message || 'Something goes wrong, please try again or contact the administrator.';
        const statusCode = e.statusCode || httpStatus.BAD_REQUEST;

        try {
            logError(req, message);
            const defaultResponseMessageTemplate = createDefaultResponseMessageTemplate(e.response_message_template, message, crudOptions);
            const mes = await messageError(
                defaultResponseMessageTemplate.layer,
                defaultResponseMessageTemplate.class_name,
                defaultResponseMessageTemplate.function_name,
                defaultResponseMessageTemplate.case_name,
                defaultResponseMessageTemplate.message,
                statusCode,
                req.body,
                req.headers['accept-language'] || 'en'
            );

            return res.status(statusCode).json({
                message: mes.message,
                error: mes.errorCode || '[ERROR_CODE] Not Found',
                statusCode: statusCode,
                debug: e ? JSON.stringify(e) : null
            });
        } catch (logError) {
            console.error('Logging failed:', logError);
            return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({ message: 'Internal Server Error' });
        }
    }
};

function createDefaultMessageTemplate(message, type, action, typeName) {
    return {
        layer: message.layer || (type === 'CRUD' ? type : `${action}_LAYER`),
        class_name: message.class_name || `${action}`,
        function_name: message.function_name || `${action}`,
        case_name: message.case_name || `${typeName}`,
        message: message.message || 'Successfully',
    };
}

function formatData(data, action, typeName, options) {
    switch (action) {
        case 'CREATE':
        case 'UPDATE':
        case 'DETAIL':
            return { data: { type: typeName, id: data?._id, attributes: { ...data.toObject() } }, meta: {} };
        case 'LIST_ALL':
            return {
                data: data.map(result => ({ type: typeName, attributes: { ...result } })),
                meta: {
                    limit: options?.limit || data.length,
                    current_page: 1,
                    total_entries: data.length,
                    total_pages: 1,
                    page: 1,
                    paging_counter: 1,
                    has_prev_page: false,
                    has_next_page: false,
                    prev_page: null,
                    next_page: null,
                }
            };
        case 'LIST':
            return {
                data: data.docs.map(result => ({ type: typeName, attributes: result })),
                meta: {
                    limit: data.limit,
                    current_page: data.page,
                    total_entries: data.totalDocs,
                    total_pages: data.totalPages,
                    page: data.page,
                    paging_counter: data.pagingCounter,
                    has_prev_page: data.hasPrevPage,
                    has_next_page: data.hasNextPage,
                    prev_page: data.prevPage,
                    next_page: data.nextPage,
                }
            };
        case 'OBJECT':
        case 'GET_BY_IDS':
        case 'COUNT':
        case 'GET_SCHEMA':
        case 'DELETE':
        case 'RESTORE':
            return { data: { type: typeName, attributes: data } };
        default:
            return { data: { type: typeName, id: data?._id, attributes: { ...data } }, meta: {} };
    }
}

function createDefaultResponseMessageTemplate(response_message_template, message, crudOptions) {
    const { type, action, typeName } = crudOptions;

    return {
        layer: response_message_template?.layer || 'DEFAULT_LAYER',
        class_name: response_message_template?.class_name || `${action}_${typeName}`,
        function_name: response_message_template?.function_name || 'DEFAULT_FUNCTION',
        case_name: response_message_template?.case_name || 'DEFAULT_CASE',
        message: response_message_template?.message || message,
    };
}

function logError(req, message) {
    logger.error(`Error received request: ${req.method} ${req.originalUrl}`, {
        method: req.method,
        url: req.originalUrl,
        body: req.body,
        query: req.query,
        headers: req.headers,
        message,
        time: new Date().toISOString()
    });
}