graphql-compose-elasticsearch/lib/resolvers/searchPagination.js

Elastic search via GraphQL

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("../utils");
function createSearchPaginationResolver(opts, searchResolver) {
    const resolver = searchResolver.clone({
        name: `searchPagination`,
    });
    resolver
        .addArgs({
        page: 'Int',
        perPage: {
            type: 'Int',
            defaultValue: 20,
        },
    })
        .removeArg(['limit', 'skip'])
        .reorderArgs(['q', 'query', 'sort', 'aggs', 'page', 'perPage']);
    const searchTC = searchResolver.getOTC();
    if (!searchTC) {
        throw new Error('Cannot get ObjectTypeComposer from resolver. Maybe resolver return Scalar?!');
    }
    const typeName = searchTC.getTypeName();
    resolver.setType(searchTC
        .clone(`${typeName}Pagination`)
        .addFields({
        pageInfo: getPageInfoTC(opts),
        items: searchTC.getFieldTC('hits').List,
    })
        .removeField('hits')
        .reorderFields(['items', 'count', 'pageInfo', 'aggregations']));
    resolver.resolve = (rp) => __awaiter(this, void 0, void 0, function* () {
        const { args = {}, projection = {} } = rp;
        const page = args.page || 1;
        if (page <= 0) {
            throw new Error('Argument `page` should be positive number.');
        }
        const perPage = args.perPage || 20;
        if (perPage <= 0) {
            throw new Error('Argument `perPage` should be positive number.');
        }
        delete args.page;
        delete args.perPage;
        args.limit = perPage;
        args.skip = (page - 1) * perPage;
        if (projection.items) {
            projection.hits = projection.items;
            delete projection.items;
        }
        const res = yield searchResolver.resolve(rp);
        const items = res.hits || [];
        const itemCount = res.count || 0;
        const result = Object.assign(Object.assign({}, res), { pageInfo: {
                hasNextPage: itemCount > page * perPage,
                hasPreviousPage: page > 1,
                currentPage: page,
                perPage,
                pageCount: Math.ceil(itemCount / perPage),
                itemCount,
            }, items });
        return result;
    });
    return resolver;
}
exports.default = createSearchPaginationResolver;
function getPageInfoTC(opts) {
    const name = (0, utils_1.getTypeName)('PaginationInfo', opts);
    if (opts.schemaComposer.has(name)) {
        return opts.schemaComposer.getOTC(name);
    }
    return opts.schemaComposer.createObjectTC(`
    # Information about pagination.
    type ${name} {
      # Current page number
      currentPage: Int!

      # Number of items per page
      perPage: Int!

      # Total number of pages
      pageCount: Int

      # Total number of items
      itemCount: Int

      # When paginating forwards, are there more items?
      hasNextPage: Boolean

      # When paginating backwards, are there more items?
      hasPreviousPage: Boolean
    }
  `);
}
//# sourceMappingURL=searchPagination.js.map