How to get this working with Nestjs

[SamCullin]

Spent some time trying to get this working with nestjs graphql. So I thought Id just note down my finding for anyone else looking to use this with nestjs.

You will need to create a custom paramer decorator

export const GqlContext = createParamDecorator(
    (data: unknown, context: ExecutionContext) => {
        const ctx = GqlExecutionContext.create(context);
        return ctx
    },
);

This will give you access to the Gql Execution Context which you will need to run the mapper

@Resolver(of => Entity)
export class EntityQueries {

    constructor(
        @InjectRepository(Entity)
        private readonly entityRepository: Repository<Entity>,
        private readonly relationMapper: RelationMapper
    ) { }

    @Query(returns => [Entity])
    async entities(
        @Args() query: Query,
        @GqlContext() context: GqlExecutionContext // Note this line is where we use the param decorator
    ): Promise<Entity[]> {
        query.relations = Array.from(this.relationMapper.buildRelationListForQuery(Entity, context.getInfo()))
        return this.entityRepository.find(query)
    }

}

Note: I have provided the Relation Mapper to the module already.

@Global()
@Module({
    providers: [
        {
            provide: RelationMapper,
            useFactory: (connection: Connection) => {
                return new RelationMapper(connection)
            },
            inject: [
                Connection
            ]
        }
    ],
    exports: [
        RelationMapper
    ],
})
export class GraphQlTypeORMJoinerModule { }

Hopefully, this can save some other people some time. And thanks madscience for this package.

[sgarner]

It's actually slightly easier than that! You don't need to create your own decorator: @Context() and more specifically @Info() are already provided by nestjs-graphql.

So the resolver method from your example should look something like this:

@Resolver(of => Entity)
export class EntityQueries {

    constructor(
        @InjectRepository(Entity)
        private readonly entityRepository: Repository<Entity>,
        private readonly relationMapper: RelationMapper
    ) { }

    @Query(returns => [Entity])
    async entities(
        @Args() query: Query,
        @Info() info: GraphQLResolveInfo
    ): Promise<Entity[]> {
        query.relations = Array.from(this.relationMapper.buildRelationListForQuery(Entity, info))
        return this.entityRepository.find(query)
    }

}

[yf-hk]

Hi, thanks for the anwer, but how does Nest.js find relationMapper? Is there a Nest.js module or service?

[sgarner]

There is no module for Nest.js but you can make your own provider for RelationMapper quite simply, like in @SamCullin's example above:

@Module({
    providers: [
        {
            provide: RelationMapper,
            useFactory: (connection: Connection) => {
                return new RelationMapper(connection)
            },
            inject: [
                Connection
            ]
        }
    ],
    exports: [
        RelationMapper
    ],
})

This will allow RelationMapper to be injected by name.

[yf-hk]

Thanks very much!
For someone who is using TypeOrm 0.3+, here is my modified implementation of it:

@Module({
  providers: [
    {
      provide: GraphRelationBuilder,
      useFactory: (dataSource: DataSource) => {
        return new GraphRelationBuilder(dataSource);
      },
      inject: [DataSource],
    },
  ],
})

import { Entity} from '~/entities';

import { Resolver, Query, Info } from '@nestjs/graphql';

import { GraphRelationBuilder } from 'typeorm-relations-graphql';
import { GraphQLResolveInfo } from 'graphql';

@Resolver()
export class EntityResolver {
  constructor(private readonly relationBuilder: GraphRelationBuilder) {}

  @Query(() => [Entity])
  async entities(@Info() info: GraphQLResolveInfo) {
    const relations = this.relationBuilder
      .buildForQuery(Entity, info)
      .toFindOptionsRelations();
    return Entity.find({ relations });
  }
}

[sgarner]

Thanks very much! For someone who is using TypeOrm 0.3+, here is my modified implementation of it:

Oops, yes the earlier example is for version 1.x of this library (when it was called typeorm-graphql-joiner) and TypeORM version v0.2.x.

For TypeORM v0.3.x and version 2.x of typeorm-relations-graphql, what you have done is perfect. 👌

Thanks!