Custom Service Implementation

Learn how to create custom CRUD service implementations for different ORMs or data sources

Overview

While the framework provides TypeOrmCrudService out of the box, you can create custom service implementations for other ORMs (like Mongoose, Prisma, Sequelize) or even non-database data sources (like REST APIs, GraphQL, etc.).

Creating a Custom Service

To create a custom CRUD service, extend the abstract CrudService class and implement all required methods.

Basic Structure

import { Injectable } from '@nestjs/common';
import { CrudService, CrudRequest, CreateManyDto, GetManyDefaultResponse } from '@nestjsx/crud';

@Injectable()
export class CustomCrudService<T> extends CrudService<T> {
  constructor(private dataSource: any) {
    super();
  }

  async getMany(req: CrudRequest): Promise<GetManyDefaultResponse<T> | T[]> {
    // Implementation
  }

  async getOne(req: CrudRequest): Promise<T> {
    // Implementation
  }

  async createOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    // Implementation
  }

  async createMany(req: CrudRequest, dto: CreateManyDto<T | Partial<T>>): Promise<T[]> {
    // Implementation
  }

  async updateOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    // Implementation
  }

  async replaceOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    // Implementation
  }

  async deleteOne(req: CrudRequest): Promise<void | T> {
    // Implementation
  }

  async recoverOne(req: CrudRequest): Promise<T> {
    // Implementation
  }
}

Mongoose Example

Here’s a complete example of a CRUD service for Mongoose:

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, FilterQuery } from 'mongoose';
import { CrudService, CrudRequest, CreateManyDto, GetManyDefaultResponse } from '@nestjsx/crud';
import { ParsedRequestParams } from '@nestjsx/crud-request';

@Injectable()
export class MongoCrudService<T> extends CrudService<T> {
  constructor(@InjectModel('ModelName') private model: Model<T>) {
    super();
  }

  async getMany(req: CrudRequest): Promise<GetManyDefaultResponse<T> | T[]> {
    const { parsed, options } = req;
    
    // Build query
    const filter = this.buildFilter(parsed);
    let query = this.model.find(filter);
    
    // Apply sorting
    if (parsed.sort && parsed.sort.length) {
      const sortObj = parsed.sort.reduce((acc, sort) => {
        acc[sort.field] = sort.order === 'ASC' ? 1 : -1;
        return acc;
      }, {});
      query = query.sort(sortObj);
    }
    
    // Apply pagination
    if (this.decidePagination(parsed, options)) {
      const limit = this.getTake(parsed, options.query);
      const skip = this.getSkip(parsed, limit);
      
      if (limit) query = query.limit(limit);
      if (skip) query = query.skip(skip);
      
      const [data, total] = await Promise.all([
        query.exec(),
        this.model.countDocuments(filter)
      ]);
      
      return this.createPageInfo(data, total, limit || total, skip || 0);
    }
    
    return query.exec();
  }

  async getOne(req: CrudRequest): Promise<T> {
    const { parsed } = req;
    const filter = this.buildFilter(parsed);
    
    const entity = await this.model.findOne(filter).exec();
    
    if (!entity) {
      this.throwNotFoundException(this.model.modelName);
    }
    
    return entity;
  }

  async createOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const entity = new this.model(dto);
    return entity.save();
  }

  async createMany(req: CrudRequest, dto: CreateManyDto<T | Partial<T>>): Promise<T[]> {
    if (!dto.bulk || !dto.bulk.length) {
      this.throwBadRequestException('Empty data. Nothing to save.');
    }
    
    return this.model.insertMany(dto.bulk);
  }

  async updateOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const { parsed } = req;
    const filter = this.buildFilter(parsed);
    
    const entity = await this.model.findOneAndUpdate(
      filter,
      { $set: dto },
      { new: true }
    ).exec();
    
    if (!entity) {
      this.throwNotFoundException(this.model.modelName);
    }
    
    return entity;
  }

  async replaceOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const { parsed } = req;
    const filter = this.buildFilter(parsed);
    
    const entity = await this.model.findOneAndReplace(
      filter,
      dto as any,
      { new: true }
    ).exec();
    
    if (!entity) {
      this.throwNotFoundException(this.model.modelName);
    }
    
    return entity;
  }

  async deleteOne(req: CrudRequest): Promise<void | T> {
    const { parsed, options } = req;
    const filter = this.buildFilter(parsed);
    const returnDeleted = options.routes?.deleteOneBase?.returnDeleted;
    
    if (returnDeleted) {
      const entity = await this.model.findOneAndDelete(filter).exec();
      if (!entity) {
        this.throwNotFoundException(this.model.modelName);
      }
      return entity;
    }
    
    await this.model.deleteOne(filter).exec();
  }

  async recoverOne(req: CrudRequest): Promise<T> {
    // Implement soft delete recovery if your schema supports it
    const { parsed } = req;
    const filter = this.buildFilter(parsed);
    
    const entity = await this.model.findOneAndUpdate(
      filter,
      { $unset: { deletedAt: 1 } },
      { new: true }
    ).exec();
    
    if (!entity) {
      this.throwNotFoundException(this.model.modelName);
    }
    
    return entity;
  }

  private buildFilter(parsed: ParsedRequestParams): FilterQuery<T> {
    const filter: FilterQuery<T> = {};
    
    // Build filter from parsed.search
    if (parsed.search) {
      // Convert parsed.search to Mongoose filter
      // This is a simplified example
      Object.keys(parsed.search).forEach(key => {
        if (key === '$and' || key === '$or') {
          filter[key] = parsed.search[key];
        } else {
          filter[key] = parsed.search[key];
        }
      });
    }
    
    // Add param filters
    if (parsed.paramsFilter?.length) {
      parsed.paramsFilter.forEach(param => {
        filter[param.field] = param.value;
      });
    }
    
    return filter;
  }
}

Prisma Example

Here’s an example for Prisma:

import { Injectable } from '@nestjs/common';
import { PrismaService } from './prisma.service';
import { CrudService, CrudRequest, CreateManyDto, GetManyDefaultResponse } from '@nestjsx/crud';

@Injectable()
export class PrismaCrudService<T> extends CrudService<T> {
  constructor(
    private prisma: PrismaService,
    private modelName: string
  ) {
    super();
  }

  private get model() {
    return this.prisma[this.modelName];
  }

  async getMany(req: CrudRequest): Promise<GetManyDefaultResponse<T> | T[]> {
    const { parsed, options } = req;
    
    const where = this.buildWhere(parsed);
    const orderBy = this.buildOrderBy(parsed);
    
    if (this.decidePagination(parsed, options)) {
      const take = this.getTake(parsed, options.query);
      const skip = this.getSkip(parsed, take);
      
      const [data, total] = await Promise.all([
        this.model.findMany({ where, orderBy, take, skip }),
        this.model.count({ where })
      ]);
      
      return this.createPageInfo(data, total, take || total, skip || 0);
    }
    
    return this.model.findMany({ where, orderBy });
  }

  async getOne(req: CrudRequest): Promise<T> {
    const { parsed } = req;
    const where = this.buildWhere(parsed);
    
    const entity = await this.model.findFirst({ where });
    
    if (!entity) {
      this.throwNotFoundException(this.modelName);
    }
    
    return entity;
  }

  async createOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    return this.model.create({ data: dto });
  }

  async createMany(req: CrudRequest, dto: CreateManyDto<T | Partial<T>>): Promise<T[]> {
    if (!dto.bulk || !dto.bulk.length) {
      this.throwBadRequestException('Empty data. Nothing to save.');
    }
    
    await this.model.createMany({ data: dto.bulk });
    return dto.bulk as T[];
  }

  async updateOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const { parsed } = req;
    const where = this.buildWhere(parsed);
    
    return this.model.update({ where, data: dto });
  }

  async replaceOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    // Prisma doesn't have a direct replace, so we update
    return this.updateOne(req, dto);
  }

  async deleteOne(req: CrudRequest): Promise<void | T> {
    const { parsed, options } = req;
    const where = this.buildWhere(parsed);
    const returnDeleted = options.routes?.deleteOneBase?.returnDeleted;
    
    if (returnDeleted) {
      return this.model.delete({ where });
    }
    
    await this.model.delete({ where });
  }

  async recoverOne(req: CrudRequest): Promise<T> {
    const { parsed } = req;
    const where = this.buildWhere(parsed);
    
    return this.model.update({
      where,
      data: { deletedAt: null }
    });
  }

  private buildWhere(parsed: any) {
    const where: any = {};
    
    // Build Prisma where clause from parsed request
    if (parsed.search) {
      // Convert to Prisma format
      Object.assign(where, parsed.search);
    }
    
    if (parsed.paramsFilter?.length) {
      parsed.paramsFilter.forEach(param => {
        where[param.field] = param.value;
      });
    }
    
    return where;
  }

  private buildOrderBy(parsed: any) {
    if (!parsed.sort?.length) return undefined;
    
    return parsed.sort.map(sort => ({
      [sort.field]: sort.order.toLowerCase()
    }));
  }
}

REST API Backend Example

You can even create a CRUD service that communicates with a REST API:

import { Injectable, HttpService } from '@nestjs/common';
import { CrudService, CrudRequest, CreateManyDto, GetManyDefaultResponse } from '@nestjsx/crud';
import { lastValueFrom } from 'rxjs';

@Injectable()
export class RestApiCrudService<T> extends CrudService<T> {
  constructor(
    private http: HttpService,
    private baseUrl: string
  ) {
    super();
  }

  async getMany(req: CrudRequest): Promise<GetManyDefaultResponse<T> | T[]> {
    const { parsed, options } = req;
    
    // Build query string from parsed parameters
    const params = this.buildQueryParams(parsed);
    
    const response = await lastValueFrom(
      this.http.get<any>(`${this.baseUrl}`, { params })
    );
    
    if (this.decidePagination(parsed, options)) {
      return {
        data: response.data.items,
        count: response.data.items.length,
        total: response.data.total,
        page: response.data.page,
        pageCount: response.data.pageCount
      };
    }
    
    return response.data;
  }

  async getOne(req: CrudRequest): Promise<T> {
    const { parsed } = req;
    const id = this.extractId(parsed);
    
    const response = await lastValueFrom(
      this.http.get<T>(`${this.baseUrl}/${id}`)
    );
    
    return response.data;
  }

  async createOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const response = await lastValueFrom(
      this.http.post<T>(`${this.baseUrl}`, dto)
    );
    
    return response.data;
  }

  async createMany(req: CrudRequest, dto: CreateManyDto<T | Partial<T>>): Promise<T[]> {
    const response = await lastValueFrom(
      this.http.post<T[]>(`${this.baseUrl}/bulk`, dto.bulk)
    );
    
    return response.data;
  }

  async updateOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const { parsed } = req;
    const id = this.extractId(parsed);
    
    const response = await lastValueFrom(
      this.http.patch<T>(`${this.baseUrl}/${id}`, dto)
    );
    
    return response.data;
  }

  async replaceOne(req: CrudRequest, dto: T | Partial<T>): Promise<T> {
    const { parsed } = req;
    const id = this.extractId(parsed);
    
    const response = await lastValueFrom(
      this.http.put<T>(`${this.baseUrl}/${id}`, dto)
    );
    
    return response.data;
  }

  async deleteOne(req: CrudRequest): Promise<void | T> {
    const { parsed, options } = req;
    const id = this.extractId(parsed);
    const returnDeleted = options.routes?.deleteOneBase?.returnDeleted;
    
    const response = await lastValueFrom(
      this.http.delete<T>(`${this.baseUrl}/${id}`)
    );
    
    return returnDeleted ? response.data : undefined;
  }

  async recoverOne(req: CrudRequest): Promise<T> {
    const { parsed } = req;
    const id = this.extractId(parsed);
    
    const response = await lastValueFrom(
      this.http.post<T>(`${this.baseUrl}/${id}/recover`, {})
    );
    
    return response.data;
  }

  private buildQueryParams(parsed: any): Record<string, any> {
    const params: Record<string, any> = {};
    
    if (parsed.limit) params.limit = parsed.limit;
    if (parsed.offset) params.offset = parsed.offset;
    if (parsed.page) params.page = parsed.page;
    if (parsed.sort?.length) {
      params.sort = parsed.sort.map(s => `${s.field},${s.order}`).join(';');
    }
    
    return params;
  }

  private extractId(parsed: any): string | number {
    if (parsed.paramsFilter?.length) {
      return parsed.paramsFilter[0].value;
    }
    throw new Error('No ID found in request');
  }
}

Using Your Custom Service

Once you’ve created your custom service, use it in your controller:

import { Controller } from '@nestjs/common';
import { Crud } from '@nestjsx/crud';
import { MongoCrudService } from './mongo-crud.service';
import { User } from './user.entity';

@Crud({
  model: {
    type: User,
  },
})
@Controller('users')
export class UsersController {
  constructor(public service: MongoCrudService<User>) {}
}

Best Practices

Reuse Base Utilities: Always use the inherited utility methods like decidePagination, getTake, getSkip, and createPageInfo for consistent behavior.

Error Handling: Use throwBadRequestException and throwNotFoundException for consistent error responses across your application.

Validation: Make sure to validate input data before processing. The framework doesn’t automatically validate DTOs in custom services.

Transaction Support: If your data source supports transactions, consider implementing transaction handling in your custom service for data consistency.

Advanced Customization

Override Pagination Format

You can override createPageInfo to customize the pagination response:

createPage Info(data: T[], total: number, limit: number, offset: number) {
  return {
    items: data,
    pagination: {
      total,
      limit,
      offset,
      hasMore: offset + data.length < total
    }
  };
}

Add Custom Methods

Extend your service with custom methods for specific use cases:

export class MongoCrudService<T> extends CrudService<T> {
  // ... standard CRUD methods ...

  async findByEmail(email: string): Promise<T> {
    const entity = await this.model.findOne({ email }).exec();
    if (!entity) {
      this.throwNotFoundException('User');
    }
    return entity;
  }

  async bulkUpdate(filter: any, update: any): Promise<number> {
    const result = await this.model.updateMany(filter, update).exec();
    return result.modifiedCount;
  }
}

See Also

• CrudService - Abstract base class documentation
• TypeOrmCrudService - Reference implementation for TypeORM