nestjs-paginate/lib/swagger/api-paginated-query.decorator.js

Pagination and filtering helper method for TypeORM repositories or query builders using Nest.js framework.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ApiPaginationQuery = void 0;
exports.SortBy = SortBy;
const common_1 = require("@nestjs/common");
const swagger_1 = require("@nestjs/swagger");
const filter_1 = require("../filter");
const paginate_1 = require("../paginate");
const DEFAULT_VALUE_KEY = 'Default Value';
function p(key, value) {
    return `<p>
             <b>${key}: </b> ${value}
          </p>`;
}
function li(key, values) {
    return `<h4>${key}</h4><ul>${values.map((v) => `<li>${v}</li>`).join('\n')}</ul>`;
}
function SortBy(paginationConfig) {
    const defaultSortMessage = paginationConfig.defaultSortBy
        ? paginationConfig.defaultSortBy.map(([col, order]) => `${col}:${order}`).join(',')
        : 'No default sorting specified, the result order is not guaranteed';
    const sortBy = paginationConfig.sortableColumns.reduce((prev, curr) => {
        return [...prev, `${curr}:ASC`, `${curr}:DESC`];
    }, []);
    return (0, swagger_1.ApiQuery)({
        name: 'sortBy',
        isArray: true,
        enum: sortBy,
        description: `Parameter to sort by.
      <p>To sort by multiple fields, just provide query param multiple types. The order in url defines an order of sorting</p>
      ${p('Format', 'fieldName:DIRECTION')}
      ${p('Example', 'sortBy=id:DESC&sortBy=createdAt:ASC')}
      ${p('Default Value', defaultSortMessage)}
      ${li('Available Fields', paginationConfig.sortableColumns)}
      `,
        required: false,
        type: 'string',
    });
}
function Limit(paginationConfig) {
    var _a, _b;
    return (0, swagger_1.ApiQuery)({
        name: 'limit',
        description: `Number of records per page.
      ${p('Example', '20')}
      ${p(DEFAULT_VALUE_KEY, ((_a = paginationConfig === null || paginationConfig === void 0 ? void 0 : paginationConfig.defaultLimit) === null || _a === void 0 ? void 0 : _a.toString()) || paginate_1.PaginationLimit.DEFAULT_LIMIT.toString())}
      ${p('Max Value', ((_b = paginationConfig.maxLimit) === null || _b === void 0 ? void 0 : _b.toString()) || paginate_1.PaginationLimit.DEFAULT_MAX_LIMIT.toString())}

      If provided value is greater than max value, max value will be applied.
      `,
        required: false,
        type: 'number',
    });
}
function Select(paginationConfig) {
    if (!paginationConfig.select) {
        return;
    }
    return (0, swagger_1.ApiQuery)({
        name: 'select',
        description: `List of fields to select.
      ${p('Example', paginationConfig.select.slice(0, Math.min(5, paginationConfig.select.length)).join(','))}
      ${p(DEFAULT_VALUE_KEY, 'By default all fields returns. If you want to select only some fields, provide them in query param')}
      `,
        required: false,
        type: 'string',
    });
}
function Where(paginationConfig) {
    if (!paginationConfig.filterableColumns)
        return;
    const allColumnsDecorators = Object.entries(paginationConfig.filterableColumns)
        .map(([fieldName, filterOperations]) => {
        const operations = filterOperations === true || filterOperations === undefined
            ? [
                ...Object.values(filter_1.FilterComparator),
                ...Object.values(paginate_1.FilterSuffix),
                ...Object.values(paginate_1.FilterOperator),
            ]
            : filterOperations.map((fo) => fo.toString());
        return (0, swagger_1.ApiQuery)({
            name: `filter.${fieldName}`,
            description: `Filter by ${fieldName} query param.
          ${p('Format', `filter.${fieldName}={$not}:OPERATION:VALUE`)}
          ${p('Example', `filter.${fieldName}=$not:$like:John Doe&filter.${fieldName}=like:John`)}
          ${li('Available Operations', operations)}`,
            required: false,
            type: 'string',
            isArray: true,
        });
    })
        .filter((v) => v !== undefined);
    return (0, common_1.applyDecorators)(...allColumnsDecorators);
}
function Page() {
    return (0, swagger_1.ApiQuery)({
        name: 'page',
        description: `Page number to retrieve.If you provide invalid value the default page number will applied
        ${p('Example', '1')}
        ${p(DEFAULT_VALUE_KEY, '1')}
        `,
        required: false,
        type: 'number',
    });
}
function Search(paginateConfig) {
    if (!paginateConfig.searchableColumns)
        return;
    return (0, swagger_1.ApiQuery)({
        name: 'search',
        description: `Search term to filter result values
        ${p('Example', 'John')}
        ${p(DEFAULT_VALUE_KEY, 'No default value')}
        `,
        required: false,
        type: 'string',
    });
}
function SearchBy(paginateConfig) {
    if (!paginateConfig.searchableColumns)
        return;
    return (0, swagger_1.ApiQuery)({
        name: 'searchBy',
        description: `List of fields to search by term to filter result values
        ${p('Example', paginateConfig.searchableColumns.slice(0, Math.min(5, paginateConfig.searchableColumns.length)).join(','))}
        ${p(DEFAULT_VALUE_KEY, 'By default all fields mentioned below will be used to search by term')}
        ${li('Available Fields', paginateConfig.searchableColumns)}
        `,
        required: false,
        isArray: true,
        type: 'string',
    });
}
const ApiPaginationQuery = (paginationConfig) => {
    return (0, common_1.applyDecorators)(...[
        Page(),
        Limit(paginationConfig),
        Where(paginationConfig),
        SortBy(paginationConfig),
        Search(paginationConfig),
        SearchBy(paginationConfig),
        Select(paginationConfig),
    ].filter((v) => v !== undefined));
};
exports.ApiPaginationQuery = ApiPaginationQuery;
//# sourceMappingURL=api-paginated-query.decorator.js.map