@nestjs/graphql#Resolver TypeScript Examples

@Resolver(() => FormStatisticModel)
export class FormStatisticResolver {
  constructor(
    private readonly statisticService: FormStatisticService,
  ) {
  }

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

@Resolver(() => ConnectorRestApi)
export class ConnectorRestApiResolver extends BlockTypeResolver(
  ConnectorRestApi,
  'ConnectorRestApis',
  FindManyConnectorRestApiArgs,
  'createConnectorRestApi',
  CreateConnectorRestApiArgs,
  'updateConnectorRestApi',
  UpdateBlockArgs
) {
  constructor(private readonly service: ConnectorRestApiService) {
    super();
  }
}

@Resolver('User')
export class UsersResolver {
  constructor(
    private readonly usersService: UsersService,
  ) {}

  @Query('user')
  async getUser(@Args('userId', ParseUUIDPipe) userId: string) {
    return this.usersService.findById(userId);
  }

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

  @Mutation('signup')
  async signup(@Args('user') user: UserSignupDTO) {
    return this.usersService.signup(user);
  }
}

@Resolver()
export class AppResolver {
  constructor(private readonly appService: AppService) {}

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

  @Mutation('echoMessage')
  replyMessage(
    @Tracing() tracing: TracingData,
    @Args('message') message: string,
  ): Observable<string> {
    Logger.log({ echoMessage: tracing });
    return this.appService.echoMessage(message);
  }
}

@Resolver('Auth')
export class AuthResolver {

  constructor(
    private readonly authService: AuthService,
  ) {}

  @Mutation('login')
  async login(@Args('user') user: LoginDTO){
    const jwtToken = await this.authService.login(user);

    if(!jwtToken) throw new UnauthorizedException();

    return jwtToken;
  }
}

@Resolver(() => Notification)
export class NotificationResolver {
  constructor(private readonly notificationService: NotificationService) {}

  @Mutation(/* istanbul ignore next */ () => Notification)
  createNotification(@Args('input') input: CreateNotificationInput) {
    return this.notificationService.create(input);
  }

  @Mutation(/* istanbul ignore next */ () => Notification)
  updateNotification(
    @Args('id', { type: /* istanbul ignore next */ () => ID }) id: string,
    @Args('input') input: UpdateNotificationInput,
  ) {
    return this.notificationService.update({ id }, input);
  }

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

  @Query(/* istanbul ignore next */ () => [Notification])
  notificationByUserId(@Args('userId') userId: string) {
    return this.notificationService.findByUserId(userId);
  }

  @Query(/* istanbul ignore next */ () => [Notification])
  notificationByTargetId(@Args('targetId') targetId: string) {
    return this.notificationService.findByTargetId(targetId);
  }
}

@Resolver(() => User)
export class UserResolver {
  constructor(private userService: UserService) {}

  @UseGuards(AuthGuard)
  @Mutation(() => User)
  async updateUser(@Args('input') input: UpdateUserInput, @Context() context) {
    const userId = get(context, 'req.user._id');
    return this.userService.updateById({ userId, input: deepClean(input) });
  }

  @Query(() => [User])
  async users() {
    return this.userService.findAll();
  }

  @Query(() => User, { nullable: true })
  async me(@Context() context) {
    return this.userService.findOne({ _id: context.req.user });
  }

  @Query(() => User, { nullable: true })
  async user(@Args('input') input: GetUserInput) {
    return this.userService.findOne({ permalink: input.userPermalink });
  }
}

@Resolver(Ship)
export class ShipResolver extends GlobalIdFieldResolver(Ship) {
  constructor(private shipService: ShipService, private factionService: FactionService) {
    super();
  }

  @RelayMutation(() => IntroduceShipOutput, {
    name: 'introduceShip',
  })
  introduceShip(
    @InputArg(() => IntroduceShipInput) input: IntroduceShipInput,
  ): IntroduceShipOutput | null {
    const data = this.factionService.introduceShipToFaction(
      input.factionId.toString(),
      input.shipName,
    );
    if (!data) return null;

    return new IntroduceShipOutput(data);
  }
}

@Resolver(() => Cat)
export class CatResolver {
  constructor(private readonly catService: CatService) {}

  @Query(() => [Cat])
  cats() {
    return this.catService.cats();
  }

  @Query(() => Cat, { nullable: true })
  cat(@Args({ name: 'id', type: () => ID }, ParseIntPipe) id: number) {
    return this.catService.cat(id);
  }

  @ResolveLoader(() => Boolean)
  hasFur(@Parent() queries: LoaderQuery<Cat>[]) {
    return queries.map(({ obj }) => obj.lives > 1);
  }

  @Subscription(() => Cat, {
    resolve: (payload) => payload,
  })
  onCatSub(@Context('pubsub') pubSub: PubSub) {
    return toAsyncIterator(pubSub.subscribe('CAT_SUB_TOPIC'));
  }
}

@Resolver(() => PageModel)
export class PageResolver {
  constructor(
    private readonly idService: IdService,
  ) {
  }

  @ResolveField(() => [ButtonModel])
  async buttons(
    @Parent() parent: FormModel,
    @Context('cache') cache: ContextCache,
  ): Promise<ButtonModel[]> {
    if (!parent._id) {
      return []
    }

    const page = await cache.get<PageEntity>(cache.getCacheKey(PageEntity.name, parent._id))

    return page.buttons.map(button => new ButtonModel(
      this.idService.encode(button.id),
      button
    ))
  }
}

@Resolver(classRef, { isAbstract: true })
  abstract class GlobalIdFieldResolverHost {
    @GlobalIdField(globalIdFieldOptions)
    id(@Parent() parent: ResolverParent, @Info() info: ResolverInfo): ResolvedGlobalId {
      if (!parent || !parent.id) {
        throw new Error(`Cannot resolve id when 'parent' or 'parent.id' is null`);
      }
      switch (typeof parent.id) {
        case 'object':
          return parent.id;
        case 'string':
          return new ResolvedGlobalId({
            type: info.parentType.name,
            id: parent.id,
          });
        case 'number':
          return new ResolvedGlobalId({
            type: info.parentType.name,
            id: parent.id.toString(),
          });
      }
    }
  }

@Resolver(() => User)
export class UserResolver {
  @ResolveField(() => [Post])
  posts(@Parent() user: User) {
    const userPosts = posts.filter(
      (p) => p.authorId.toString() === user.id.toString(),
    );
    return userPosts;
  }
}

@Resolver()
export class FindUsersGraphqlResolver {
  constructor(private readonly userRepo: UserRepository) {}

  @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));
  }
}

@Resolver()
export class HelloResolver {
  static COUNTER = 0;
  constructor(
    private readonly helloService: HelloService,
    private readonly usersService: UsersService,
  ) {
    HelloResolver.COUNTER++;
  }

  @Query()
  @UseGuards(Guard)
  @UseInterceptors(Interceptor)
  getCats(): any[] {
    return this.helloService.getCats();
  }
}

@Resolver(() => Webhook)
export class WebhookResolver {
  constructor(private readonly webhookService: WebhookService) {}

  /**
   * Queries
   */
  @Query(() => [Webhook], { nullable: true })
  async webhooks(): Promise<IWebhook[]> {
    return this.webhookService.findAll();
  }

  /**
   * Mutations
   */
  @Mutation(() => Webhook)
  async createWebhook(@Args('webhook') webhook: WebhookInputType): Promise<IWebhook> {
    return this.webhookService.create(webhook);
  }

  @Mutation(() => Boolean)
  async deleteWebhook(@Args('id') id: string): Promise<boolean> {
    return this.webhookService.delete(id);
  }
}

@Resolver(() => Animal)
export class AnimalResolver {
  constructor(
    private readonly catService: CatService,
    private readonly dogService: DogService,
  ) {}

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

  @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()];
    }
  }

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

  @ResolveLoader(() => String)
  aField(@Parent() queries: LoaderQuery<Animal>[]) {
    return queries.map(({ obj }) => 'lorem');
  }
}

/**
 * AuthResolver execute auth.graphql query
 */
@Resolver('Auth')
export class AuthResolver {
  /**
   * Inject into AuthResolver: AuthService
   *
   * @param authService validate user and return SignAuthResponse
   */
  constructor(private readonly authService: AuthService) {}

  /**
   * 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);
  }

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

@Resolver(UserInfo)
export class AuthResolver {
  constructor(private readonly authService: AuthService) {}
  @Mutation(() => UserInfo)
  async login(@Args() args: LoginArgs): Promise<UserInfo> {
    return this.authService.login(args.credentials);
  }

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

@Resolver(() => Post)
export class PostResolver {
  @Query(() => [Post])
  posts() {
    return posts;
  }

  @ResolveField(() => User)
  author(@Parent() post: Post) {
    return { __typename: 'User', id: post.authorId };
  }
}

@Resolver(() => AppSettings)
@UseGuards(GqlAuthGuard)
export class AppSettingsResolver {
  constructor(private readonly service: AppSettingsService) {}

  @Mutation(() => AppSettings, {
    nullable: true,
    description: undefined
  })
  @AuthorizeContext(AuthorizableResourceParameter.AppId, 'where.id')
  async updateAppSettings(
    @Args() args: UpdateAppSettingsArgs,
    @UserEntity() user: User
  ): Promise<AppSettings> {
    return this.service.updateAppSettings(args, user);
  }

  @Query(() => AppSettings, {
    nullable: false
  })
  @AuthorizeContext(AuthorizableResourceParameter.AppId, 'where.id')
  async appSettings(
    @Args() args: FindOneArgs,
    @UserEntity() user: User
  ): Promise<AppSettings> {
    return this.service.getAppSettingsBlock(args, user);
  }
}

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

  @ResolveLoader(() => String)
  uniqueId(@Parent() queries: LoaderQuery<Person>[]) {
    return queries.map(({ obj }) => `${obj.name}__${obj.id}`);
  }
}

/** @todo add FieldResolver to return the settings, inputs, and outputs from the current version */

@Resolver(() => Block)
@UseFilters(GqlResolverExceptionsFilter)
@UseGuards(GqlAuthGuard)
export class BlockResolver {
  constructor(
    private readonly blockService: BlockService,
    private readonly userService: UserService
  ) {}

  @Query(() => [Block], {
    nullable: false,
    description: undefined
  })
  @AuthorizeContext(AuthorizableResourceParameter.AppId, 'where.app.id')
  async blocks(@Args() args: FindManyBlockArgs): Promise<Block[]> {
    return this.blockService.findMany(args);
  }

  @Query(() => Block, {
    nullable: false,
    description: undefined
  })
  @AuthorizeContext(AuthorizableResourceParameter.BlockId, 'where.id')
  async block(@Args() args: FindOneArgs): Promise<Block> {
    return this.blockService.block(args);
  }

  //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(() => [BlockVersion])
  async versions(
    @Parent() entity: Block,
    @Args() args: FindManyBlockVersionArgs
  ): Promise<BlockVersion[]> {
    return this.blockService.getVersions({
      ...args,
      where: {
        ...args.where,
        block: { id: entity.id }
      }
    });
  }

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

@Resolver()
export class SearchResolver {
  @Query(() => [SearchUnion])
  search() {
    return [...users, ...posts];
  }
}

@Resolver(Type)
export class TypeResolver extends GlobalIdFieldResolver(Type) {}

@Resolver(() => User)
export class UserResolver {
  @Query(() => [User])
  users() {
    return users;
  }

  @ResolveReferenceLoader()
  resolveReference(refs: LoaderQuery<Reference<'User', 'id'>>[]) {
    const refIds = refs.map(({ obj }) => obj.id.toString());

    return users.filter((u) => refIds.includes(u.id.toString()));
  }

  @Mutation(() => User)
  createUser(
    @Args('input') data: CreateUserInput,
    @Context('pubsub') pubSub: PubSub,
  ) {
    const user = {
      ...data,
      id: nextId,
    };
    users.push(user);
    pubSub.publish({
      topic: 'createUser',
      payload: { user },
    });

    nextId++;

    return user;
  }

  @Subscription(() => User, {
    resolve: (payload) => payload.user,
  })
  onCreateUser(@Context('pubsub') pubSub: PubSub) {
    return toAsyncIterator(pubSub.subscribe('createUser'));
  }
}

@Resolver(() => SubmissionProgressModel)
export class SubmissionProgressResolver {

}

export function GlobalIdFieldResolver<T>(
  classRef: Type<T>,
  idFieldOptions?: GlobalIdFieldOptions,
): Type<GlobalIdFieldResolver> {
  const globalIdFieldOptions = idFieldOptions || {};

  @Resolver(classRef, { isAbstract: true })
  abstract class GlobalIdFieldResolverHost {
    @GlobalIdField(globalIdFieldOptions)
    id(@Parent() parent: ResolverParent, @Info() info: ResolverInfo): ResolvedGlobalId {
      if (!parent || !parent.id) {
        throw new Error(`Cannot resolve id when 'parent' or 'parent.id' is null`);
      }
      switch (typeof parent.id) {
        case 'object':
          return parent.id;
        case 'string':
          return new ResolvedGlobalId({
            type: info.parentType.name,
            id: parent.id,
          });
        case 'number':
          return new ResolvedGlobalId({
            type: info.parentType.name,
            id: parent.id.toString(),
          });
      }
    }
  }
  return GlobalIdFieldResolverHost as Type<GlobalIdFieldResolver>;
}

@Resolver(() => Tag)
export class TagResolver {
  constructor(private readonly tagService: TagService, private readonly tagGroupService: TagGroupService) {}

  /**
   * Queries
   */

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

  @Query(() => Tag, { nullable: true })
  async tagById(@Args('id') id: string): Promise<ITag> {
    return this.tagService.findOne(id);
  }

  /**
   * Mutations
   */

  @Mutation(() => Tag)
  async createTag(@Args('tag') tag: TagInputType): Promise<ITag> {
    return this.tagService.create(tag);
  }

  @Mutation(() => Tag)
  async updateTag(@Args('id') id: string, @Args('tag') tag: TagInputType): Promise<ITag> {
    return this.tagService.update(id, tag);
  }

  @Mutation(() => Tag)
  async replaceTag(@Args('id') id: string, @Args('tag') tag: TagInputType): Promise<ITag> {
    return this.tagService.replace(id, tag);
  }

  @Mutation(() => Boolean)
  async deleteTag(@Args('id') id: string): Promise<boolean> {
    return this.tagService.delete(id);
  }

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

@Resolver(FormFieldModel)
export class FormFieldResolver {
  constructor(
    private readonly idService: IdService,
  ) {
  }

  @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(() => [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(() => FormFieldRatingModel, { nullable: true })
  async rating(
    @Parent() parent: FormFieldModel,
    @Context('cache') cache: ContextCache,
  ): Promise<FormFieldRatingModel> {
    const field = await cache.get<FormFieldEntity>(cache.getCacheKey(
      FormFieldEntity.name,
      parent._id
    ))

    if (!field.rating) {
      return null
    }

    return new FormFieldRatingModel(field.rating)
  }
}