type-graphql#FieldResolver TypeScript Examples

@FieldResolver(returns => [Subcourse])
    @Authorized(Role.ADMIN)
    async subcourses(@Root() course: Course) {
        return await prisma.subcourse.findMany({
            where: {
                courseId: course.id
            }
        });
    }

@FieldResolver(() => Int, { nullable: true })
  async voteStatus(
    @Root() post: Post,
    @Ctx() { updootLoader, req }: MyContext
  ) {
    if (!req.session.userId) {
      return null;
    }

    const updoot = await updootLoader.load({
      postId: post.id,
      userId: req.session.userId,
    });

    return updoot ? updoot.value : null;
  }

@FieldResolver(returns => [Student])
    @Authorized(Role.ADMIN)
    // eslint-disable-next-line camelcase
    async student(@Root() certificate: Certificate_of_conduct) {
        return await prisma.student.findUnique({
            where: {
                id: certificate.studentId
            }
        });
    }

@Directive(`@requires(fields: "price weight")`)
  @FieldResolver(returns => Number)
  async shippingEstimate(@Root() product: Product): Promise<number> {
    // free for expensive items
    if (product.price > 1000) {
      return 0;
    }

    // estimate is based on weight
    return product.weight * 0.5;
  }

@FieldResolver(returns => String, { nullable: true })
    @Authorized(Role.ADMIN)
    image(@Root() course: Course) {
        if (!course.imageKey) {
            return null;
        }

        return accessURLForKey(course.imageKey);
    }

@FieldResolver((returns) => TopicAuthor)
  async author(@Root() topic: Topic) {
    const author = await prisma.user.findUnique({
      where: {
        id: topic.authorId,
      },
    })
    return author
  }

@FieldResolver()
  @Loader<string, Chair[]>(async (ids) => {
    const chairs = await getRepository(Chair).find({
      where: { company: { id: In([...ids]) } },
    });
    const chairsById = groupBy(chairs, "companyId");
    return ids.map((id) => chairsById[id] ?? []);
  })
  chairs(@Root() root: Company) {
    return (dataloader: DataLoader<string, Chair[]>) =>
      dataloader.load(root.id);
  }

@FieldResolver((returns) => TopicExternalLink, { nullable: true })
  externalLink(@Root() topic: Topic) {
    if (!topic.url) return null

    const url = new URL(topic.url)
    return {
      url: url.href,
      domain: url.hostname.replace(/^www\./, ''),
    }
  }

@FieldResolver(() => User, { nullable: true })
    async [authorKey](@Root() post: Post): Promise<TUser | undefined> {
        try {
            if (post.authorId)
                return await this.userRepository.getUserById(post.authorId);
        } catch (e) {
            logger.error(e);
        }
    }

@FieldResolver((returns) => Int)
  async likesCount(@Root() topic: Topic) {
    const count = await prisma.userTopicLike.count({
      where: {
        topicId: topic.id,
      },
    })
    return count
  }

@FieldResolver(type => [ParticipationCertificate])
    @Authorized(Role.ADMIN, Role.OWNER)
    @LimitEstimated(10)
    async participationCertificatesToSign(@Root() pupil: Required<Pupil>) {
        return await prisma.participation_certificate.findMany({
            where: { pupilId: pupil.id }
        });
    }

@FieldResolver((type) => Address, { nullable: true })
  address(user: User): Address | undefined {
    return user.address as unknown as Address;
  }

@FieldResolver(returns => [Secret])
    @Authorized(Role.USER)
    async secrets(@Ctx() context: GraphQLContext) {
        return await getSecrets(getSessionUser(context));
    }

@FieldResolver((returns) => Comment, { nullable: true })
  async lastComment(@Root() topic: Topic) {
    return (
      topic.lastCommentId &&
      prisma.comment.findUnique({ where: { id: topic.lastCommentId } })
    )
  }

@FieldResolver(returns => Number)
    @Authorized(Role.UNAUTHENTICATED)
    @PublicCache()
    async participantsCount(@Root() subcourse: Subcourse) {
        return await prisma.subcourse_participants_pupil.count({
            where: { subcourseId: subcourse.id }
        });
    }

@FieldResolver((returns) => String)
  html(@Root() topic: Topic) {
    const html = renderMarkdown(topic.content)
    return html
  }

@FieldResolver(type => [Match])
    @Authorized(Role.ADMIN, Role.OWNER)
    @LimitEstimated(10)
    async matches(@Root() pupil: Required<Pupil>) {
        return await prisma.match.findMany({
            where: { pupilId: pupil.id }
        });
    }

@FieldResolver((returns) => String)
  html(@Root() comment: Comment) {
    const html = renderMarkdown(comment.content)
    return html
  }

@FieldResolver(type => Int)
    @Authorized(Role.ADMIN, Role.OWNER)
    gradeAsInt(@Root() pupil: Required<Pupil>) {
        return gradeAsInt(pupil.grade);
    }

@FieldResolver((returns) => Boolean)
  isAdmin(@Root() user: CurrentUser) {
    return isAdmin(user)
  }

@FieldResolver(type => Decision)
    @Authorized(Role.ADMIN, Role.OWNER)
    async canRequestMatch(@Root() pupil: Required<Pupil>) {
        return await canPupilRequestMatch(pupil);
    }

@FieldResolver(() => ProductCategory, { nullable: true })
    async [parentKey](@Root() productCategory: ProductCategory): Promise<TProductCategory | undefined | null> {
        return await this.repository.getParentCategory(productCategory);
    }

@FieldResolver(returns => [String])
    @Authorized(Role.ADMIN, Role.STUDENT)
    subjectsFormatted(@Root() certificate: ParticipationCertificate) {
        return certificate.subjects.split(",");
    }

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: Attribute, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.Attribute, entity.id, fields);
    }

@FieldResolver(returns => [MatchPoolRun])
    @Authorized(Role.ADMIN)
    async runs(@Root() matchPool: MatchPoolType) {
        return await getPoolRuns(matchPool);
    }

@FieldResolver(() => User)
  creator(@Root() post: Post, @Ctx() { userLoader }: MyContext) {
    return userLoader.load(post.creatorId);
  }

@FieldResolver(returns => [Review])
  async reviews(@Root() user: User): Promise<Review[]> {
    return reviews.filter(review => review.author.id === user.id);
  }

@FieldResolver(() => GraphQLJSONObject, { nullable: true })
    async customMeta(@Root() entity: User, @Arg("keys", () => [String]) fields: string[]): Promise<any> {
        return entityMetaRepository.getEntityMetaByKeys(EDBEntity.User, entity.id, fields);
    }