add filtration and update readme

Author: tfarras

README.md

@@ -18,4 +18,86 @@
 
 ```bash
 npm install @tfarras/nestjs-typeorm-pagination
-```
+```
+
+
+### Pagination Query params
+
+* `_start` - from which row to start on fetch
+* `_limit` - how many rows to take
+* `_sortBy`? - column for sorting
+* `_order`? - order for sorting. Accepted values: `1 | -1 | ASC | DESC`
+
+### Filtration
+
+You can filter your data by passing columns and values as query params.
+For the moment we support `Equal` and `In` operator of typeorm.
+
+#### Usage of `Equal`
+To filter data with `Equal` operator, you can simply add a parameter like `column=value`
+
+Examples:
+<br/>
+`id=1` <br/>
+`email=farrastaimoor@gmail.com` <br />
+`country=MD` 
+
+#### Usage of `In`
+To filter data with `In` operator, you can add more than one time parameter like `column=value`
+
+Examples:
+<br />
+`id=1&&id=2&&id=3` <br />
+`country=MD&&country=SE&&country=US`
+
+<hr>
+
+### Usage
+
+Extend your entity from `PaginateableBaseEntity` :
+```typescript
+@Entity({ name: 'user' })
+export class UserEntity extends PaginateableBaseEntity {
+```
+
+Add parameter decorator to your controller method :
+```typescript
+@Get()
+getMany(
+  @PgParams() pg: PaginationParams,
+) {...}
+```
+
+And now you're able to use pagination:
+```typescript
+...
+import { PgParams, PaginationParams, Pagination } from '@tfarras/nestjs-typeorm-pagination';
+
+@Get()
+getMany(
+  @PgParams() pg: PaginationParams,
+): Promise<Pagination<UserEntity>> {
+  return UserEntity.findAndPaginate(pg);
+}
+```
+
+Example request:
+```
+/user?_limit=11&_start=0&_sortBy=id&_order=DESC&id=1&id=2&email=farrastaimoor@gmail.com
+```
+
+`Pagination` response: 
+```json
+{
+  "data": [
+    {
+      "id": 2,
+      "email": "farrastaimoor@gmail.com",
+      "firstname": "Taimoor",
+      "lastname": "Farras",
+      "country": "MD",
+    }
+  ],
+  "total": 1,
+}
+```

src/paginateable.entity.ts

@@ -1,10 +1,9 @@
 import { BadRequestException } from '@nestjs/common';
-import { BaseEntity, ObjectType, FindManyOptions } from 'typeorm';
+import { BaseEntity, ObjectType, FindManyOptions, In, Equal } from 'typeorm';
 import { PaginationParams } from './pagination.decorator';
 import { Pagination } from './pagination.interface';
 
 export abstract class PaginateableBaseEntity extends BaseEntity {
-
   /**
    * Finds entities that match given find options
    */
@@ -15,33 +14,57 @@ export abstract class PaginateableBaseEntity extends BaseEntity {
   ): Promise<Pagination<T>> {
     const entity = this as any;
     const {
-      _end,
+      _limit,
       _start,
       _order,
-      _sort,
+      _sortBy,
+      _filter,
     } = pg;
     let query = options;
-    const columnExists = entity.getRepository().metadata.findColumnWithPropertyPath(_sort);
+    const columnExists = entity.getRepository().metadata.findColumnWithPropertyPath(_sortBy);
 
-    if (_order && _sort && columnExists) {
+    if (_order && _sortBy && columnExists) {
       query = {
         ...query,
         order: {
-          [_sort]: _order,
+          [_sortBy]: _order,
         }
       }
     }
 
-    if (_start >= 0 && _end > _start) {
+    if (_start >= 0 && _limit > 0) {
       query = {
         ...query,
-        take: _end - _start,
+        take: _limit,
         skip: _start,
       }
     } else {
       throw new BadRequestException('Invalid pagination query!');
     }
 
+    if (_filter) {
+      const toFilter = Object.entries(_filter).filter(([key]) =>
+        entity.getRepository().metadata.findColumnWithPropertyPath(key)
+      );
+      const filterQuery = {};
+
+      toFilter.forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          filterQuery[key] = In(value);
+        } else {
+          filterQuery[key] = Equal(value);
+        }
+      });
+
+      query = {
+        ...query,
+        where: {
+          ...query.where,
+          ...filterQuery,
+        }
+      }
+    }
+
     const [data, total] = await entity.getRepository().findAndCount(query as any);
 
     return {

src/pagination.decorator.ts

@@ -1,24 +1,28 @@
 import { createParamDecorator } from '@nestjs/common';
+import { ObjectLiteral } from 'typeorm';
 
 export interface PaginationParams {
-  _end: number;
+  _limit: number;
   _start: number;
   _order?: 'ASC' | 'DESC' | 1 | -1;
-  _sort?: string;
+  _sortBy?: string;
+  _filter: ObjectLiteral;
 }
 
 export const PgParams = createParamDecorator((data, req): PaginationParams => {
   const {
-    _end,
+    _limit,
     _start,
     _order,
-    _sort,
+    _sortBy,
+    ..._filter
   } = req.query;
 
   return {
-    _end: +_end,
+    _limit: +_limit,
     _start: +_start,
     _order,
-    _sort,
+    _sortBy,
+    _filter,
   };
 });

src/pagination.interface.ts

@@ -3,4 +3,4 @@ import { PaginateableBaseEntity } from './paginateable.entity';
 export interface Pagination<T extends PaginateableBaseEntity> {
   data: T[];
   total: number;
-}
+}