@nestjs/graphql#Query TypeScript Examples

@Query(() => [DomesticAnimal])
  domesticAnimals(
    @Args({ name: 'species', type: () => Species, nullable: true })
    species?: Species,
  ) {
    switch (species) {
      case Species.DOG:
        return this.dogService.dogs();
      case Species.CAT:
        return this.catService.cats();
      default:
        return [...this.dogService.dogs(), ...this.catService.cats()];
    }
  }

@Query(() => [UserResponse])
  async findUsers(
    @Args('input') input: FindUsersRequest,
  ): Promise<UserResponse[]> {
    const query = new FindUsersQuery(input);
    const users = await this.userRepo.findUsers(query);

    return users.map(user => new UserResponse(user));
  }

@Query(() => [Whisp], { nullable: true })
  async whisps(
    @Args('filter', { type: () => GraphQLJSONObject, nullable: true })
      filter?: Record<string, unknown>,
    @Args('sort', { type: () => GraphQLJSONObject, nullable: true })
      sort?: Record<string, unknown>,
    @Args('limit', { type: () => Int, nullable: true }) limit?: number,
  ): Promise<IWhisp[]> {
    return this.whispService.findAll(filter, sort, limit);
  }

/**
   * Implement GraphQL Query 'login'
   *
   * @param signInPayload from lib shared-data-access-interfaces
   */
  @Query('login')
  async login(
    @SignIn() signInPayload: ISignAuthPayload
  ): Promise<ISignAuthResponse> {
    return await this.authService.login(signInPayload);
  }

@Query(() => [App], {
    nullable: false,
    description: undefined
  })
  @Roles('ORGANIZATION_ADMIN')
  @InjectContextValue(
    InjectableResourceParameter.WorkspaceId,
    'where.workspace.id'
  )
  async apps(@Args() args: FindManyAppArgs): Promise<App[]> {
    return this.appService.apps(args);
  }

@Query(() => AppLaunchData)
    async [PUBLIC_GRAPHQL_METHODS.APP_LAUNCH_DATA](
        @Context('environment') environment: Environment,
        @Args() {appName, launchToken}: LaunchDataArgs,
    ): Promise<AppLaunchData> {
        const {dbmsId, projectId, ...rest} = await environment.extensions.parseAppLaunchToken(appName, launchToken);
        const dbms = await environment.dbmss.get(dbmsId);
        const appLaunchData: AppLaunchData = {
            ...rest,
            dbms,
            environmentId: environment.id,
        };

        if (projectId) {
            appLaunchData.project = {
                ...(await environment.projects.get(projectId)),
                files: [],
            };
        }

        return appLaunchData;
    }

@Query(() => RawgGameResponse, {
    name: 'allGames',
  })
  async getAllGames(
    @Args('page', { nullable: true, type: () => Int }) page?: number,
    @Args('pageSize', { nullable: true, type: () => Int }) pageSize?: number,
    @Args('dates', { nullable: true }) dates?: string,
    @Args('ordering', { nullable: true }) ordering?: string,
    @Args('tags', { nullable: true }) tags?: string,
    @Args('genres', { nullable: true }) genres?: string,
    @Args('publishers', { nullable: true }) publishers?: string,
    @Args('search', { nullable: true }) search?: string,
  ): Promise<RawgGameResponse> {
    const params = {
      key: this.apiKey,
      page,
      page_size: pageSize || 10,
      search,
      genres,
      tags,
      publishers,
      dates,
      ordering,
    };
    this.logger.debug('getAllGames called with params', params);
    const res = await this.httpService
      .get<RawgGameResponse>(`${this.host}/games?${stringifyQueryObject(params)}`)
      .toPromise();
    const rawgResponse = plainToClass(RawgGameResponse, res.data);
    return rawgResponse;
  }

@Query(() => FormPagerModel)
  @Roles('user')
  async listForms(
    @User() user: UserEntity,
    @Args('start', {type: () => Int, defaultValue: 0, nullable: true}) start: number,
    @Args('limit', {type: () => Int, defaultValue: 50, nullable: true}) limit: number,
    @Context('cache') cache: ContextCache,
  ): Promise<FormPagerModel> {
    const [forms, total] = await this.formService.find(
      start,
      limit,
      {},
      user.roles.includes('superuser') ? null : user,
    )

    forms.forEach(form => cache.add(cache.getCacheKey(FormEntity.name, form.id), form))

    return new FormPagerModel(
      forms.map(form => new FormModel(this.idService.encode(form.id), form)),
      total,
      limit,
      start,
    )
  }

@Query(returnsNodeInterface, {
    name: 'node',
    description: 'Fetches an object given its ID',
    nullable: true,
  })
  node(
    @Args({
      name: 'id',
      nullable: false,
      description: 'The ID of an object',
      type: typeResolvedGlobalId,
    })
    id: ResolvedGlobalId,
  ): ResolvedNode {
    return this.resolveNode(id);
  }

/**
   * Query for single user.
   */
  @Query(() => [Dummy])
  dummies() {
    const dummy = new Dummy();
    dummy.json = {
      a: 1,
    };
    dummy.decimal = new Prisma.Decimal(1.002);
    return [dummy];
  }

@Query(() => [Animal])
  animals() {
    return [...this.dogService.dogs(), ...this.catService.cats()];
  }

/**
   * Queries
   */

  @Query(() => [Tag], { nullable: true })
  async tags(@Args('tag') tagFilter: TagInputType): Promise<ITag[]> {
    return this.tagService.findAll(tagFilter);
  }

/**
   * Implement GraphQL Query 'logout'
   */
  @Query('logout')
  async logout(): Promise<boolean> {
    return true;
  }

@Query(() => UserInfo)
  @common.UseGuards(GqlDefaultAuthGuard, gqlACGuard.GqlACGuard)
  async userInfo(@UserData() userInfo: UserInfo): Promise<UserInfo> {
    return userInfo;
  }

@Query('getHello')
  hello(@Tracing() tracing: TracingData): string {
    Logger.log({ getHello: tracing });
    return this.appService.getHello();
  }

@Query(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.read, Post)
  async post(@Args('id') id: string) {
    return this.postService.findById(id);
  }

@Query(/* istanbul ignore next */ () => Notification)
  notification(
    @Args('id', { type: /* istanbul ignore next */ () => ID }) id: string,
  ) {
    return this.notificationService.findOne({ id });
  }

@Query(() => [Db]!)
    async [PUBLIC_GRAPHQL_METHODS.LIST_DBS](
        @Context('environment') environment: Environment,
        @Args() {dbmsId, user, accessToken}: ListDbArgs,
    ): Promise<List<IDb>> {
        return environment.dbs.list(dbmsId, user, accessToken);
    }

@Query(() => FormStatisticModel)
  getFormStatistic(): FormStatisticModel {
    return new FormStatisticModel()
  }