@nestarc/pagination 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nestarc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,334 @@
+# @nestarc/pagination
+
+Prisma cursor & offset pagination for NestJS with filtering, sorting, search, and Swagger auto-documentation.
+
+## Features
+
+- **Offset + cursor** pagination in a single API
+- **12 filter operators**: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$ilike`, `$btw`, `$null`, `$not:null`
+- **Multi-column sorting** with null positioning
+- **Full-text search** across multiple columns
+- **Column/operator whitelisting** for security
+- **Swagger** auto-documentation (optional)
+- **Standalone** `paginate()` function — works without NestJS
+- Compatible with `@nestarc/tenancy` (RLS) and `@nestarc/soft-delete` via Prisma extension chain
+
+## Quick Start
+
+### Install
+
+```bash
+npm install @nestarc/pagination
+```
+
+Peer dependencies: `@nestjs/common`, `@nestjs/core`, `@prisma/client`, `reflect-metadata`, `rxjs`
+
+### 1. Register the module
+
+```typescript
+import { PaginationModule } from '@nestarc/pagination';
+
+@Module({
+  imports: [
+    PaginationModule.forRoot({
+      defaultLimit: 20,
+      maxLimit: 100,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 2. Use in a controller
+
+```typescript
+import { Paginate, PaginateQuery, ApiPaginatedResponse } from '@nestarc/pagination';
+
+@Controller('users')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Get()
+  @ApiPaginatedResponse(UserDto)
+  async findAll(@Paginate() query: PaginateQuery) {
+    return this.userService.findAll(query);
+  }
+}
+```
+
+### 3. Use in a service
+
+```typescript
+import { paginate, PaginateQuery, PaginateConfig, Paginated } from '@nestarc/pagination';
+
+@Injectable()
+export class UserService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(query: PaginateQuery): Promise<Paginated<User>> {
+    return paginate(query, this.prisma.user, {
+      sortableColumns: ['id', 'name', 'email', 'createdAt'],
+      defaultSortBy: [['createdAt', 'DESC']],
+      searchableColumns: ['name', 'email'],
+      filterableColumns: {
+        role: ['$eq', '$in'],
+        createdAt: ['$gte', '$lte'],
+      },
+    });
+  }
+}
+```
+
+## Query Parameters
+
+### Offset
+
+```
+GET /users?page=2&limit=20&sortBy=createdAt:DESC&search=john&filter.role=$eq:admin
+```
+
+| Param | Description | Example |
+|-------|-------------|---------|
+| `page` | Page number (1-based) | `2` |
+| `limit` | Items per page | `20` |
+| `sortBy` | Sort (multi allowed) | `createdAt:DESC` |
+| `search` | Full-text search | `john` |
+| `filter.{col}` | Filter by column | `filter.role=$eq:admin` |
+
+### Cursor
+
+```
+GET /users?limit=20&after=eyJpZCI6IjEwIn0&sortBy=createdAt:DESC
+```
+
+| Param | Description | Example |
+|-------|-------------|---------|
+| `limit` | Items per page | `20` |
+| `after` | Forward cursor (Base64url) | `eyJpZCI6IjEwIn0` |
+| `before` | Backward cursor | `eyJpZCI6NX0` |
+| `sortBy` | Sort | `createdAt:DESC` |
+
+Cursor mode activates automatically when `after`/`before` is present or `paginationType: 'cursor'` is set.
+
+## Filter Operators
+
+| Operator | Prisma | Example |
+|----------|--------|---------|
+| `$eq` | `{ equals }` | `filter.role=$eq:admin` |
+| `$ne` | `{ not }` | `filter.status=$ne:deleted` |
+| `$gt` | `{ gt }` | `filter.age=$gt:18` |
+| `$gte` | `{ gte }` | `filter.age=$gte:18` |
+| `$lt` | `{ lt }` | `filter.price=$lt:100` |
+| `$lte` | `{ lte }` | `filter.price=$lte:100` |
+| `$in` | `{ in }` | `filter.role=$in:admin,user` |
+| `$nin` | `{ notIn }` | `filter.role=$nin:banned` |
+| `$ilike` | `{ contains, mode: 'insensitive' }` | `filter.name=$ilike:john` |
+| `$btw` | `{ gte, lte }` | `filter.price=$btw:10,100` |
+| `$null` | `null` | `filter.deletedAt=$null` |
+| `$not:null` | `{ not: null }` | `filter.verifiedAt=$not:null` |
+
+## Response Format
+
+### Offset
+
+```json
+{
+  "data": [{ "id": "1", "name": "Alice" }],
+  "meta": {
+    "itemsPerPage": 20,
+    "totalItems": 500,
+    "currentPage": 1,
+    "totalPages": 25,
+    "sortBy": [["createdAt", "DESC"]]
+  },
+  "links": {
+    "first": "/users?page=1&limit=20&sortBy=createdAt%3ADESC",
+    "previous": null,
+    "current": "/users?page=1&limit=20&sortBy=createdAt%3ADESC",
+    "next": "/users?page=2&limit=20&sortBy=createdAt%3ADESC",
+    "last": "/users?page=25&limit=20&sortBy=createdAt%3ADESC"
+  }
+}
+```
+
+### Cursor
+
+```json
+{
+  "data": [{ "id": "10", "name": "Bob" }],
+  "meta": {
+    "itemsPerPage": 20,
+    "hasNextPage": true,
+    "hasPreviousPage": true,
+    "startCursor": "eyJpZCI6IjEwIn0",
+    "endCursor": "eyJpZCI6IjI5In0",
+    "sortBy": [["createdAt", "DESC"]]
+  },
+  "links": {
+    "current": "/users?limit=20&after=eyJpZCI6IjEwIn0",
+    "next": "/users?limit=20&after=eyJpZCI6IjI5In0",
+    "previous": "/users?limit=20&before=eyJpZCI6IjEwIn0"
+  }
+}
+```
+
+## PaginateConfig
+
+```typescript
+const config: PaginateConfig<User> = {
+  // Required
+  sortableColumns: ['id', 'name', 'email', 'createdAt'],
+
+  // Sorting
+  defaultSortBy: [['createdAt', 'DESC']],
+  nullSort: 'last',
+
+  // Search
+  searchableColumns: ['name', 'email'],
+
+  // Filtering
+  filterableColumns: {
+    role: ['$eq', '$in'],
+    age: ['$gt', '$gte', '$lt', '$lte'],
+    createdAt: ['$gte', '$lte', '$btw'],
+  },
+
+  // Relations (Prisma include)
+  relations: { profile: true },
+
+  // Column selection (Prisma select)
+  select: ['id', 'name', 'email'],
+
+  // Pagination
+  paginationType: 'offset',     // 'offset' | 'cursor'
+  cursorColumn: 'id',            // default: 'id'
+  defaultLimit: 20,
+  maxLimit: 100,
+  withTotalCount: false,         // cursor mode: include total count
+
+  // Base where condition
+  where: { isActive: true },
+};
+```
+
+> When both `select` and `relations` are set, relations are merged into the select object to avoid Prisma's include/select conflict.
+
+## Module Options
+
+### forRoot
+
+```typescript
+PaginationModule.forRoot({
+  defaultLimit: 20,
+  maxLimit: 100,
+  defaultPaginationType: 'offset',
+  defaultSortBy: [['createdAt', 'DESC']],
+})
+```
+
+### forRootAsync
+
+```typescript
+PaginationModule.forRootAsync({
+  imports: [ConfigModule],
+  useFactory: (config: ConfigService) => ({
+    defaultLimit: config.get('PAGINATION_DEFAULT_LIMIT', 20),
+    maxLimit: config.get('PAGINATION_MAX_LIMIT', 100),
+  }),
+  inject: [ConfigService],
+})
+```
+
+## PaginateService
+
+`PaginateService` merges module options, `@PaginateDefaults` metadata, and per-endpoint config (highest priority wins):
+
+```typescript
+@Controller('users')
+export class UserController {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly paginateService: PaginateService,
+  ) {}
+
+  @Get()
+  @PaginateDefaults({ defaultLimit: 10, maxLimit: 50 })
+  async findAll(@Paginate() query: PaginateQuery) {
+    return this.paginateService.paginate(
+      query,
+      this.prisma.user,
+      { sortableColumns: ['id', 'name', 'createdAt'] },
+      this.findAll,
+    );
+  }
+}
+```
+
+Priority: `config` (per-endpoint) > `@PaginateDefaults` (per-handler) > `forRoot()` (global)
+
+## Swagger
+
+Install `@nestjs/swagger` (optional peer dependency) for auto-documentation:
+
+```typescript
+@Get()
+@ApiPaginatedResponse(UserDto)          // offset response schema
+async findAll(@Paginate() query: PaginateQuery) { ... }
+
+@Get('stream')
+@ApiCursorPaginatedResponse(UserDto)    // cursor response schema
+async findAllCursor(@Paginate() query: PaginateQuery) { ... }
+```
+
+If `@nestjs/swagger` is not installed, decorators are no-ops.
+
+## Standalone Usage
+
+`paginate()` works without NestJS:
+
+```typescript
+import { paginate } from '@nestarc/pagination';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+const result = await paginate(
+  { page: 1, limit: 20, path: '/users' },
+  prisma.user,
+  { sortableColumns: ['id', 'name', 'createdAt'] },
+);
+```
+
+## Testing Utilities
+
+```typescript
+import { createPaginateQuery, TestPaginationModule } from '@nestarc/pagination/testing';
+
+// Test module
+const module = await Test.createTestingModule({
+  imports: [TestPaginationModule.register({ defaultLimit: 10 })],
+  providers: [UserService],
+}).compile();
+
+// Query factory
+const query = createPaginateQuery({
+  page: 1,
+  limit: 10,
+  sortBy: [['createdAt', 'DESC']],
+  path: '/users',
+});
+```
+
+## Error Handling
+
+| Error | Status | When |
+|-------|--------|------|
+| `InvalidSortColumnError` | 400 | Sort column not in `sortableColumns` |
+| `InvalidFilterColumnError` | 400 | Filter column not in `filterableColumns` or operator not allowed |
+| `InvalidCursorError` | 400 | Invalid Base64url cursor |
+
+Unknown sort/filter columns throw errors (not silently ignored) to prevent clients from trusting incorrect results.
+
+## License
+
+MIT

package/dist/cursor/cursor.encoder.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeCursor(record: Record<string, any>, cursorColumn: string): string;
+export declare function decodeCursor(cursor: string): Record<string, any>;

package/dist/cursor/cursor.encoder.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeCursor = encodeCursor;
+exports.decodeCursor = decodeCursor;
+const invalid_cursor_error_1 = require("../errors/invalid-cursor.error");
+function encodeCursor(record, cursorColumn) {
+    const value = record[cursorColumn];
+    return Buffer.from(JSON.stringify({ [cursorColumn]: value })).toString('base64url');
+}
+function decodeCursor(cursor) {
+    if (!cursor) {
+        throw new invalid_cursor_error_1.InvalidCursorError(cursor);
+    }
+    try {
+        const json = Buffer.from(cursor, 'base64url').toString('utf-8');
+        const parsed = JSON.parse(json);
+        if (typeof parsed !== 'object' || parsed === null) {
+            throw new Error('Not an object');
+        }
+        return parsed;
+    }
+    catch {
+        throw new invalid_cursor_error_1.InvalidCursorError(cursor);
+    }
+}

package/dist/decorators/api-paginated-response.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+export declare function ApiPaginatedResponse(dataDto: Type): MethodDecorator;
+export declare function ApiCursorPaginatedResponse(dataDto: Type): MethodDecorator;

package/dist/decorators/api-paginated-response.decorator.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPaginatedResponse = ApiPaginatedResponse;
+exports.ApiCursorPaginatedResponse = ApiCursorPaginatedResponse;
+const common_1 = require("@nestjs/common");
+let swagger;
+try {
+    swagger = require('@nestjs/swagger');
+}
+catch {
+    // @nestjs/swagger not installed — decorators become no-ops
+}
+function ApiPaginatedResponse(dataDto) {
+    if (!swagger) {
+        return (0, common_1.applyDecorators)();
+    }
+    const { ApiOkResponse, ApiQuery, getSchemaPath } = swagger;
+    return (0, common_1.applyDecorators)(ApiOkResponse({
+        schema: {
+            allOf: [
+                {
+                    properties: {
+                        data: {
+                            type: 'array',
+                            items: { $ref: getSchemaPath(dataDto) },
+                        },
+                        meta: {
+                            type: 'object',
+                            properties: {
+                                itemsPerPage: { type: 'number', example: 20 },
+                                totalItems: { type: 'number', example: 500 },
+                                currentPage: { type: 'number', example: 1 },
+                                totalPages: { type: 'number', example: 25 },
+                                sortBy: { type: 'array', example: [['createdAt', 'DESC']] },
+                            },
+                        },
+                        links: {
+                            type: 'object',
+                            properties: {
+                                first: { type: 'string' },
+                                previous: { type: 'string', nullable: true },
+                                current: { type: 'string' },
+                                next: { type: 'string', nullable: true },
+                                last: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    }), ApiQuery({ name: 'page', required: false, type: Number }), ApiQuery({ name: 'limit', required: false, type: Number }), ApiQuery({ name: 'sortBy', required: false, type: String, isArray: true }), ApiQuery({ name: 'search', required: false, type: String }));
+}
+function ApiCursorPaginatedResponse(dataDto) {
+    if (!swagger) {
+        return (0, common_1.applyDecorators)();
+    }
+    const { ApiOkResponse, ApiQuery, getSchemaPath } = swagger;
+    return (0, common_1.applyDecorators)(ApiOkResponse({
+        schema: {
+            allOf: [
+                {
+                    properties: {
+                        data: {
+                            type: 'array',
+                            items: { $ref: getSchemaPath(dataDto) },
+                        },
+                        meta: {
+                            type: 'object',
+                            properties: {
+                                itemsPerPage: { type: 'number', example: 20 },
+                                hasNextPage: { type: 'boolean', example: true },
+                                hasPreviousPage: { type: 'boolean', example: false },
+                                startCursor: { type: 'string', nullable: true },
+                                endCursor: { type: 'string', nullable: true },
+                                sortBy: { type: 'array', example: [['createdAt', 'DESC']] },
+                            },
+                        },
+                        links: {
+                            type: 'object',
+                            properties: {
+                                current: { type: 'string' },
+                                next: { type: 'string', nullable: true },
+                                previous: { type: 'string', nullable: true },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    }), ApiQuery({ name: 'limit', required: false, type: Number }), ApiQuery({ name: 'after', required: false, type: String }), ApiQuery({ name: 'before', required: false, type: String }), ApiQuery({ name: 'sortBy', required: false, type: String, isArray: true }), ApiQuery({ name: 'search', required: false, type: String }));
+}

package/dist/decorators/paginate-defaults.decorator.d.ts

@@ -0,0 +1,9 @@
+import { SortOrder } from '../interfaces/filter-operator.type';
+export declare const PAGINATE_DEFAULTS_KEY = "PAGINATE_DEFAULTS";
+export interface PaginateDefaultsOptions {
+    defaultLimit?: number;
+    maxLimit?: number;
+    defaultSortBy?: [string, SortOrder][];
+    paginationType?: 'offset' | 'cursor';
+}
+export declare const PaginateDefaults: (defaults: PaginateDefaultsOptions) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/paginate-defaults.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateDefaults = exports.PAGINATE_DEFAULTS_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.PAGINATE_DEFAULTS_KEY = 'PAGINATE_DEFAULTS';
+const PaginateDefaults = (defaults) => (0, common_1.SetMetadata)(exports.PAGINATE_DEFAULTS_KEY, defaults);
+exports.PaginateDefaults = PaginateDefaults;

package/dist/decorators/paginate.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Paginate: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/dist/decorators/paginate.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paginate = void 0;
+const common_1 = require("@nestjs/common");
+const paginate_query_pipe_1 = require("../pipes/paginate-query.pipe");
+exports.Paginate = (0, common_1.createParamDecorator)((_data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return (0, paginate_query_pipe_1.parsePaginateQuery)(request);
+});

package/dist/errors/invalid-cursor.error.d.ts

@@ -0,0 +1,4 @@
+import { BadRequestException } from '@nestjs/common';
+export declare class InvalidCursorError extends BadRequestException {
+    constructor(cursor: string);
+}

package/dist/errors/invalid-cursor.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidCursorError = void 0;
+const common_1 = require("@nestjs/common");
+class InvalidCursorError extends common_1.BadRequestException {
+    constructor(cursor) {
+        super(`Invalid cursor: '${cursor}'`);
+        this.name = 'InvalidCursor';
+    }
+}
+exports.InvalidCursorError = InvalidCursorError;

package/dist/errors/invalid-filter-column.error.d.ts

@@ -0,0 +1,4 @@
+import { BadRequestException } from '@nestjs/common';
+export declare class InvalidFilterColumnError extends BadRequestException {
+    constructor(column: string, filterableColumns: string[], operator?: string, allowedOperators?: string[]);
+}

package/dist/errors/invalid-filter-column.error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFilterColumnError = void 0;
+const common_1 = require("@nestjs/common");
+class InvalidFilterColumnError extends common_1.BadRequestException {
+    constructor(column, filterableColumns, operator, allowedOperators) {
+        const message = operator && allowedOperators
+            ? `Operator '${operator}' is not allowed for column '${column}'. Allowed operators: ${allowedOperators.join(', ')}`
+            : `Column '${column}' is not filterable. Filterable columns: ${filterableColumns.join(', ')}`;
+        super(message);
+        this.name = 'InvalidFilterColumn';
+    }
+}
+exports.InvalidFilterColumnError = InvalidFilterColumnError;

package/dist/errors/invalid-sort-column.error.d.ts

@@ -0,0 +1,4 @@
+import { BadRequestException } from '@nestjs/common';
+export declare class InvalidSortColumnError extends BadRequestException {
+    constructor(column: string, sortableColumns: string[]);
+}

package/dist/errors/invalid-sort-column.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSortColumnError = void 0;
+const common_1 = require("@nestjs/common");
+class InvalidSortColumnError extends common_1.BadRequestException {
+    constructor(column, sortableColumns) {
+        super(`Column '${column}' is not sortable. Sortable columns: ${sortableColumns.join(', ')}`);
+        this.name = 'InvalidSortColumn';
+    }
+}
+exports.InvalidSortColumnError = InvalidSortColumnError;

package/dist/filter/filter-parser.d.ts

@@ -0,0 +1,2 @@
+import { FilterOperator } from '../interfaces/filter-operator.type';
+export declare function parseFilters(filters: Record<string, string | string[]> | undefined, filterableColumns: Record<string, FilterOperator[]>): Record<string, any>;

package/dist/filter/filter-parser.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFilters = parseFilters;
+const invalid_filter_column_error_1 = require("../errors/invalid-filter-column.error");
+const type_coercion_1 = require("../helpers/type-coercion");
+function parseFilters(filters, filterableColumns) {
+    if (!filters)
+        return {};
+    const where = {};
+    for (const [column, rawValue] of Object.entries(filters)) {
+        const allowedOperators = filterableColumns[column];
+        if (!allowedOperators) {
+            throw new invalid_filter_column_error_1.InvalidFilterColumnError(column, Object.keys(filterableColumns));
+        }
+        const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+        for (const value of values) {
+            const parsed = parseSingleFilter(value, column, allowedOperators);
+            where[column] = where[column]
+                ? { ...where[column], ...toObject(parsed) }
+                : parsed;
+        }
+    }
+    return where;
+}
+function toObject(value) {
+    if (value === null || typeof value !== 'object')
+        return {};
+    return value;
+}
+function parseSingleFilter(raw, column, allowedOperators) {
+    if (raw === '$null') {
+        validateOperator('$null', column, allowedOperators);
+        return null;
+    }
+    if (raw === '$not:null') {
+        validateOperator('$not:null', column, allowedOperators);
+        return { not: null };
+    }
+    const colonIndex = raw.indexOf(':');
+    if (colonIndex === -1) {
+        throw new invalid_filter_column_error_1.InvalidFilterColumnError(column, [], raw, allowedOperators);
+    }
+    let operator;
+    let value;
+    if (raw.startsWith('$not:null')) {
+        operator = '$not:null';
+        value = '';
+    }
+    else {
+        operator = raw.substring(0, colonIndex);
+        value = raw.substring(colonIndex + 1);
+    }
+    validateOperator(operator, column, allowedOperators);
+    switch (operator) {
+        case '$eq':
+            return { equals: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$ne':
+            return { not: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$gt':
+            return { gt: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$gte':
+            return { gte: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$lt':
+            return { lt: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$lte':
+            return { lte: (0, type_coercion_1.coerceFilterValue)(value) };
+        case '$in': {
+            const items = value.split(',').map(type_coercion_1.coerceFilterValue);
+            return { in: items };
+        }
+        case '$nin': {
+            const items = value.split(',').map(type_coercion_1.coerceFilterValue);
+            return { notIn: items };
+        }
+        case '$ilike':
+            return { contains: value, mode: 'insensitive' };
+        case '$btw': {
+            const [min, max] = value.split(',');
+            return { gte: (0, type_coercion_1.coerceFilterValue)(min), lte: (0, type_coercion_1.coerceFilterValue)(max) };
+        }
+        default:
+            throw new invalid_filter_column_error_1.InvalidFilterColumnError(column, [], operator, allowedOperators);
+    }
+}
+function validateOperator(operator, column, allowedOperators) {
+    if (!allowedOperators.includes(operator)) {
+        throw new invalid_filter_column_error_1.InvalidFilterColumnError(column, [], operator, allowedOperators);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function buildSearchCondition(search: string | undefined, searchableColumns: string[] | undefined): Record<string, any>;