@nestarc/pagination 0.1.0

package/dist/filter/search-builder.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSearchCondition = buildSearchCondition;
+function buildSearchCondition(search, searchableColumns) {
+    if (!search || !searchableColumns || searchableColumns.length === 0) {
+        return {};
+    }
+    return {
+        OR: searchableColumns.map((column) => ({
+            [column]: { contains: search, mode: 'insensitive' },
+        })),
+    };
+}

package/dist/filter/sort-builder.d.ts

@@ -0,0 +1,3 @@
+import { SortOrder } from '../interfaces/filter-operator.type';
+export declare function validateSortColumns(sortBy: [string, SortOrder][] | undefined, sortableColumns: string[]): void;
+export declare function buildOrderBy(sortBy: [string, SortOrder][] | undefined, nullSort?: 'first' | 'last'): Record<string, any>[];

package/dist/filter/sort-builder.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSortColumns = validateSortColumns;
+exports.buildOrderBy = buildOrderBy;
+const invalid_sort_column_error_1 = require("../errors/invalid-sort-column.error");
+function validateSortColumns(sortBy, sortableColumns) {
+    if (!sortBy)
+        return;
+    for (const [column] of sortBy) {
+        if (!sortableColumns.includes(column)) {
+            throw new invalid_sort_column_error_1.InvalidSortColumnError(column, sortableColumns);
+        }
+    }
+}
+function buildOrderBy(sortBy, nullSort) {
+    if (!sortBy || sortBy.length === 0)
+        return [];
+    return sortBy.map(([column, order]) => {
+        const direction = order.toLowerCase();
+        if (nullSort) {
+            return { [column]: { sort: direction, nulls: nullSort } };
+        }
+        return { [column]: direction };
+    });
+}

package/dist/helpers/link-builder.d.ts

@@ -0,0 +1,13 @@
+import { PaginateQuery } from '../interfaces/paginate-query.interface';
+export declare function buildOffsetLinks(query: PaginateQuery, currentPage: number, limit: number, totalPages: number): {
+    first: string;
+    previous: string | null;
+    current: string;
+    next: string | null;
+    last: string;
+};
+export declare function buildCursorLinks(query: PaginateQuery, limit: number, endCursor: string | null, startCursor: string | null, hasNextPage: boolean, hasPreviousPage: boolean): {
+    current: string;
+    next: string | null;
+    previous: string | null;
+};

package/dist/helpers/link-builder.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOffsetLinks = buildOffsetLinks;
+exports.buildCursorLinks = buildCursorLinks;
+function buildQueryString(path, query, overrides) {
+    const params = new URLSearchParams();
+    // Pagination params (from overrides)
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value !== undefined) {
+            params.set(key, value);
+        }
+    }
+    // Preserve sortBy
+    if (query.sortBy) {
+        for (const [col, order] of query.sortBy) {
+            params.append('sortBy', `${col}:${order}`);
+        }
+    }
+    // Preserve search
+    if (query.search) {
+        params.set('search', query.search);
+    }
+    // Preserve filters
+    if (query.filter) {
+        for (const [col, value] of Object.entries(query.filter)) {
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    params.append(`filter.${col}`, v);
+                }
+            }
+            else {
+                params.set(`filter.${col}`, value);
+            }
+        }
+    }
+    return `${path}?${params.toString()}`;
+}
+function buildOffsetLinks(query, currentPage, limit, totalPages) {
+    const base = { limit: String(limit) };
+    return {
+        first: buildQueryString(query.path, query, { page: '1', ...base }),
+        previous: currentPage > 1
+            ? buildQueryString(query.path, query, { page: String(currentPage - 1), ...base })
+            : null,
+        current: buildQueryString(query.path, query, { page: String(currentPage), ...base }),
+        next: currentPage < totalPages
+            ? buildQueryString(query.path, query, { page: String(currentPage + 1), ...base })
+            : null,
+        last: buildQueryString(query.path, query, { page: String(totalPages), ...base }),
+    };
+}
+function buildCursorLinks(query, limit, endCursor, startCursor, hasNextPage, hasPreviousPage) {
+    const base = { limit: String(limit) };
+    // current link: reflect the original request's cursor
+    let currentOverrides = { ...base };
+    if (query.after) {
+        currentOverrides.after = query.after;
+    }
+    else if (query.before) {
+        currentOverrides.before = query.before;
+    }
+    return {
+        current: buildQueryString(query.path, query, currentOverrides),
+        next: hasNextPage && endCursor
+            ? buildQueryString(query.path, query, { ...base, after: endCursor })
+            : null,
+        previous: hasPreviousPage && startCursor
+            ? buildQueryString(query.path, query, { ...base, before: startCursor })
+            : null,
+    };
+}

package/dist/helpers/type-coercion.d.ts

@@ -0,0 +1 @@
+export declare function coerceFilterValue(value: string): string | number | boolean | null;

package/dist/helpers/type-coercion.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceFilterValue = coerceFilterValue;
+function coerceFilterValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (value !== '' && !isNaN(Number(value)) && value.trim() === value && String(Number(value)) === value) {
+        return Number(value);
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { PaginationModule } from './pagination.module';
+export { PaginationModuleOptions, PaginationModuleAsyncOptions, } from './interfaces/pagination-options.interface';
+export { paginate } from './paginate';
+export { PaginateService } from './paginate.service';
+export { PaginateQuery } from './interfaces/paginate-query.interface';
+export { PaginateConfig } from './interfaces/paginate-config.interface';
+export { Paginated, CursorPaginated } from './interfaces/paginated.interface';
+export { FilterOperator, SortOrder } from './interfaces/filter-operator.type';
+export { Paginate } from './decorators/paginate.decorator';
+export { PaginateDefaults, PAGINATE_DEFAULTS_KEY, PaginateDefaultsOptions } from './decorators/paginate-defaults.decorator';
+export { ApiPaginatedResponse, ApiCursorPaginatedResponse, } from './decorators/api-paginated-response.decorator';
+export { InvalidSortColumnError } from './errors/invalid-sort-column.error';
+export { InvalidFilterColumnError } from './errors/invalid-filter-column.error';
+export { InvalidCursorError } from './errors/invalid-cursor.error';
+export { PAGINATION_MODULE_OPTIONS } from './pagination.constants';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGINATION_MODULE_OPTIONS = exports.InvalidCursorError = exports.InvalidFilterColumnError = exports.InvalidSortColumnError = exports.ApiCursorPaginatedResponse = exports.ApiPaginatedResponse = exports.PAGINATE_DEFAULTS_KEY = exports.PaginateDefaults = exports.Paginate = exports.PaginateService = exports.paginate = exports.PaginationModule = void 0;
+// Core Module
+var pagination_module_1 = require("./pagination.module");
+Object.defineProperty(exports, "PaginationModule", { enumerable: true, get: function () { return pagination_module_1.PaginationModule; } });
+// Core Function
+var paginate_1 = require("./paginate");
+Object.defineProperty(exports, "paginate", { enumerable: true, get: function () { return paginate_1.paginate; } });
+// Service
+var paginate_service_1 = require("./paginate.service");
+Object.defineProperty(exports, "PaginateService", { enumerable: true, get: function () { return paginate_service_1.PaginateService; } });
+// Decorators
+var paginate_decorator_1 = require("./decorators/paginate.decorator");
+Object.defineProperty(exports, "Paginate", { enumerable: true, get: function () { return paginate_decorator_1.Paginate; } });
+var paginate_defaults_decorator_1 = require("./decorators/paginate-defaults.decorator");
+Object.defineProperty(exports, "PaginateDefaults", { enumerable: true, get: function () { return paginate_defaults_decorator_1.PaginateDefaults; } });
+Object.defineProperty(exports, "PAGINATE_DEFAULTS_KEY", { enumerable: true, get: function () { return paginate_defaults_decorator_1.PAGINATE_DEFAULTS_KEY; } });
+var api_paginated_response_decorator_1 = require("./decorators/api-paginated-response.decorator");
+Object.defineProperty(exports, "ApiPaginatedResponse", { enumerable: true, get: function () { return api_paginated_response_decorator_1.ApiPaginatedResponse; } });
+Object.defineProperty(exports, "ApiCursorPaginatedResponse", { enumerable: true, get: function () { return api_paginated_response_decorator_1.ApiCursorPaginatedResponse; } });
+// Errors
+var invalid_sort_column_error_1 = require("./errors/invalid-sort-column.error");
+Object.defineProperty(exports, "InvalidSortColumnError", { enumerable: true, get: function () { return invalid_sort_column_error_1.InvalidSortColumnError; } });
+var invalid_filter_column_error_1 = require("./errors/invalid-filter-column.error");
+Object.defineProperty(exports, "InvalidFilterColumnError", { enumerable: true, get: function () { return invalid_filter_column_error_1.InvalidFilterColumnError; } });
+var invalid_cursor_error_1 = require("./errors/invalid-cursor.error");
+Object.defineProperty(exports, "InvalidCursorError", { enumerable: true, get: function () { return invalid_cursor_error_1.InvalidCursorError; } });
+// Constants
+var pagination_constants_1 = require("./pagination.constants");
+Object.defineProperty(exports, "PAGINATION_MODULE_OPTIONS", { enumerable: true, get: function () { return pagination_constants_1.PAGINATION_MODULE_OPTIONS; } });

package/dist/interfaces/filter-operator.type.d.ts

@@ -0,0 +1,2 @@
+export type FilterOperator = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$ilike' | '$btw' | '$null' | '$not:null';
+export type SortOrder = 'ASC' | 'DESC';

package/dist/interfaces/filter-operator.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/paginate-config.interface.d.ts

@@ -0,0 +1,29 @@
+import { FilterOperator, SortOrder } from './filter-operator.type';
+export interface PaginateConfig<T = any> {
+    sortableColumns: (keyof T & string)[];
+    defaultSortBy?: [keyof T & string, SortOrder][];
+    nullSort?: 'first' | 'last';
+    searchableColumns?: (keyof T & string)[];
+    filterableColumns?: {
+        [K in keyof T & string]?: FilterOperator[];
+    };
+    relations?: Record<string, boolean | object>;
+    select?: (keyof T & string)[];
+    paginationType?: 'offset' | 'cursor';
+    /**
+     * Column used as cursor for cursor-based pagination. Defaults to 'id'.
+     *
+     * Requirements:
+     * - Must be included in `sortableColumns`
+     * - Should have unique, sequential values (e.g., auto-increment ID, UUID v7, timestamp)
+     * - Non-unique cursor columns may produce inconsistent results across pages
+     *
+     * @see https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination
+     */
+    cursorColumn?: keyof T & string;
+    defaultLimit?: number;
+    maxLimit?: number;
+    withTotalCount?: boolean;
+    where?: object;
+    allowWithDeleted?: boolean;
+}

package/dist/interfaces/paginate-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/paginate-query.interface.d.ts

@@ -0,0 +1,11 @@
+import { SortOrder } from './filter-operator.type';
+export interface PaginateQuery {
+    limit?: number;
+    sortBy?: [string, SortOrder][];
+    search?: string;
+    filter?: Record<string, string | string[]>;
+    path: string;
+    page?: number;
+    after?: string;
+    before?: string;
+}

package/dist/interfaces/paginate-query.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/paginated.interface.d.ts

@@ -0,0 +1,39 @@
+import { SortOrder } from './filter-operator.type';
+export interface Paginated<T> {
+    data: T[];
+    meta: {
+        itemsPerPage: number;
+        totalItems: number;
+        currentPage: number;
+        totalPages: number;
+        sortBy: [string, SortOrder][];
+        search?: string;
+        filter?: Record<string, string>;
+    };
+    links: {
+        first: string;
+        previous: string | null;
+        current: string;
+        next: string | null;
+        last: string;
+    };
+}
+export interface CursorPaginated<T> {
+    data: T[];
+    meta: {
+        itemsPerPage: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        startCursor: string | null;
+        endCursor: string | null;
+        sortBy: [string, SortOrder][];
+        search?: string;
+        filter?: Record<string, string>;
+        totalItems?: number;
+    };
+    links: {
+        current: string;
+        next: string | null;
+        previous: string | null;
+    };
+}

package/dist/interfaces/paginated.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/pagination-options.interface.d.ts

@@ -0,0 +1,15 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { SortOrder } from './filter-operator.type';
+export interface PaginationModuleOptions {
+    defaultLimit?: number;
+    maxLimit?: number;
+    defaultPaginationType?: 'offset' | 'cursor';
+    defaultSortBy?: [string, SortOrder][];
+    withLinks?: boolean;
+    withTotalCount?: boolean;
+    fieldNamingStrategy?: 'camelCase' | 'snake_case';
+}
+export interface PaginationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory: (...args: any[]) => Promise<PaginationModuleOptions> | PaginationModuleOptions;
+    inject?: any[];
+}

package/dist/interfaces/pagination-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/paginate.d.ts

@@ -0,0 +1,7 @@
+import { PaginateQuery } from './interfaces/paginate-query.interface';
+import { PaginateConfig } from './interfaces/paginate-config.interface';
+import { Paginated, CursorPaginated } from './interfaces/paginated.interface';
+export declare function paginate<T>(query: PaginateQuery, delegate: {
+    findMany: (args: any) => Promise<T[]>;
+    count: (args: any) => Promise<number>;
+}, config: PaginateConfig<T>): Promise<Paginated<T> | CursorPaginated<T>>;

package/dist/paginate.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = paginate;
+const pagination_constants_1 = require("./pagination.constants");
+const filter_parser_1 = require("./filter/filter-parser");
+const sort_builder_1 = require("./filter/sort-builder");
+const search_builder_1 = require("./filter/search-builder");
+const link_builder_1 = require("./helpers/link-builder");
+const cursor_encoder_1 = require("./cursor/cursor.encoder");
+async function paginate(query, delegate, config) {
+    const isCursorMode = config.paginationType === 'cursor' ||
+        query.after !== undefined ||
+        query.before !== undefined;
+    if (isCursorMode) {
+        return paginateCursor(query, delegate, config);
+    }
+    return paginateOffset(query, delegate, config);
+}
+async function paginateOffset(query, delegate, config) {
+    const limit = resolveLimit(query.limit, config);
+    const page = query.page ?? pagination_constants_1.DEFAULT_PAGE;
+    const sortBy = query.sortBy ?? config.defaultSortBy;
+    if (sortBy) {
+        (0, sort_builder_1.validateSortColumns)(sortBy, config.sortableColumns);
+    }
+    const orderBy = (0, sort_builder_1.buildOrderBy)(sortBy, config.nullSort);
+    const where = buildWhere(query, config);
+    const findManyArgs = {
+        where,
+        orderBy,
+        skip: (page - 1) * limit,
+        take: limit,
+    };
+    applySelectAndRelations(findManyArgs, config);
+    const [data, totalItems] = await Promise.all([
+        delegate.findMany(findManyArgs),
+        delegate.count({ where }),
+    ]);
+    const totalPages = Math.max(Math.ceil(totalItems / limit), 1);
+    return {
+        data,
+        meta: {
+            itemsPerPage: limit,
+            totalItems,
+            currentPage: page,
+            totalPages,
+            sortBy: sortBy ?? [],
+            ...(query.search && { search: query.search }),
+            ...(query.filter && { filter: flattenFilter(query.filter) }),
+        },
+        links: (0, link_builder_1.buildOffsetLinks)(query, page, limit, totalPages),
+    };
+}
+async function paginateCursor(query, delegate, config) {
+    const limit = resolveLimit(query.limit, config);
+    const cursorColumn = (config.cursorColumn ?? 'id');
+    const sortBy = query.sortBy ?? config.defaultSortBy;
+    if (sortBy) {
+        (0, sort_builder_1.validateSortColumns)(sortBy, config.sortableColumns);
+    }
+    const orderBy = (0, sort_builder_1.buildOrderBy)(sortBy, config.nullSort);
+    const where = buildWhere(query, config);
+    const findManyArgs = {
+        where,
+        orderBy,
+        take: limit + 1,
+    };
+    if (query.after) {
+        const cursorValue = (0, cursor_encoder_1.decodeCursor)(query.after);
+        findManyArgs.cursor = cursorValue;
+        findManyArgs.skip = 1;
+    }
+    else if (query.before) {
+        const cursorValue = (0, cursor_encoder_1.decodeCursor)(query.before);
+        findManyArgs.cursor = cursorValue;
+        findManyArgs.skip = 1;
+        findManyArgs.take = -(limit + 1);
+    }
+    applySelectAndRelations(findManyArgs, config);
+    let data = await delegate.findMany(findManyArgs);
+    let hasPreviousPage;
+    let hasNextPage;
+    if (query.before) {
+        // Navigating backward — we fetched limit+1 items backward
+        hasNextPage = true; // We came from a forward page, so there's always a next
+        hasPreviousPage = data.length > limit;
+        if (hasPreviousPage) {
+            data = data.slice(data.length - limit);
+        }
+    }
+    else if (query.after) {
+        // Navigating forward from a cursor — there's always a previous
+        hasPreviousPage = true;
+        hasNextPage = data.length > limit;
+        if (hasNextPage) {
+            data.pop();
+        }
+    }
+    else {
+        // First page (no cursor) — no previous
+        hasPreviousPage = false;
+        hasNextPage = data.length > limit;
+        if (hasNextPage) {
+            data.pop();
+        }
+    }
+    const startCursor = data.length > 0 ? (0, cursor_encoder_1.encodeCursor)(data[0], cursorColumn) : null;
+    const endCursor = data.length > 0 ? (0, cursor_encoder_1.encodeCursor)(data[data.length - 1], cursorColumn) : null;
+    const meta = {
+        itemsPerPage: limit,
+        hasNextPage,
+        hasPreviousPage,
+        startCursor,
+        endCursor,
+        sortBy: sortBy ?? [],
+        ...(query.search && { search: query.search }),
+        ...(query.filter && { filter: flattenFilter(query.filter) }),
+    };
+    if (config.withTotalCount) {
+        meta.totalItems = await delegate.count({ where });
+    }
+    return {
+        data,
+        meta,
+        links: (0, link_builder_1.buildCursorLinks)(query, limit, endCursor, startCursor, hasNextPage, hasPreviousPage),
+    };
+}
+function buildWhere(query, config) {
+    const conditions = [];
+    if (config.where && Object.keys(config.where).length > 0) {
+        conditions.push(config.where);
+    }
+    if (query.filter && config.filterableColumns) {
+        const filterWhere = (0, filter_parser_1.parseFilters)(query.filter, config.filterableColumns);
+        if (Object.keys(filterWhere).length > 0) {
+            conditions.push(filterWhere);
+        }
+    }
+    if (query.search && config.searchableColumns) {
+        const searchWhere = (0, search_builder_1.buildSearchCondition)(query.search, config.searchableColumns);
+        if (Object.keys(searchWhere).length > 0) {
+            conditions.push(searchWhere);
+        }
+    }
+    if (conditions.length === 0)
+        return {};
+    if (conditions.length === 1)
+        return conditions[0];
+    return { AND: conditions };
+}
+function applySelectAndRelations(findManyArgs, config) {
+    if (config.select) {
+        // Build select object from column list
+        const selectObj = Object.fromEntries(config.select.map((col) => [col, true]));
+        // Merge relations into select if both are present
+        if (config.relations) {
+            for (const [key, value] of Object.entries(config.relations)) {
+                selectObj[key] = value;
+            }
+        }
+        findManyArgs.select = selectObj;
+    }
+    else if (config.relations) {
+        findManyArgs.include = config.relations;
+    }
+}
+function resolveLimit(queryLimit, config) {
+    const defaultLimit = config.defaultLimit ?? pagination_constants_1.DEFAULT_LIMIT;
+    const maxLimit = config.maxLimit ?? pagination_constants_1.DEFAULT_MAX_LIMIT;
+    const limit = queryLimit ?? defaultLimit;
+    return Math.min(Math.max(limit, 1), maxLimit);
+}
+function flattenFilter(filter) {
+    const flat = {};
+    for (const [key, value] of Object.entries(filter)) {
+        flat[key] = Array.isArray(value) ? value.join(',') : value;
+    }
+    return flat;
+}

package/dist/paginate.service.d.ts

@@ -0,0 +1,15 @@
+import { Reflector } from '@nestjs/core';
+import { PaginationModuleOptions } from './interfaces/pagination-options.interface';
+import { PaginateQuery } from './interfaces/paginate-query.interface';
+import { PaginateConfig } from './interfaces/paginate-config.interface';
+import { Paginated, CursorPaginated } from './interfaces/paginated.interface';
+export declare class PaginateService {
+    private readonly moduleOptions;
+    private readonly reflector;
+    constructor(moduleOptions: PaginationModuleOptions | undefined, reflector: Reflector);
+    paginate<T>(query: PaginateQuery, delegate: {
+        findMany: (args: any) => Promise<T[]>;
+        count: (args: any) => Promise<number>;
+    }, config: PaginateConfig<T>, handler?: Function): Promise<Paginated<T> | CursorPaginated<T>>;
+    private mergeConfig;
+}

package/dist/paginate.service.js

@@ -0,0 +1,59 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const pagination_constants_1 = require("./pagination.constants");
+const paginate_1 = require("./paginate");
+const paginate_defaults_decorator_1 = require("./decorators/paginate-defaults.decorator");
+let PaginateService = class PaginateService {
+    constructor(moduleOptions = {}, reflector) {
+        this.moduleOptions = moduleOptions;
+        this.reflector = reflector;
+    }
+    async paginate(query, delegate, config, handler) {
+        const mergedConfig = this.mergeConfig(config, handler);
+        return (0, paginate_1.paginate)(query, delegate, mergedConfig);
+    }
+    mergeConfig(config, handler) {
+        // Read @PaginateDefaults metadata from handler
+        const defaults = handler
+            ? this.reflector.get(paginate_defaults_decorator_1.PAGINATE_DEFAULTS_KEY, handler)
+            : undefined;
+        // Priority: config (highest) > @PaginateDefaults (medium) > module options (lowest)
+        return {
+            ...config,
+            defaultLimit: config.defaultLimit ??
+                defaults?.defaultLimit ??
+                this.moduleOptions.defaultLimit,
+            maxLimit: config.maxLimit ??
+                defaults?.maxLimit ??
+                this.moduleOptions.maxLimit,
+            defaultSortBy: config.defaultSortBy ??
+                defaults?.defaultSortBy ??
+                this.moduleOptions.defaultSortBy,
+            paginationType: config.paginationType ??
+                defaults?.paginationType ??
+                this.moduleOptions.defaultPaginationType,
+        };
+    }
+};
+exports.PaginateService = PaginateService;
+exports.PaginateService = PaginateService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(pagination_constants_1.PAGINATION_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_1.Reflector])
+], PaginateService);

package/dist/pagination.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const PAGINATION_MODULE_OPTIONS = "PAGINATION_MODULE_OPTIONS";
+export declare const DEFAULT_LIMIT = 20;
+export declare const DEFAULT_MAX_LIMIT = 100;
+export declare const DEFAULT_PAGE = 1;
+export declare const DEFAULT_PAGINATION_TYPE: "offset";

package/dist/pagination.constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PAGINATION_TYPE = exports.DEFAULT_PAGE = exports.DEFAULT_MAX_LIMIT = exports.DEFAULT_LIMIT = exports.PAGINATION_MODULE_OPTIONS = void 0;
+exports.PAGINATION_MODULE_OPTIONS = 'PAGINATION_MODULE_OPTIONS';
+exports.DEFAULT_LIMIT = 20;
+exports.DEFAULT_MAX_LIMIT = 100;
+exports.DEFAULT_PAGE = 1;
+exports.DEFAULT_PAGINATION_TYPE = 'offset';

package/dist/pagination.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { PaginationModuleOptions, PaginationModuleAsyncOptions } from './interfaces/pagination-options.interface';
+export declare class PaginationModule {
+    static forRoot(options?: PaginationModuleOptions): DynamicModule;
+    static forRootAsync(options: PaginationModuleAsyncOptions): DynamicModule;
+}