Getting a Relation using a microservice client

[Flusinerd]

Hello, I want to be able to fetch the owner of my entites using a microservice client that talks to my login microservice.

All entites extend from the base class Resource:

@InterfaceType()
export abstract class Resource {
  @Column('uuid')
  @Field(() => ID)
  @IsUUID()
  ownerId: string;

  @Field(() => User)
  owner: User;

User can only be retrieved via a ClientProxy:

return loginService.send('get_user', {
            secret: this._configService.get('CLIENT_SECRET'),
            userId: resource.ownerId,
          });

This worked with the "vanilla" nestjs ResolveField decorator:

 @ResolveField(() => User)
 async owner(@Parent() project: Project) {
   console.log('Getting user', project.ownerId);
   return await this.loginService.send('get_user', {
     secret: this._configService.get('CLIENT_SECRET'),
     userId: project.ownerId,
   });
 }

How would I be able to achieve something similar with this package?
Ideally it is attached to the Resource Entity / DTO.
It can be readonly.

[smolinari]

Are you using any of the three database connectivity methods Nestjs-Query offers above and beyond microservices? Or, is all data coming from microservices?

Scott

[Flusinerd]

Hello, all but the user/owner  is coming from a mssql database using typeOrm.

…

On 7. Mar 2021, 08:37 +0100, Scott ***@***.***>, wrote: Are you using any of the three databases Nestjs-Query supports? Above and beyond microservices? Or, is all data coming from microservices? Scott — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub, or unsubscribe.

[smolinari]

Hmmm. Interesting. I'm not sure either how to get the async method to work. Maybe Doug can chime in.

Scott

[Flusinerd]

Okay after a lot more trying I managed to get this working using a AssemblerQueryService:

import {
  AssemblerQueryService,
  InjectQueryService,
  Query,
  QueryService,
} from '@nestjs-query/core';
import { NotFoundException } from '@nestjs/common';
import { ProjectAssembler } from 'src/shared_internal/owner.assembler';
import { Project } from '../entities/project.entity';

export class ProjectAssemblerService extends AssemblerQueryService<
  Project,
  Project
> {
  constructor(
    readonly assembler: ProjectAssembler,
    @InjectQueryService(Project) readonly queryService: QueryService<Project>
  ) {
    super(assembler, queryService);
    console.log('Assembler ctor');
  }

  async findById(id) {
    console.log('Finding one', id);
    const dto = this.assembler.convertAsyncToDTO(
      this.queryService.findById(id)
    );
    return dto;
  }

  async getById(id) {
    const project = await this.findById(id);
    if (!project) {
      throw new NotFoundException();
    }
    return project;
  }

  query(query: Query<Project>) {
    return this.assembler.convertAsyncToDTOs(this.queryService.query(query));
  }
}

Wich intern then uses the previously build Assembler

import { Assembler, ClassTransformerAssembler } from '@nestjs-query/core';
import { Inject } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { ClientProxy } from '@nestjs/microservices';
import { Project } from 'src/projects/entities/project.entity';
import { User } from './user.entity';

@Assembler(Project, Project)
export class ProjectAssembler extends ClassTransformerAssembler<
  Project,
  Project
> {
  constructor(
    @Inject('LOGIN_SERVICE') private readonly _loginService: ClientProxy,
    private readonly _config: ConfigService
  ) {
    super();
  }

  async getUser(userId: string): Promise<User> {
    return await this._loginService
      .send('get_user', {
        secret: this._config.get('CLIENT_SECRET'),
        userId,
      })
      .toPromise();
  }

  async convertAsyncToDTO(entity: Promise<Project>) {
    const dto = super.convertToDTO(await entity);
    dto.owner = await this.getUser(dto.ownerId);
    return dto;
  }

  convertToDTO(entity: Project) {
    const dto = super.convertToDTO(entity);
    dto.owner = new User();
    dto.owner.userId = entity.ownerId;
    dto.owner.firstName = 'Sync';
    return dto;
  }

  async convertAsyncToDTOs(promise: Promise<Project[]>) {
    const entities = await promise;
    return Promise.all(
      entities.map(async entity => {
        entity.owner = await this.getUser(entity.ownerId);
        return entity;
      })
    );
  }
}

[Flusinerd]

I am still curious if there is a better way of doing this

[Flusinerd]

I found another solution:
I am now using a RelationQueryService and a self written UserQueryService.

[smolinari]

I'm sure there are many paths that lead to Rome. I'd also be interested in the best practice, if there is one.

Scott