QueryService

{
  count: ['id'],
  sum: ['priority'],
  avg: ['priority'],
  min: ['id', 'title'],
  max: ['id', 'title']
}

;[
  {
    count: { id: 5 },
    sum: { id: 10 },
    avg: { id: 2.5 },
    min: { id: 1, title: 'A Title' },
    max: { id: 4, title: 'Z Title' }
  }
]

import { InjectQueryService, QueryService, RelationQueryService } from '@ptc-org/nestjs-query-core'
import { TodoItemEntity } from './todo-item.entity'
import { SubTaskEntity } from '../sub-task/sub-task.entity'

export class TodoItemService extends RelationQueryService<TodoItemEntity> {

  constructor(
    @InjectQueryService(TodoItemEntity) queryService: QueryService<TodoItemEntity>,
    @InjectQueryService(SubTaskEntity) subTaskQueryService: QueryService<SubTaskEntity>
  ) {
    // provide the original query service so all relations defined in the ORM work
    super(queryService, {
      // specify the virtual relations
      completedSubTasks: {
        // provide the service that will be used to query the relation
        service: subTaskQueryService,
        // the query method accepts a todoItem that can be used to filter the relations
        query(todoItem) {
          // filter for all relations that belong to the todoItem and are completed
          return { filter: { todoItemId: { eq: todoItem.id }, completed: { is: true } } }
        }
      }
    })
  }
}

import { FilterableField, IDField, FilterableConnection, KeySet } from '@ptc-org/nestjs-query-graphql'
import { ObjectType, ID, GraphQLISODateTime, Field } from '@nestjs/graphql'
import { SubTaskDTO } from '../../sub-task/dto/sub-task.dto'

@ObjectType('TodoItem')
@KeySet(['id'])
@FilterableConnection('subTasks', () => SubTaskDTO)
@FilterableConnection('completedSubTasks', () => SubTaskDTO)
export class TodoItemDTO {

  @IDField(() => ID)
  id!: number

  @FilterableField()
  title!: string

  @FilterableField({ nullable: true })
  description?: string

  @FilterableField()
  completed!: boolean

  @FilterableField(() => GraphQLISODateTime)
  created!: Date

  @FilterableField(() => GraphQLISODateTime)
  updated!: Date
}

import { NestjsQueryGraphQLModule } from '@ptc-org/nestjs-query-graphql'
import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm'
import { Module } from '@nestjs/common'
import { SubTaskDTO } from './dto/sub-task.dto'
import { SubTaskEntity } from './sub-task.entity'

// define the persistence module so it can be exported
const nestjsQueryTypeOrmModule = NestjsQueryTypeOrmModule.forFeature([SubTaskEntity])

@Module({
  imports: [
    NestjsQueryGraphQLModule.forFeature({
      // import it in the graphql module
      imports: [nestjsQueryTypeOrmModule],
      resolvers: [
        {
          DTOClass: SubTaskDTO,
          EntityClass: SubTaskEntity
        }
      ]
    }),
    // import it into the subTaskModule so it can be exported
    nestjsQueryTypeOrmModule
  ],
  // export the persistence module so it can be used by the TodoItemService
  exports: [nestjsQueryTypeOrmModule]
})
export class SubTaskModule {}

import { NestjsQueryGraphQLModule } from '@ptc-org/nestjs-query-graphql'
import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm'
import { Module } from '@nestjs/common'
import { TodoItemDTO } from './dto/todo-item.dto'
import { TodoItemAssembler } from './todo-item.assembler'
import { TodoItemEntity } from './todo-item.entity'
import { TodoItemResolver } from './todo-item.resolver'
import { TodoItemService } from './todo-item.service'
import { SubTaskModule } from '../sub-task/sub-task.module'

@Module({
  providers: [TodoItemResolver],
  imports: [
    NestjsQueryGraphQLModule.forFeature({
      // import the persistence module for the TodoItemEntity and the SubTaskModule
      imports: [NestjsQueryTypeOrmModule.forFeature([TodoItemEntity]), SubTaskModule],
      services: [TodoItemService],
      assemblers: [TodoItemAssembler],
      resolvers: [
        {
          DTOClass: TodoItemDTO,
          ServiceClass: TodoItemService
        }
      ]
    })
  ]
})
export class TodoItemModule {}

import { Logger, LoggerService } from '@nestjs/common'
import { DeepPartial } from '../common'
import { Filter, DeleteManyResponse, DeleteOneOptions, UpdateManyResponse, UpdateOneOptions } from '../interfaces'
import { ProxyQueryService } from './proxy-query.service'
import { QueryService } from './query.service'

export class MutationLoggerQueryService<DTO, C = DeepPartial<DTO>, U = DeepPartial<DTO>> extends ProxyQueryService<DTO, C, U> {

  private readonly logger: LoggerService
  constructor(label: string, queryService: QueryService<DTO, C, U>) {
    // call super witht the QueryService we will delegate to
    super(queryService)
    // create our logger
    this.logger = new Logger(label)
  }
  // Override all the create, update, and delete methods to add the timed logging functionality
  createMany(items: C[]): Promise<DTO[]> {
    return this.timedLog(`create many [itemCount=${items.length}]`, () => super.createMany(items))
  }
  createOne(item: C): Promise<DTO> {
    return this.timedLog(`create one`, () => super.createOne(item))
  }
  deleteMany(filter: Filter<DTO>): Promise<DeleteManyResponse> {
    return this.timedLog(`delete many`, () => super.deleteMany(filter))
  }
  deleteOne(id: number | string, opts?: DeleteOneOptions<DTO>): Promise<DTO> {
    return this.timedLog(`delete one [id=${id}]`, () => super.deleteOne(id, opts))
  }
  updateMany(update: U, filter: Filter<DTO>): Promise<UpdateManyResponse> {
    return this.timedLog('update many', () => super.updateMany(update, filter))
  }
  updateOne(id: string | number, update: U, opts?: UpdateOneOptions<DTO>): Promise<DTO> {
    return this.timedLog(`update one [id=${id}]`, () => super.updateOne(id, update, opts))
  }
  private async timedLog<T>(message, fn: () => Promise<T>): Promise<T> {
    const start = new Date()
    const result = await fn()
    const duration = start.getTime() - new Date().getTime()
    this.logger.log(`${message} [duration=${duration}]`)
    return result
  }
}

import { InjectQueryService, QueryService } from '@ptc-org/nestjs-query-core'
import { MutationLoggerQueryService } from '../utilities/mutation-logger-query.service'
import { TodoItemEntity } from './todo-item.entity'

@QueryService(TodoItemEntity)
export class TodoItemService extends MutationLoggerQueryService<TodoItemEntity> {

  constructor(@InjectQueryService(TodoItemEntity) service: QueryService<TodoItemEntity>) {
    // provide the logger name and the service
    super(TodoItemService.name, service)
  }
}

import { NestjsQueryGraphQLModule } from '@ptc-org/nestjs-query-graphql'
import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm'
import { Module } from '@nestjs/common'
import { TodoItemDTO } from './dto/todo-item.dto'
import { TodoItemEntity } from './todo-item.entity'
import { TodoItemService } from './todo-item.service'

@Module({
  imports: [
    NestjsQueryGraphQLModule.forFeature({
      imports: [NestjsQueryTypeOrmModule.forFeature([TodoItemEntity])],
      services: [TodoItemService],
      resolvers: [
        {
          DTOClass: TodoItemDTO,
          ServiceClass: TodoItemService
        }
      ]
    })
  ]
})
export class TodoItemModule {}

import {
  applyFilter,
  applyQuery,
  DeleteManyResponse,
  DeleteOneOptions,
  Filter,
  FindByIdOptions,
  GetByIdOptions,
  NoOpQueryService,
  Query,
  QueryService,
  UpdateManyResponse,
  UpdateOneOptions
} from '@ptc-org/nestjs-query-core'
import { NotFoundException } from '@nestjs/common'
import { TodoItemEntity } from './todo-item.entity'

@QueryService(TodoItemEntity)
export class TodoItemService extends NoOpQueryService<TodoItemEntity> {

  private records: TodoItemEntity[]
  constructor() {
    super()
    this.records = []
  }
  createMany(items: TodoItemEntity[]): Promise<TodoItemEntity[]> {
    this.records.push(...items)
    return Promise.resolve(items)
  }
  createOne(item: TodoItemEntity): Promise<TodoItemEntity> {
    this.records.push(item)
    return Promise.resolve(item)
  }
  async updateMany(update: Partial<TodoItemEntity>, filter: Filter<TodoItemEntity>): Promise<UpdateManyResponse> {
    const recordsToUpdate = await this.query({ filter })
    recordsToUpdate.forEach((r) => Object.assign(r, update))
    return { updatedCount: recordsToUpdate.length }
  }
  async updateOne(
    id: string | number,
    update: Partial<TodoItemEntity>,
    opts?: UpdateOneOptions<TodoItemEntity>
  ): Promise<TodoItemEntity> {
    const record = await this.getById(id, opts)
    return Object.assign(record, update)
  }
  async deleteMany(filter: Filter<TodoItemEntity>): Promise<DeleteManyResponse> {
    const recordIds = (await this.query({ filter })).map((r) => r.id)
    this.records = this.records.filter((r) => !recordIds.includes(r.id))
    return Promise.resolve({ deletedCount: recordIds.length })
  }
  async deleteOne(id: number | string, opts?: DeleteOneOptions<TodoItemEntity>): Promise<TodoItemEntity> {
    const record = await this.getById(id, opts)
    this.records = this.records.filter((r) => r.id !== record.id)
    return Promise.resolve(record)
  }
  findById(id: string | number, opts?: FindByIdOptions<TodoItemEntity>): Promise<TodoItemEntity | undefined> {
    const record = applyFilter(this.records, opts?.filter ?? {}).find((r) => r.id === id)
    return Promise.resolve(record)
  }
  async getById(id: string | number, opts?: GetByIdOptions<TodoItemEntity>): Promise<TodoItemEntity> {
    const record = await this.findById(id, opts)
    if (!record) {
      throw new NotFoundException(`Unable to find TodoItem with id ${id}`)
    }
    return record
  }
  query(query: Query<TodoItemEntity>): Promise<TodoItemEntity[]> {
    return Promise.resolve(applyQuery(this.records, query))
  }
  async count(filter: Filter<TodoItemEntity>): Promise<number> {
    const found = await this.query({ filter })
    return found.length
  }
}