smart-query-nestjs 1.0.0

package/.eslintrc.json

@@ -0,0 +1,22 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "env": {
+    "node": true,
+    "es6": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
+  "rules": {
+    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
+  }
+}

package/README.md

@@ -0,0 +1,236 @@
+# nestjs-smart-query
+
+A high-performance, ORM-agnostic NestJS library for search, filtering, pagination, and sorting in REST APIs.
+
+## Features
+
+- **Global Search** - Search across multiple fields with a single query parameter
+- **Field Filtering** - Filter by exact match, contains, startsWith, endsWith
+- **Range Filtering** - Greater than, less than, greater or equal, less or equal
+- **Array Filtering** - IN queries for multiple values
+- **Nested Relation Filtering** - Filter by related entity fields
+- **Pagination** - Page-based pagination with configurable limits
+- **Sorting** - Sort by any field in ascending or descending order
+- **ORM Agnostic** - Generates query objects compatible with any database layer (Prisma, TypeORM, etc.)
+- **High Performance** - Optimized parsing with single query parse and O(1) field lookups
+
+## Installation
+
+```bash
+npm install nestjs-smart-query
+```
+
+## Quick Start
+
+### 1. Configure the Module
+
+```typescript
+import { Module } from '@nestjs/common';
+import { SmartQueryModule } from 'nestjs-smart-query';
+
+@Module({
+  imports: [
+    SmartQueryModule.forRoot({
+      searchableFields: ['full_name', 'email'],
+      filterableFields: ['full_name', 'email', 'is_active', 'status', 'shop_id'],
+      numberFields: ['age', 'price'],
+      booleanFields: ['is_active', 'is_verified'],
+      dateFields: ['created_at', 'updated_at'],
+      defaultLimit: 10,
+      maxLimit: 100,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 2. Use in Controller
+
+```typescript
+import { Controller, Get, UseInterceptors } from '@nestjs/common';
+import { SmartQueryInterceptor, SmartQuery, buildSmartQuery } from 'nestjs-smart-query';
+
+const customerQueryConfig = {
+  searchableFields: ['full_name', 'email'],
+  filterableFields: ['full_name', 'email', 'is_active', 'status', 'shop_id', 'age'],
+  numberFields: ['age'],
+  booleanFields: ['is_active'],
+  dateFields: ['created_at'],
+  defaultLimit: 10,
+  maxLimit: 100,
+};
+
+@Controller('customers')
+export class CustomerController {
+  @Get()
+  @UseInterceptors(new SmartQueryInterceptor(customerQueryConfig))
+  async findAll(@SmartQuery() query) {
+    const dbQuery = buildSmartQuery(query, {
+      shop_id: user.tenant_id,
+    });
+
+    const [data, total] = await Promise.all([
+      this.prisma.customer.findMany(dbQuery),
+      this.prisma.customer.count({ where: dbQuery.where }),
+    ]);
+
+    return { data, total };
+  }
+}
+```
+
+## Supported Query Formats
+
+### Global Search
+
+Search across all searchable fields:
+
+```
+GET /customers?searchTerm=john
+```
+
+### Field Filtering
+
+Exact match filtering:
+
+```
+GET /customers?full_name=John
+GET /customers?is_active=true
+```
+
+### Range Filtering
+
+Filter by numeric or date ranges:
+
+```
+GET /customers?price[gte]=10&price[lte]=100
+GET /customers?created_at[gte]=2024-01-01
+GET /customers?age[gt]=18
+```
+
+Operators: `gte`, `gt`, `lte`, `lt`
+
+### Array Filtering (IN Query)
+
+Filter by multiple values:
+
+```
+GET /customers?status[]=pending&status[]=approved
+GET /customers?status=pending,approved
+```
+
+### Nested Relation Filtering
+
+Filter by related entity fields:
+
+```
+GET /customers?shop.id=10
+GET /customers?shop.name=MyShop
+```
+
+### Pagination
+
+```
+GET /customers?page=2&limit=20
+```
+
+- `page`: Page number (default: 1)
+- `limit`: Items per page (default: 10, max: 100)
+
+### Sorting
+
+```
+GET /customers?sortBy=created_at&sortOrder=desc
+```
+
+- `sortBy`: Field to sort by
+- `sortOrder`: `asc` or `desc` (default: asc)
+
+## Combined Example
+
+```
+GET /customers?searchTerm=john&status[]=active&age[gte]=18&page=1&limit=20&sortBy=created_at&sortOrder=desc
+```
+
+This query will:
+- Search for "john" in all searchable fields
+- Filter by status "active"
+- Filter by age >= 18
+- Return page 1 with 20 items per page
+- Sort by created_at in descending order
+
+## API Reference
+
+### Interfaces
+
+#### SmartQueryConfig
+
+```typescript
+interface SmartQueryConfig {
+  searchableFields: string[];
+  filterableFields: string[];
+  numberFields?: string[];
+  booleanFields?: string[];
+  dateFields?: string[];
+  defaultLimit?: number;
+  maxLimit?: number;
+}
+```
+
+#### SmartQueryContext
+
+```typescript
+interface SmartQueryContext {
+  where: Record<string, unknown>;
+  pagination: PaginationOptions;
+}
+```
+
+#### PaginationOptions
+
+```typescript
+interface PaginationOptions {
+  page: number;
+  limit: number;
+  skip: number;
+  sortBy: string;
+  sortOrder: 'asc' | 'desc';
+}
+```
+
+### Functions
+
+#### buildSmartQuery(context, ...extraConditions)
+
+Merges the smart query context with additional conditions and generates a database query object.
+
+```typescript
+const result = buildSmartQuery(query, { shop_id: 1 });
+// Returns: { where, orderBy, skip, take, page }
+```
+
+### Decorators
+
+#### @SmartQuery()
+
+Extracts the SmartQueryContext from the request.
+
+```typescript
+@Get()
+async findAll(@SmartQuery() query: SmartQueryContext) {
+  // ...
+}
+```
+
+## Performance Optimizations
+
+The library includes several performance optimizations:
+
+1. **Single Query Parse** - Uses `qs.parse` with `allowDots: true` to parse the query string only once
+2. **O(1) Field Lookups** - Uses `Set` for field lookups instead of array includes
+3. **Modular Architecture** - Separates concerns into dedicated parsers
+4. **No Unnecessary Cloning** - Avoids deep object cloning where possible
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "smart-query-nestjs",
+  "version": "1.0.0",
+  "description": "High-performance search, filtering, pagination, and sorting for NestJS REST APIs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "nestjs",
+    "query",
+    "filter",
+    "search",
+    "pagination",
+    "sort",
+    "rest-api",
+    "orm-agnostic"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "qs": "^6.12.0"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.3.0",
+    "@nestjs/core": "^10.3.0",
+    "@nestjs/platform-express": "^10.3.0",
+    "@types/qs": "^6.9.14",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.56.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^9.0.0 || ^8.0.0",
+    "@nestjs/core": "^10.0.0 || ^9.0.0 || ^8.0.0",
+    "reflect-metadata": "^0.1.13 || ^0.2.0"
+  }
+}

package/src/builders/index.ts

@@ -0,0 +1 @@
+export * from './smart-query.builder';

package/src/builders/smart-query.builder.ts

@@ -0,0 +1,45 @@
+import { SmartQueryContext } from '../interfaces';
+
+export interface BuildSmartQueryOptions {
+  where?: Record<string, unknown>;
+  orderBy?: Record<string, 'asc' | 'desc'>;
+  skip?: number;
+  take?: number;
+}
+
+export interface SmartQueryResult {
+  where: Record<string, unknown>;
+  orderBy: Record<string, 'asc' | 'desc'>;
+  skip: number;
+  take: number;
+  page: number;
+}
+
+export function buildSmartQuery(
+  context: SmartQueryContext,
+  ...extraConditions: Record<string, unknown>[]
+): SmartQueryResult {
+  const { where, pagination } = context;
+
+  let finalWhere: Record<string, unknown>;
+
+  if (extraConditions.length === 0) {
+    finalWhere = where;
+  } else if (extraConditions.length === 1) {
+    finalWhere = { AND: [where, extraConditions[0]] };
+  } else {
+    finalWhere = { AND: [where, ...extraConditions] };
+  }
+
+  const orderBy: Record<string, 'asc' | 'desc'> = {
+    [pagination.sortBy]: pagination.sortOrder,
+  };
+
+  return {
+    where: finalWhere,
+    orderBy,
+    skip: pagination.skip,
+    take: pagination.limit,
+    page: pagination.page,
+  };
+}

package/src/decorators/index.ts

@@ -0,0 +1 @@
+export * from './smart-query.decorator';

package/src/decorators/smart-query.decorator.ts

@@ -0,0 +1,9 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { SmartQueryContext } from '../interfaces';
+
+export const SmartQuery = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext): SmartQueryContext => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.smartQuery as SmartQueryContext;
+  },
+);

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './interfaces';
+export * from './utils';
+export * from './parsers';
+export * from './interceptors';
+export * from './decorators';
+export * from './builders';
+export * from './module';

package/src/interceptors/index.ts

@@ -0,0 +1 @@
+export * from './smart-query.interceptor';

package/src/interceptors/smart-query.interceptor.ts

@@ -0,0 +1,83 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from '@nestjs/common';
+import type { SmartQueryConfig, SmartQueryContext } from '../interfaces';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { parseQueryString } from '../utils';
+import { buildSearchConditions } from '../parsers/search.parser';
+import { parseFilters } from '../parsers/filter.parser';
+import { parsePagination } from '../parsers/pagination.parser';
+
+export const SMART_QUERY_CONFIG = 'SMART_QUERY_CONFIG';
+
+@Injectable()
+export class SmartQueryInterceptor implements NestInterceptor {
+  private readonly config: SmartQueryConfig;
+
+  constructor(config: SmartQueryConfig) {
+    const defaults: SmartQueryConfig = {
+      searchableFields: [],
+      filterableFields: [],
+      numberFields: [],
+      booleanFields: [],
+      dateFields: [],
+      defaultLimit: 10,
+      maxLimit: 100,
+    };
+    this.config = { ...defaults, ...config };
+  }
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    const request = context.switchToHttp().getRequest();
+    const queryString = request.url.split('?')[1] || '';
+
+    const parsedQuery = parseQueryString(queryString);
+
+    const searchTerm = parsedQuery.searchTerm as string | undefined;
+    const filters = parseFilters(parsedQuery, this.config);
+    const searchConditions = buildSearchConditions(searchTerm, this.config);
+    const pagination = parsePagination(parsedQuery, this.config);
+
+    const where: Record<string, unknown> = {};
+
+    if (Object.keys(filters).length > 0) {
+      Object.assign(where, filters);
+    }
+
+    if (searchConditions) {
+      Object.assign(where, searchConditions);
+    }
+
+    const smartQueryContext: SmartQueryContext = {
+      where,
+      pagination,
+    };
+
+    request.smartQuery = smartQueryContext;
+
+    return next.handle().pipe(
+      map((data) => {
+        if (data && typeof data === 'object' && 'data' in data && 'total' in data) {
+          return {
+            ...data,
+            pagination: {
+              page: pagination.page,
+              limit: pagination.limit,
+              total: data.total,
+              totalPages: Math.ceil(data.total / pagination.limit),
+            },
+          };
+        }
+        return data;
+      }),
+    );
+  }
+}
+
+export function createSmartQueryInterceptor(config: SmartQueryConfig): SmartQueryInterceptor {
+  return new SmartQueryInterceptor(config);
+}

package/src/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './smart-query-config.interface';
+export * from './smart-query-context.interface';
+export * from './pagination-options.interface';

package/src/interfaces/pagination-options.interface.ts

@@ -0,0 +1,7 @@
+export interface PaginationOptions {
+  page: number;
+  limit: number;
+  skip: number;
+  sortBy: string;
+  sortOrder: 'asc' | 'desc';
+}

package/src/interfaces/smart-query-config.interface.ts

@@ -0,0 +1,9 @@
+export interface SmartQueryConfig {
+  searchableFields: string[];
+  filterableFields: string[];
+  numberFields?: string[];
+  booleanFields?: string[];
+  dateFields?: string[];
+  defaultLimit?: number;
+  maxLimit?: number;
+}

package/src/interfaces/smart-query-context.interface.ts

@@ -0,0 +1,6 @@
+import { PaginationOptions } from './pagination-options.interface';
+
+export interface SmartQueryContext {
+  where: Record<string, unknown>;
+  pagination: PaginationOptions;
+}

package/src/module/index.ts

@@ -0,0 +1 @@
+export * from './smart-query.module';

package/src/module/smart-query.module.ts

@@ -0,0 +1,20 @@
+import { Module, Global, DynamicModule, Provider } from '@nestjs/common';
+import { SmartQueryConfig } from '../interfaces';
+import { SMART_QUERY_CONFIG } from '../interceptors/smart-query.interceptor';
+
+@Global()
+@Module({})
+export class SmartQueryModule {
+  static forRoot(config: SmartQueryConfig): DynamicModule {
+    const configProvider: Provider = {
+      provide: SMART_QUERY_CONFIG,
+      useValue: config,
+    };
+
+    return {
+      module: SmartQueryModule,
+      providers: [configProvider],
+      exports: [configProvider],
+    };
+  }
+}

package/src/parsers/filter.parser.ts

@@ -0,0 +1,177 @@
+import { SmartQueryConfig } from '../interfaces';
+
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'startsWith' | 'endsWith';
+
+interface ParsedFilter {
+  field: string;
+  operator: FilterOperator;
+  value: unknown;
+}
+
+export function parseFilters(
+  query: Record<string, unknown>,
+  config: SmartQueryConfig,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const filterableFieldsSet = new Set(config.filterableFields);
+  const numberFieldsSet = new Set(config.numberFields ?? []);
+  const booleanFieldsSet = new Set(config.booleanFields ?? []);
+  const dateFieldsSet = new Set(config.dateFields ?? []);
+
+  const paginationKeys = new Set(['page', 'limit', 'sortBy', 'sortOrder', 'searchTerm']);
+
+  for (const [key, value] of Object.entries(query)) {
+    if (paginationKeys.has(key) || key.startsWith('searchTerm')) {
+      continue;
+    }
+
+    if (!filterableFieldsSet.has(key)) {
+      continue;
+    }
+
+    if (value === undefined || value === null || value === '') {
+      continue;
+    }
+
+    const parsedFilter = parseFieldFilter(key, value);
+    if (!parsedFilter) {
+      continue;
+    }
+
+    const { field, operator, value: filterValue } = parsedFilter;
+
+    if (numberFieldsSet.has(field)) {
+      result[field] = buildNumericFilter(operator, filterValue);
+    } else if (booleanFieldsSet.has(field)) {
+      result[field] = parseBooleanFilter(filterValue);
+    } else if (dateFieldsSet.has(field)) {
+      result[field] = buildDateFilter(operator, filterValue);
+    } else {
+      result[field] = buildStringFilter(operator, filterValue);
+    }
+  }
+
+  return result;
+}
+
+function parseFieldFilter(key: string, value: unknown): ParsedFilter | null {
+  const rangeMatch = key.match(/^(.+)\[(gte|gt|lte|lt)\]$/);
+  if (rangeMatch) {
+    return {
+      field: rangeMatch[1],
+      operator: rangeMatch[2] as FilterOperator,
+      value: value,
+    };
+  }
+
+  const arrayMatch = key.match(/^(.+)\[\]$/);
+  if (arrayMatch) {
+    if (Array.isArray(value)) {
+      return {
+        field: arrayMatch[1],
+        operator: 'in',
+        value: value,
+      };
+    }
+    if (typeof value === 'string') {
+      return {
+        field: arrayMatch[1],
+        operator: 'in',
+        value: value.split(',').map((v) => v.trim()),
+      };
+    }
+  }
+
+  return {
+    field: key,
+    operator: 'eq',
+    value: value,
+  };
+}
+
+function buildNumericFilter(operator: FilterOperator, value: unknown): Record<string, unknown> {
+  const numValue = typeof value === 'number' ? value : Number(value);
+  if (Number.isNaN(numValue)) {
+    return { eq: value };
+  }
+
+  switch (operator) {
+    case 'eq':
+      return { equals: numValue };
+    case 'ne':
+      return { not: { equals: numValue } };
+    case 'gt':
+      return { gt: numValue };
+    case 'gte':
+      return { gte: numValue };
+    case 'lt':
+      return { lt: numValue };
+    case 'lte':
+      return { lte: numValue };
+    case 'in':
+      return { in: Array.isArray(value) ? value : [value] };
+    default:
+      return { equals: numValue };
+  }
+}
+
+function parseBooleanFilter(value: unknown): Record<string, unknown> {
+  if (typeof value === 'boolean') {
+    return { equals: value };
+  }
+  if (typeof value === 'string') {
+    const lower = value.toLowerCase();
+    if (lower === 'true' || lower === '1' || lower === 'yes') {
+      return { equals: true };
+    }
+    if (lower === 'false' || lower === '0' || lower === 'no') {
+      return { equals: false };
+    }
+  }
+  return { equals: value };
+}
+
+function buildDateFilter(operator: FilterOperator, value: unknown): Record<string, unknown> {
+  const dateValue = typeof value === 'string' ? new Date(value) : value;
+  if (!(dateValue instanceof Date) || Number.isNaN(dateValue.getTime())) {
+    return { equals: value };
+  }
+
+  switch (operator) {
+    case 'eq':
+      return { equals: dateValue };
+    case 'ne':
+      return { not: { equals: dateValue } };
+    case 'gt':
+      return { gt: dateValue };
+    case 'gte':
+      return { gte: dateValue };
+    case 'lt':
+      return { lt: dateValue };
+    case 'lte':
+      return { lte: dateValue };
+    case 'in':
+      return { in: Array.isArray(value) ? value : [value] };
+    default:
+      return { equals: dateValue };
+  }
+}
+
+function buildStringFilter(operator: FilterOperator, value: unknown): Record<string, unknown> {
+  switch (operator) {
+    case 'eq':
+      return { equals: String(value) };
+    case 'ne':
+      return { not: { equals: String(value) } };
+    case 'contains':
+      return { contains: String(value), mode: 'insensitive' };
+    case 'startsWith':
+      return { startsWith: String(value) };
+    case 'endsWith':
+      return { endsWith: String(value) };
+    case 'in':
+      return { in: Array.isArray(value) ? value : [value] };
+    default:
+      return { equals: String(value) };
+  }
+}

package/src/parsers/index.ts

@@ -0,0 +1,3 @@
+export * from './search.parser';
+export * from './filter.parser';
+export * from './pagination.parser';

package/src/parsers/pagination.parser.ts

@@ -0,0 +1,71 @@
+import { PaginationOptions } from '../interfaces';
+import { SmartQueryConfig } from '../interfaces/smart-query-config.interface';
+
+const DEFAULT_PAGE = 1;
+const DEFAULT_LIMIT = 10;
+
+export function parsePagination(
+  query: Record<string, unknown>,
+  config: SmartQueryConfig,
+): PaginationOptions {
+  const pageParam = query.page;
+  const limitParam = query.limit;
+  const sortByParam = query.sortBy;
+  const sortOrderParam = query.sortOrder;
+
+  const maxLimit = config.maxLimit ?? 100;
+  const defaultLimit = config.defaultLimit ?? DEFAULT_LIMIT;
+
+  const page = parsePositiveInteger(pageParam) ?? DEFAULT_PAGE;
+  const limit = clampLimit(
+    parsePositiveInteger(limitParam) ?? defaultLimit,
+    defaultLimit,
+    maxLimit,
+  );
+  const skip = (page - 1) * limit;
+
+  let sortBy = 'id';
+  if (typeof sortByParam === 'string' && sortByParam.trim()) {
+    sortBy = sortByParam.trim();
+  }
+
+  let sortOrder: 'asc' | 'desc' = 'asc';
+  if (typeof sortOrderParam === 'string') {
+    const normalized = sortOrderParam.toLowerCase();
+    if (normalized === 'desc' || normalized === 'asc') {
+      sortOrder = normalized;
+    }
+  }
+
+  return {
+    page,
+    limit,
+    skip,
+    sortBy,
+    sortOrder,
+  };
+}
+
+function parsePositiveInteger(value: unknown): number | null {
+  if (value === undefined || value === null || value === '') {
+    return null;
+  }
+
+  const num = typeof value === 'number' ? value : Number(value);
+
+  if (!Number.isInteger(num) || num < 1) {
+    return null;
+  }
+
+  return num;
+}
+
+function clampLimit(value: number, defaultLimit: number, maxLimit: number): number {
+  if (value < 1) {
+    return defaultLimit;
+  }
+  if (value > maxLimit) {
+    return maxLimit;
+  }
+  return value;
+}

package/src/parsers/search.parser.ts

@@ -0,0 +1,31 @@
+import { SmartQueryConfig } from '../interfaces';
+
+interface SearchCondition {
+  OR: Record<string, { contains: string; mode: string }>[];
+}
+
+export function buildSearchConditions(
+  searchTerm: string | undefined,
+  config: SmartQueryConfig,
+): SearchCondition | null {
+  if (!searchTerm || typeof searchTerm !== 'string' || !searchTerm.trim()) {
+    return null;
+  }
+
+  const trimmedTerm = searchTerm.trim();
+  const searchableFieldsSet = new Set(config.searchableFields);
+
+  const conditions: Record<string, { contains: string; mode: string }>[] = [];
+
+  for (const field of config.searchableFields) {
+    if (searchableFieldsSet.has(field)) {
+      conditions.push({ [field]: { contains: trimmedTerm, mode: 'insensitive' } });
+    }
+  }
+
+  if (conditions.length === 0) {
+    return null;
+  }
+
+  return { OR: conditions };
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './query-parser.util';
+export * from './pick.util';

package/src/utils/pick.util.ts

@@ -0,0 +1,12 @@
+export function pick<T extends Record<string, unknown>, K extends keyof T>(
+  obj: T,
+  keys: K[],
+): Pick<T, K> {
+  const result = {} as Pick<T, K>;
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}

package/src/utils/query-parser.util.ts

@@ -0,0 +1,12 @@
+import qs from 'qs';
+
+export function parseQueryString(queryString: string): Record<string, unknown> {
+  if (!queryString || typeof queryString !== 'string') {
+    return {};
+  }
+  return qs.parse(queryString, {
+    allowDots: true,
+    arrayLimit: 0,
+    comma: true,
+  }) as Record<string, unknown>;
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  sourcemap: true,
+  splitting: false,
+  clean: true,
+  external: ['@nestjs/common', '@nestjs/core', 'reflect-metadata'],
+  treeshake: true,
+});