Typeorm Curd Generator

This code represent how to use Typeorm Curd Generator

Installation

npm i @prabink/nestjsx-typeorm-curd

Also install the following to work with this packages if not installed

npm i @nestjs/typeorm typeorm @nestjs/swagger

Usage/Examples

Service Using (TypeOrmCurdService)

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TypeOrmCurdService } from '@Pathto_typeorm-curd/typeorm-curd.service';
import { Repository } from 'typeorm';
import { User } from '../entities/user.entity';

@Injectable()
export class UserService extends TypeOrmCurdService<User> {
  constructor(
    @InjectRepository(User)
    public readonly usersRepository: Repository<User>,
  ) {
    super(usersRepository);
  }
}

Controller Using (TypeOrmCurdControllerFactory(options?: TypeOrmCurdFactoryOptions))

import { Controller } from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';
import { TypeOrmCurdControllerFactory } from 'src/shared/classes/typeorm-curd/typeorm-curd.factory';
import { CreateUserDto } from '../dto/create-user.dto';
import { UpdateUserDto } from '../dto/update-user.dto';
import { User } from '../entities/user.entity';
import { UserService } from '../services/user.service';

@ApiTags('User Controller')
@Controller('users')
export class UserController extends TypeOrmCurdControllerFactory<User>({
  modal: {
    type: User,
  },
  routes: {
    findAll: {
      decorators: [],
    },
    create: {
      dto: CreateUserDto,
    },
    update: {
      dto: UpdateUserDto,
    },
  },
  query: {
    join: [{ field: 'avatar' }, { field: 'role' }],
  },
}) {
  constructor(public readonly userService: UserService) {
    super(userService);
  }
}

TypeOrmCurdFactoryOptions

modal

  {
    modal: {
      type: any,
    },
  }

| Parameter | Type | Required | | :-------- | :---- | :------- | | type | any | true |

Example:

{
    modal: {
      type: User,
    },
  }

routes

  {
    routes?: {
      findAll?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
      };
      count?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
      };
      findById?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
      };
      create?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
        dto:any
      };
      update?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
        dto:any
      };
      delete?: {
        interceptors?: any[];
        decorators?: (PropertyDecorator | MethodDecorator)[];
      };
    };
  }

| Parameter | Type | Required | | :-------- | :------- | :------- | | findAll | object | false |

Example:

routes: {
    findAll: {
      interceptors: [],
      decorators: [],
    },
  }

| Parameter | Type | Required | | :-------- | :------- | :------- | | count | object | false |

Example:

routes: {
    count: {
      interceptors: [],
      decorators: [],
    },
  }

| Parameter | Type | Required | | :--------- | :------- | :------- | | findById | object | false |

Example:

routes: {
    findById: {
      interceptors: [],
      decorators: [],
    },
  }

| Parameter | Type | Required | | :-------- | :------- | :------- | | create | object | false |

Example:

routes: {
    create: {
      interceptors: [],
      decorators: [],
      dto: CreateUserDto
    },
  }

| Parameter | Type | Required | | :-------- | :------- | :------- | | update | object | false |

Example:

routes: {
    update: {
      interceptors: [],
      decorators: [],
      dto: UpdateUserDto
    },
  }

| Parameter | Type | Required | | :-------- | :------- | :------- | | delete | object | false |

Example:

routes: {
    delete: {
      interceptors: [],
      decorators: []
    },
  }

query

  {
    query: {
      fields: QueryFields;
      filter: QueryFilter[];
      or: QueryFilter[];
      join: QueryJoin[];
      sort: QuerySort[];
      pagination: boolean;
      limit: number;
      offset: number;
      page: number;
      cache: boolean;
      includeDeleted: boolean;
    },
  }

| Parameter | Type | Required | | :--------------- | :---------------------------------------------------------------------------------- | :------- | | fields | Array | false | | filter | Array<{field:string, operator:QueryCondOperator, value?:any}> | false | | or | Array<{field:string, operator:QueryCondOperator, value?:any}> | false | | join | Array<{field:string, select?:Array}> | false | | sort | Array<{field:string, order?:QuerySortOperator}> | false | | pagination | boolean | false | | limit | number | false | | offset | number | false | | page | number | false | | cache | boolean | false | | includeDeleted | boolean | false |

Reference Type

QuerySortOperator

| Value | Description | | :----- | :------------------------------------------------------------------------------------- | | ASC | Ascending means smallest to largest, 0 to 9, and/or A to Z | | DESC | Ascending means a series of data is arranged from high to low or largest to smallest |

QueryCondOperator

filter conditions

• $eq (=, equal)
• $ne (!=, not equal)
• $gt (>, greater than)
• $lt (<, lower that)
• $gte (>=, greater than or equal)
• $lte (<=, lower than or equal)
• $starts (LIKE val%, starts with)
• $ends (LIKE %val, ends with)
• $cont (LIKE %val%, contains)
• $excl (NOT LIKE %val%, not contains)
• $in (IN, in range, accepts multiple values)
• $notin (NOT IN, not in range, accepts multiple values)
• $isnull (IS NULL, is NULL, doesn't accept value)
• $notnull (IS NOT NULL, not NULL, doesn't accept value)
• $between (BETWEEN, between, accepts two values)
• $eqL (LOWER(field) =, equal)
• $neL (LOWER(field) !=, not equal)
• $startsL (LIKE|ILIKE val%)
• $endsL (LIKE|ILIKE %val, ends with)
• $contL (LIKE|ILIKE %val%, contains)
• $exclL (NOT LIKE|ILIKE %val%, not contains)
• $inL (LOWER(field) IN, in range, accepts multiple values)
• $notinL (LOWER(field) NOT IN, not in range, accepts multiple values)

Frontend usage

From frontend you can pass the query params as follows

Without using qs package

| Parameter | Usage | | :--------------- | :--------------------------------------------------------------------- | | fields | ?fields[0]=A&fields[1]=B | | filter | ?filter[0][field]=userName&filter[0][operator]=$eq&filter[0][value]=AB | | or | ?or[0][field]=userName&or[0][operator]=$eq&or[0][value]=AB | | join | ?join[0][field]=role // Use?join[0][field]=* for all | | sort | ?sort[0][field]=role&sort[0][order]=DESC | | limit | ?limit=50 | | offset | ?offset=0 | | pagination | ?pagination=true | | page | ?page=1 | | cache | ?cache=false | | includeDeleted | ?includeDeleted=false |

With using qs package

const qs = require('qs');
const query = qs.stringify(
  {
    fields: ['id', 'userName', 'email'], // Use [] for all
    filter: [{ field: 'userName', operator: '$eq', value: 'AB' }],
    or: [{ field: 'userName', operator: '$eq', value: 'AB' }],
    join: [{ field: 'role' }, { field: 'avatar' }], // Use ['*'] for all
    sort: [{ field: 'userName', order: 'DESC' }],
    limit: 50,
    offset: 0,
    pagination: true,
    page: 1,
    cache: false,
    includeDeleted: false,
  },
  {
    encodeValuesOnly: true, // prettify URL
  },
);
await request('/api/users?{query}');

Authors

• @prabinkarki643

Tech Stack

Server: Node, Postgress, NestJs, Typescript