sksharma72000\nestjs-gqlsearch-page

Installation:

1. Install via Composer:

   1npm install @sksharma72000/nestjs-gqlsearch-page

Features:

1. Easy conditional searching using dto with query parameter.
2. Relational table searching
3. Relational table data extraction
4. Customizable condition ie AND, OR. Default OR
5. Customizable operation of MYSQL QUERY ie LIKE, EQUAL, GREATEN THEN, other,
6. Easy pagination with start and end page, order by column, sort type ie. ASC, DESC

Uses:

1. @PageSearch Decorator
   You can define your custom data transfer object defining your quering attributes. Your quering attributes are the table column where your query keyword would be search. @PageSearch decorator accept IPageSearch interface object.

   interface IPageSearch {
       is_relational?: boolean;
       column?: string;
       is_nested?: boolean;
       operation?: Operation;
       operator?: Operator;
       value?: string | number | boolean | null;
   }
   

   is_relational: Indicate if the attribute is relational. By Default, if attribute value type is boolen,
   then attribute is considered as relational unless it is set to false.
   ie this will extract the relational table of current table with name of attribute and add to your response. Default value is null.
   
   column: Name of table's column where your want to query. Default value is the name of the attribute.
   
   is_nested: Indicate if current quering attribute is of relational table column. If the column name
   consist of dot ie '.' then the attribute is taken nested. When this options is set to true,
   column option must be define indicating the relational table name and column name
   saperated by dot. Default is false.
   Example :
   {column:"post.title"}
   
   operation: Operation are one of "eq" | "neq" | "in" | "gt" | "gteq" | "lt" | "lteq" | "like" | "between". Default is "like".
   
   operator: Operator are one of "and" | "or". Default is "and".
   
   value: Value of query attribute. It can be one of type: string | number | boolean | null. Default is null.\

2. IPage
   IPage defines the attribute that customize your pagination. Your dto should implements IPage or has all attribute of IPage defined. IPage consist of following attributes :

   interface IPage {
       _start: number;
       _end: number;
       _sort: string;
       _order: SortDirection;
   }
   

   _start: Define from which row you want to the data list to start from.
   Example:
   Start from 10th item of 1000 items
   
   _end: Define upto which row you want the data list.
   Example:
   Upto 100th item of 1000 items.
   With this the item from 10th to 100th will be responsed.
   
   _sort: Define the column that you want the list to be sorted by. By default, the list will be sorted by id in DESC order.
   
   _order: Define the order of column you want the list to be sorted by. By default, the list will be sorted buy in DESC order of id column.

3. findAllByPage
   It is the function that is responsible for quering into table with to enable pagination in your service. It takes IFindAllByPage interface as parameter. IFindAllByPage consist of repo, page, queryDto, customQuery where repo is your repositiry to perform query, page is IPage, queryDto is your dto and customQuery is where you can add custom where condition. It taked the Model class as its type.
   Example :

   findAllByPage<Comment>({ repo: this.commentRepository, page: pagable, queryDto: commentDto });
   

4. findOne
   This findOne perform query by id into your repository and gets you one model result or null. It takes IFindOne interface as parameter. IFindOne consist of id, repo, queryDto, customQuery where id is id of model, repo is your repositiry to perform query, queryDto is your dto and customQuery is where you can add custom where condition. It taked the Model class as its type.
   Example :

   findOne<Comment>({id:1, repo: this.commentRepository, queryDto: commentDto });
   

5. findOptions
It is the function that is responsible for building typeorm FindManyOptions and return the options. It is similar to findAllByPage, except it does not takes repo and does not actually perform query, rather returns the FindManyOptions so you can futher customize the where option and run your query. It takes IFindOptionByPage interface as parameter. IFindOptionByPage consist of page, queryDto, customQuery where page is IPage, queryDto is your dto and customQuery is where you can add custom where condition. It taked the Model class as its type.
Example :

```
findOptions<Comment>({ page: pagable, queryDto: commentDto });
/*
{
    where, #your where condition from dto
    order, #your order from IPage sort
    relations, #your relation from dto,
    skip, #your skip from from IPage start
    take, #your take from from IPage end
}
*/

```

This is how your CommentService looks like.

Example : Your Entity

1     import { Injectable } from '@nestjs/common';
2     import { findAllByPage, findOne, Page, IPage } from '@sksharma72000/nestjs-gqlsearch-page';
3     import { InjectRepository } from '@nestjs/typeorm';
4     import { Repository } from "typeorm";
5     import { Comment } from './entities/comment.entity';
6     import { CommentSearchDto } from './dtos/comment.search.dto';
7
8     @Injectable()
9     export class CommentService {
10         constructor(
11             @InjectRepository(Comment)
12             private readonly commentRepository: Repository<Comment>
13         ) {
14         }
15         getAll(
16             pagable: IPage,
17             commentDto: CommentSearchDto
18         ): Promise<Page<Comment>> {
19             return findAllByPage<Comment>({repo:this.commentRepository, page:pagable, queryDto:commentDto, customQuery:[{column: 'status',value:'active', operation: "eq", operator: "and" }]});
20         }
21
22         getOne(
23             id: number,
24             commentDto: CommentSearchDto
25         ): Promise<Page<Comment>> {
26             return findOne<Comment>({id,repo:this.commentRepository,queryDto:commentDto,customQuery:[{column:'status',value:'active', operation: "eq", operator: "and" }]});
27         }
28     }

Following is how your CommentSearchDto looks like:

1        import { PageSearch } from '@sksharma72000/nestjs-gqlsearch-page'
2        import { Type } from 'class-transformer'
3        import { IsOptional } from 'class-validator'
4        export class CommentSearchDto {
5            @IsOptional()
6            @PageSearch({ column: "post.title" })
7            post_title: string
8
9            @IsOptional()
10            @Type(() => Boolean)
11            @PageSearch({column:"post.author"})//here indication column name as 'post.author' for relation will return post with its relational column author
12            post: boolean
13
14            @IsOptional()
15            @Type(() => Number)
16            @PageSearch({ operation: "eq", operator: "and" })
17            post_id: number
18
19            @IsOptional()
20            @PageSearch()
21            message: string
22
23        }

\

Following is how your CommentController looks like:

1        import {
2            Param,
3            Query,
4            UsePipes,
5            ValidationPipe,
6            Controller,
7            Get
8        } from '@nestjs/common';
9        import { CommentService } from './comment.service';
10        import { PagableDto } from './dtos/pagable.dto';
11        import { CommentSearchDto } from './dtos/comment.search.dto';
12
13        @Controller("comments")
14        export class AppController {
15            constructor(private readonly commentService: CommentService) { }
16
17            @Get("/")
18            @UsePipes(new ValidationPipe({
19                whitelist: true,
20                transform: true
21            }))
22            getComments(
23                @Query() commentSearchDto: CommentSearchDto,
24                @Query() pagableDto: PagableDto,
25            ) {
26                return this.commentService.getAll(pagableDto, commentSearchDto);
27            }
28
29            @Get("/:id")
30            getOne(
31                @Param("id") id: number,
32                @Query() commentSearchDto: CommentSearchDto,
33            ) {
34                return this.commentService.getOne(id, commentSearchDto);
35            }
36            
37        }
38

Now you can make search url query for searching your comment

http://localhost:5000/comments?post=true&post_id=1&message=Hello&_start=10&_end=50
http://localhost:5000/comments/5?post=true

Github:

Want to explor the code for free.

We appreciate your star and fork on github : https://github.com/shreekrishnaacharya/nestjs-gqlsearch-page

Contributing:

We welcome contributions! Please see Contribution Guidelines: https://github.com/shreekrishnaacharya/nestjs-gqlsearch-page/CONTRIBUTING.md

License:

Open-source licensed under the MIT license: https://opensource.org/licenses/MIT

Credits:

Developed by Shree Krishna Acharya: https://www.linkedin.com/in/shree-krishna-acharya/ Built on top of the amazing Laravel framework