@searchkit/schema/lib/resolvers/ResultsResolver.js

Elasticsearch GraphQL Resolvers

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DataRequest = void 0;
/* eslint-disable no-useless-catch */
const sdk_1 = __importDefault(require("@searchkit/sdk"));
const ESClientTransporter_1 = __importDefault(require("@searchkit/sdk/lib/cjs/transporters/ESClientTransporter"));
const dataloader_1 = __importDefault(require("dataloader"));
const transporter = {};
function getTransporter(config) {
    if (!transporter[config.index]) {
        transporter[config.index] = new ESClientTransporter_1.default(config);
    }
    return transporter[config.index];
}
class DataRequest {
    constructor(config) {
        this.config = config;
        this.facetsCriteria = [];
        this.dataloader = new dataloader_1.default(this.performSearch.bind(this));
        this.skRequest = sdk_1.default(config, getTransporter(this.config));
    }
    setFacets(enable) {
        this.facets = enable;
    }
    setFacetsCriteria(facetsCriteria) {
        this.facetsCriteria = [...this.facetsCriteria, ...facetsCriteria];
    }
    setHits({ size, from, sortId }) {
        this.size = size;
        this.from = from;
        this.skRequest.setSortBy(sortId);
    }
    setQuery(query) {
        this.skRequest.query(query);
    }
    setBaseFilters(baseFilters) {
        this.baseFilters = baseFilters;
    }
    setFilters(filters) {
        this.skRequest.setFilters(filters);
    }
    setQueryOptions(options) {
        this.skRequest.setQueryOptions(options);
    }
    search() {
        return this.dataloader.load(1);
    }
    performSearch(requests) {
        return __awaiter(this, void 0, void 0, function* () {
            const results = yield this.skRequest.execute({
                facets: this.facetsCriteria.length > 0 ? this.facetsCriteria : this.facets,
                hits: {
                    size: this.size,
                    from: this.from,
                    includeRawHit: true
                }
            }, this.baseFilters);
            return requests.map(() => results);
        });
    }
}
exports.DataRequest = DataRequest;
exports.default = (parent, parameters, ctx, info) => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const returnTypeName = info.returnType.name;
        const config = ctx.searchkit.configs[returnTypeName];
        const baseFilters = ctx.searchkit.baseFilters[returnTypeName]
            ? ctx.searchkit.baseFilters[returnTypeName](parent, parameters, ctx, info)
            : [];
        const queryOptions = parameters.queryOptions || { fields: [] };
        const dataRequest = new DataRequest(config);
        dataRequest.setQueryOptions(queryOptions);
        dataRequest.setBaseFilters(baseFilters);
        if (parameters.query) {
            dataRequest.setQuery(parameters.query);
        }
        if (parameters.filters) {
            dataRequest.setFilters(parameters.filters);
        }
        return {
            searchkit: {
                dataRequest,
                config,
                hitType: ctx.searchkit.hitTypeMappings[returnTypeName]
            }
        };
    }
    catch (e) {
        throw e;
    }
});