@pallad/graphql-command-bus/compiled/EntityHelper.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EntityHelper = void 0;
const dataloader_manager_1 = require("@pallad/dataloader-manager");
const graphql_1 = require("graphql");
const QueryHelper_1 = require("./QueryHelper");
class EntityHelper {
    constructor(entityType, mapper, dataLoaderManager) {
        this.entityType = entityType;
        this.mapper = mapper;
        this.dataLoaderManager = dataLoaderManager;
    }
    createFindByIdResolver(options) {
        const dataLoaderName = options.dataLoaderName || this.entityType.getTypeName() + '.findById';
        const dataLoaderFactory = (context) => {
            return new dataloader_manager_1.DataLoader(async (keys) => {
                const command = await options.commandFactory(keys.slice(), context);
                const executionContext = {
                    contextOptions: options.context,
                    gqlContext: context
                };
                const result = await this.mapper.handleCommand(command, executionContext, options.resultHandler);
                const arrayExtractor = options.resultsExtractor || EntityHelper.defaultResultExtractor;
                const finalResult = arrayExtractor(result);
                if (!Array.isArray(finalResult)) {
                    return [];
                }
                const idExtractor = options.idExtractor || EntityHelper.defaultIdExtractor;
                const resultMap = new Map();
                for (const entry of finalResult) {
                    finalResult && resultMap.set(idExtractor(entry), entry);
                }
                return keys.map(x => resultMap.get(x));
            });
        };
        this.dataLoaderManager.registerDataLoaderType(dataLoaderName, dataLoaderFactory);
        this.entityType.addResolver({
            name: 'findById',
            type: this.entityType.getType(),
            args: {
                id: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID) }
            },
            resolve: this.mapper.createDataLoaderResolver(dataLoaderName, 'id')
        });
        return this.getFindByIdResolver();
    }
    getFindByIdResolver() {
        return this.entityType.getResolver('findById');
    }
    createQueryResolver(options) {
        this.entityType.addResolver({
            name: 'query',
            args: {
                query: QueryHelper_1.QueryHelper.createQueryType(options)
            },
            type: QueryHelper_1.QueryHelper.createQueryResultType(this.entityType, options.pagination),
            resolve: this.mapper.createResolver({
                commandFactory: ({ args }) => {
                    var _a;
                    const query = {
                        ...(args.query || {}),
                        filters: ((_a = args.query) === null || _a === void 0 ? void 0 : _a.filters) || {},
                    };
                    return options.commandFactory(query);
                },
                context: options.context
            }).rp
        });
        return this.getQueryResolver();
    }
    getQueryResolver() {
        return this.entityType.getResolver('query');
    }
}
exports.EntityHelper = EntityHelper;
EntityHelper.defaultIdExtractor = result => {
    return result.id;
};
EntityHelper.defaultResultExtractor = result => {
    // eslint-disable-next-line no-null/no-null
    if (result === null || result === undefined) {
        return [];
    }
    if (Array.isArray(result)) {
        return result;
    }
    if ('results' in result) {
        return result.results;
    }
    throw new Error('Could not extract array results');
};