@nestjs/graphql#ResolveField TypeScript Examples

@ResolveField(() => [FormFieldOptionModel])
  async options(
    @Parent() parent: FormFieldModel,
    @Context('cache') cache: ContextCache,
  ): Promise<FormFieldOptionModel[]> {
    const field = await cache.get<FormFieldEntity>(cache.getCacheKey(
      FormFieldEntity.name,
      parent._id
    ))

    if (!field.options) {
      return []
    }

    return field.options.map(option => new FormFieldOptionModel(
      this.idService.encode(option.id),
      option,
    ))
  }

@ResolveField(() => [User])
  async lockedByUser(@Parent() block: Block): Promise<User> {
    if (block.lockedByUserId) {
      return this.userService.findUser({
        where: {
          id: block.lockedByUserId
        }
      });
    } else {
      return null;
    }
  }

@ResolveField(() => [FormFieldLogicModel])
  async logic(
    @Parent() parent: FormFieldModel,
    @Context('cache') cache: ContextCache,
  ): Promise<FormFieldLogicModel[]> {
    const field = await cache.get<FormFieldEntity>(cache.getCacheKey(
      FormFieldEntity.name,
      parent._id
    ))

    if (!field.logic) {
      return []
    }

    return field.logic.map(logic => new FormFieldLogicModel(
      this.idService.encode(logic.id),
      logic,
    ))
  }

@ResolveField(() => [BlockVersion])
  async versions(
    @Parent() entity: Block,
    @Args() args: FindManyBlockVersionArgs
  ): Promise<BlockVersion[]> {
    return this.blockService.getVersions({
      ...args,
      where: {
        ...args.where,
        block: { id: entity.id }
      }
    });
  }

@ResolveField(() => DesignModel)
  async design(
    @User() user: UserEntity,
    @Parent() parent: FormModel,
    @Context('cache') cache: ContextCache,
  ): Promise<DesignModel> {
    const form = await cache.get<FormEntity>(cache.getCacheKey(FormEntity.name, parent._id))

    return new DesignModel(form.design)
  }

export function ResolveConnectionField(
  nodeTypeFunc: ReturnTypeFunc,
  options?: ResolveConnectionFieldOptions,
): MethodDecorator {
  return (target: Record<string, any>, key: string | symbol, descriptor: PropertyDescriptor) => {
    // eslint-disable-next-line @typescript-eslint/ban-types
    const nodeType = nodeTypeFunc() as Function;
    const typeMetadata = MetadataStorage.getClassMetadata({ target: nodeType });

    const connection = ConnectionTypeFactory.create({
      nodeTypeFunc,
      nodeTypeName: typeMetadata.name,
    });

    const resolveFieldOptions = { ...options, nullable: true };
    ResolveField(() => connection, resolveFieldOptions)(target, key, descriptor);
  };
}

@ResolveField(() => [String])
  @Roles('user')
  async roles(
    @User() user: UserEntity,
    @Parent() parent: UserModel,
    @Context('cache') cache: ContextCache,
  ): Promise<string[]> {
    return this.returnFieldForSuperuser(
      await cache.get<UserEntity>(cache.getCacheKey(UserEntity.name, parent._id)),
      user,
      c => c.roles
    )
  }

@ResolveField(() => [Entity])
  async entities(
    @Parent() app: App,
    @Args() args: FindManyEntityArgs
  ): Promise<Entity[]> {
    return this.entityService.entities({
      ...args,
      where: { ...args.where, app: { id: app.id } }
    });
  }

@ResolveField(() => UserModel, { nullable: true })
  @Roles('admin')
  async admin(
    @Parent() parent: FormModel,
    @Context('cache') cache: ContextCache,
  ): Promise<UserModel> {
    const form = await cache.get<FormEntity>(cache.getCacheKey(FormEntity.name, parent._id))

    if (!form.admin) {
      return null
    }

    return new UserModel(this.idService.encode(form.admin.id), form.admin)
  }

@ResolveField()
  async roles(@Parent() user) {
    return user.roles || [];
  }

@ResolveField(() => GraphQLInt)
  @Roles('admin')
  total(): Promise<number> {
    return this.statisticService.getTotal()
  }

@ResolveField()
    dbmss(
        @Context('environment') environment: Environment,
        @Parent() project: Project,
        @Args() {filters}: FilterArgs,
    ): Promise<List<ProjectDbms>> {
        return environment.projects.listDbmss(project.name, filters);
    }

@ResolveField(() => [GitOrganization])
  async gitOrganizations(
    @Parent() workspace: Workspace
  ): Promise<GitOrganization[]> {
    return this.workspaceService.findManyGitOrganizations(workspace.id);
  }

@ResolveField(() => Int)
  @Roles('admin')
  total(): Promise<number> {
    return this.statisticService.getTotal()
  }

@ResolveField(() => Account)
  async account(@Parent() user: User) {
    return await this.userService.getAccount(user.id);
  }

GlobalIdField = (options?: GlobalIdFieldOptions) =>
  ResolveField(typeResolvedGlobalId, {
    name: 'id',
    nullable: false,
    ...options,
  })

@ResolveField(() => Boolean)
  hasPaws(@Parent() animal: Animal) {
    return true;
  }

//resolve the parentBlock property as a generic block
  @ResolveField(() => Block, { nullable: true })
  async parentBlock(@Parent() block: Block): Promise<Block> {
    return this.blockService.getParentBlock(block);
  }

@ResolveField(() => String)
  uniqueName(@Parent() person: Person) {
    return `${person.id}__${person.name}`;
  }

/**
   * Field resolver
   */
  @ResolveField()
  async tagGroup(@Root() tag: Tag): Promise<ITagGroup> {
    // eslint-disable-next-line no-underscore-dangle
    return this.tagGroupService.findOne(tag.tagGroup._id);
  }

@ResolveField(() => [ActionStep])
  async steps(@Parent() action: Action) {
    return this.service.getSteps(action.id);
  }