@grapi/server/lib/hooks/manyToMany.js

Grapi Schema Generator For GraphQL Server

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createHookMap = void 0;
const lodash_1 = require("../lodash");
const relation_1 = require("../relation");
const index_1 = require("./index");
const createHookMap = (relation) => {
    const relationImpl = new relation_1.ManyToManyRelation({
        modelA: relation.source,
        modelB: relation.target,
        modelAField: relation.sourceField,
        modelBField: relation.targetField,
    });
    const modelAField = relationImpl.getModelAField();
    const modelBField = relationImpl.getModelBField();
    const createForModelA = (sourceId, records, context) => {
        return Promise.all(records.map(async (record) => await relationImpl.createAndAddIdForModelA({ modelAId: sourceId, modelBData: record }, context)));
    };
    const connectForModelA = (sourceId, ids, context) => {
        return Promise.all(ids.map(id => relationImpl.addId({ modelAId: sourceId, modelBId: id }, context)));
    };
    const disconnectForModelA = (sourceId, ids, context) => {
        return Promise.all(ids.map(id => relationImpl.removeId({ modelAId: sourceId, modelBId: id }, context)));
    };
    const destroyForModelA = (sourceId, ids, context) => {
        return Promise.all(ids.map(async (id) => await relationImpl.deleteAndRemoveIdFromModelB({ modelAId: sourceId, modelBId: id }, context)));
    };
    const createForModelB = (sourceId, records, context) => {
        return Promise.all(records.map(async (record) => await relationImpl.createAndAddIdForModelB({ modelBId: sourceId, modelAData: record }, context)));
    };
    const connectForModelB = (sourceId, ids, context) => {
        return Promise.all(ids.map(id => relationImpl.addId({ modelBId: sourceId, modelAId: id }, context)));
    };
    const disconnectForModelB = (sourceId, ids, context) => {
        return Promise.all(ids.map(id => relationImpl.removeId({ modelAId: id, modelBId: sourceId }, context)));
    };
    const destroyForModelB = (sourceId, ids, context) => {
        return Promise.all(ids.map(id => relationImpl.deleteAndRemoveIdFromModelA({ modelAId: id, modelBId: sourceId }, context)));
    };
    return {
        [relationImpl.getModelA().getName()]: {
            wrapCreate: async (context, createOperation) => {
                const { data, graphqlContext } = context;
                const relationData = (0, lodash_1.get)(data, modelAField);
                if (!relationData) {
                    return createOperation();
                }
                const connectWhere = await (0, index_1.findUniqueObjectsOnModel)((0, lodash_1.get)(relationData, 'connect'), relationImpl.getModelB());
                const createRecords = (0, lodash_1.get)(relationData, 'create');
                context.data = (0, lodash_1.omit)(data, modelAField);
                await createOperation();
                const created = context.response;
                if (connectWhere) {
                    const connectIds = connectWhere.map(where => where.id);
                    await connectForModelA(created.id, connectIds, graphqlContext);
                }
                if (createRecords) {
                    await createForModelA(created.id, createRecords, graphqlContext);
                }
                return created;
            },
            wrapUpdate: async (context, updateOperation) => {
                const { where, data, graphqlContext } = context;
                const relationData = (0, lodash_1.get)(data, modelAField);
                if (!relationData) {
                    return updateOperation();
                }
                context.data = (0, lodash_1.omit)(data, modelAField);
                await updateOperation();
                const updated = context.response;
                const connectWhere = (0, lodash_1.get)(relationData, 'connect');
                const createRecords = (0, lodash_1.get)(relationData, 'create');
                const disconnectWhere = (0, lodash_1.get)(relationData, 'disconnect');
                const deleteWhere = (0, lodash_1.get)(relationData, 'delete');
                if (connectWhere) {
                    const connectIds = connectWhere.map(v => v.id);
                    await connectForModelA(where.id, connectIds, graphqlContext);
                }
                if (createRecords) {
                    await createForModelA(where.id, createRecords, graphqlContext);
                }
                if (disconnectWhere) {
                    const disconnectIds = disconnectWhere.map(v => v.id);
                    await disconnectForModelA(where.id, disconnectIds, graphqlContext);
                }
                if (deleteWhere) {
                    const deleteIds = deleteWhere.map(v => v.id);
                    await destroyForModelA(where.id, deleteIds, graphqlContext);
                }
                return updated;
            },
            resolveFields: {
                [relationImpl.getModelAField()]: (data, argument, graphqlContext) => {
                    return relationImpl.joinModelB(data.id, argument, graphqlContext);
                },
            },
        },
        [relationImpl.getModelB().getName()]: {
            wrapCreate: async (context, createOperation) => {
                const { data, graphqlContext } = context;
                const relationData = (0, lodash_1.get)(data, modelBField);
                if (!relationData) {
                    return createOperation();
                }
                const connectWhere = await (0, index_1.findUniqueObjectsOnModel)((0, lodash_1.get)(relationData, 'connect'), relationImpl.getModelA());
                const createRecords = (0, lodash_1.get)(relationData, 'create');
                context.data = (0, lodash_1.omit)(data, modelBField);
                await createOperation();
                const created = context.response;
                if ((0, lodash_1.isEmpty)(connectWhere) === false) {
                    const connectIds = connectWhere.map(where => where.id);
                    await connectForModelB(created.id, connectIds, graphqlContext);
                }
                if (createRecords) {
                    await createForModelB(created.id, createRecords, graphqlContext);
                }
                return created;
            },
            wrapUpdate: async (context, updateOperation) => {
                const { where, data, graphqlContext } = context;
                const relationData = (0, lodash_1.get)(data, modelBField);
                if (!relationData) {
                    return updateOperation();
                }
                context.data = (0, lodash_1.omit)(data, modelBField);
                await updateOperation();
                const updated = context.response;
                const connectWhere = (0, lodash_1.get)(relationData, 'connect');
                const createRecords = (0, lodash_1.get)(relationData, 'create');
                const disconnectWhere = (0, lodash_1.get)(relationData, 'disconnect');
                const deleteWhere = (0, lodash_1.get)(relationData, 'delete');
                if (connectWhere) {
                    const connectIds = connectWhere.map(v => v.id);
                    await connectForModelB(where.id, connectIds, graphqlContext);
                }
                if (createRecords) {
                    await createForModelB(where.id, createRecords, graphqlContext);
                }
                if (disconnectWhere) {
                    const disconnectIds = disconnectWhere.map(v => v.id);
                    await disconnectForModelB(where.id, disconnectIds, graphqlContext);
                }
                if (deleteWhere) {
                    const deleteIds = deleteWhere.map(v => v.id);
                    await destroyForModelB(where.id, deleteIds, graphqlContext);
                }
                return updated;
            },
            resolveFields: {
                [relationImpl.getModelBField()]: (data, argument, graphqlContext) => {
                    return relationImpl.joinModelA(data.id, argument, graphqlContext);
                },
            },
        },
    };
};
exports.createHookMap = createHookMap;