@tasolutions/express-core/core/crud/getAllSchemaAuth.crud.js

All libs for express

const _ = require('lodash');
const Response = require('../../utils/v1Response');
const { buildResult } = require('./common/resultBuilder');
const { buildFieldList } = require('./common/fieldBuilder');
const actionList = require('../../utils/actionList');
const { buildFieldListFromInterface } = require('./common/fieldBuilderInterface');
const path = require('path');
const { buildResultFromInterface } = require('./common/resultBuilderInterface');
const { filterActions } = require('./auth/permission');
const { mapHeadersToQuery } = require('../../utils/requestHeader');
const interfacesPath = path.resolve(process.cwd(), 'src/interfaces');
const workflowsPath = path.resolve(process.cwd(), 'src/workflows');
const hooksPath = path.resolve(process.cwd(), 'src/hooks');

let interfacesMapping;
try {
    interfacesMapping = require(interfacesPath);
} catch (error) {
    console.error('[CORE][CRUD][GET_ALL_SCHEMA] Could not load `interfaces`');
    interfacesMapping = {};
}
let workflowsMapping;
try {
    workflowsMapping = require(workflowsPath);
} catch (error) {
    console.error('[CORE][CRUD][GET_ALL_SCHEMA] Could not load `workflows`');
    workflowsMapping = {};
}
let hooksMapping;
try {
    hooksMapping = require(hooksPath);
} catch (error) {
    console.error('[CORE][CRUD][GET_ALL_SCHEMA] Could not load `hooks`');
    hooksMapping = {};
}

module.exports = {
    getAllSchemaAuth: async (req, res, Collection, reqPath) => {
        try {
            await mapHeadersToQuery(req, Collection);
            const { action, user_identifier } = req.query;
            const moduleName = Collection.collection.collectionName;

            const normalizedModuleName = _.snakeCase(moduleName).replace(/_/g, '-');
            const regex = new RegExp(`(${_.escapeRegExp(moduleName)}|${normalizedModuleName})`, 'i');
            const segment = reqPath.replace(regex, '');
            const fieldList = await buildFieldList(Collection, segment);

            const actionLists = _.filter(actionList, { collection_key: moduleName, is_extend: false });
            const actionListsFiltered = await filterActions(user_identifier, actionLists);

            const actionExtends = _.filter(actionList, { collection_key: moduleName, is_extend: true });
            const actionExtendsFiltered = await filterActions(user_identifier, actionExtends);

            const workflowsObj = workflowsMapping[moduleName];
            const hook = hooksMapping[moduleName];

            let resultInterfaces = [];
            let actionIncludes = [];
            const actionPromises = actionExtendsFiltered.map(async (actionExtend) => {
                const interfaceKey = actionExtend.collection_key;
                const interfaceObj = interfacesMapping[interfaceKey][actionExtend.action];

                if (interfaceObj) {
                    const fieldListInterfaces = await buildFieldListFromInterface(interfaceObj, segment);
                    resultInterfaces.push(buildResultFromInterface(actionExtend, fieldListInterfaces));

                    actionIncludes.push({
                        function: actionExtend.includes,
                        action: {
                            action: actionExtend.action,
                            name: actionExtend.name,
                            is_enable: true,
                            color: '#fff',
                            method: actionExtend.method?.toUpperCase(),
                            type: actionExtend.type?.toUpperCase()
                        }
                    });
                }
            });
            await Promise.all(actionPromises);

            const overwriteActionPromises = actionLists.map(async (model) => {
                const interfaceKey = model.collection_key;
                const interfaceOverwriteObj = interfacesMapping[interfaceKey] && interfacesMapping[interfaceKey][model.type?.toLowerCase()] ? interfacesMapping[interfaceKey][model.type?.toLowerCase()] : null;
                if (interfaceOverwriteObj) {
                    const fieldListInterfaces = await buildFieldListFromInterface(interfaceOverwriteObj, segment);
                    model.action = model.type?.toLowerCase();
                    resultInterfaces.push(buildResultFromInterface(model, fieldListInterfaces));
                }
            });
            await Promise.all(overwriteActionPromises);

            const result = buildResult(Collection, reqPath, actionListsFiltered, fieldList, resultInterfaces, actionIncludes, workflowsObj, hook);
            const filteredResult = action ? { [action.toLowerCase()]: result[action.toLowerCase()] } : result;

            return Response.success(req, res, filteredResult, {}, {
                type: 'CRUD',
                action: 'GET_SCHEMA',
                typeName: moduleName,
                options: {}
            });
        } catch (e) {
            return Response.error(req, res, e.message);
        }
    }
};