How to define a relation nested in an object in an array?

[graddaniel]

TLDR: My query doesn't recognize a field, which has been linked via @Relation, to a nested DTO stored in an array, belonging to an outer DTO.

Hi,
So far I've been successfully using various relation decorators when dealing various relation types. In worst case, when an incorrect decorator was used, the query would fail to resolve a field. Currently however I am experiencing an issue, where the field is not recognized at all.

I have a MongoDB document, which's one of the fields stores an array of objects and each of those objects references another document.

export class NestedEntity extends MongooseDocument {
  @Prop()
  someString: string;
}

@Schema()
export class Config {
  @Prop({
    type: MongooseSchema.Types.ObjectId,
    ref: 'NestedEntity',
    required: true,
  })
  nestedEntity: NestedEntity;

  @Prop()
  someString: string;
}

@Schema()
export class SomeEntity extends MongooseDocument {
  @Prop({
    type: [Config],
  })
  configs: Config[];
}

Then to retrieve these I have defined such DTOs:

@ObjectType('NestedEntity')
export class NestedEntityDTO {
    @ObjectId()
    _id: mongoose.Types.ObjectId;

    @Field(() => ID)
    id: mongoose.Types.ObjectId;

    @Field()
    someString: string;
}

@ObjectType('Config')
@Relation('nestedEntity', () => NestedEntityDTO)
export class ConfigDTO { // the nested object has _id also
    @ObjectId()
    _id: mongoose.Types.ObjectId;

    @Field(() => ID)
    id: mongoose.Types.ObjectId;

    @Field()
    someString: string;
}

@ObjectType('SomeEntity')
@QueryOptions({
    pagingStrategy: PagingStrategies.OFFSET,
    enableTotalCount: true,
})
export class SomeEntityDTO {
  @ObjectId()
  _id: mongoose.Types.ObjectId;

  @Field(() => ID)
  id: mongoose.Types.ObjectId;
  
  @Field(() => [ConfigDTO])
  configs: ConfigDTO[];
}

Even when I take a look at the generated schema, the Config looks like this (the nestedEntity field is missing):

type Config {
  id: ID!
  someString: String!
}

What's the correct way of defining the relation in such case?

[graddaniel]

I've managed to solve it by creating a separate Resolver for the nested entity and a separate Service which inherits from NoOpQueryService (to avoid typical interaction with the DB). The service then implements methods, which explicitly interact with the Model injected to the Service and the Resolver in addition to basic CRUD operations has custom fields, which resolve with the help of the Service.

Examples:
Module

@Module({
 imports: [
   NestjsQueryGraphQLModule.forFeature({
     imports: [
       NestjsQueryMongooseModule.forFeature([
         { document: SomeEntity, name: SomeEntity.name, schema: SomeEntitySchema },
       ]),
       MongooseModule.forFeature([
         { name: NestedEntity.name, schema: NestedEntitySchema },
       ]),
     ],
     dtos: [
       { DTOClass: SomeEntityDTO },
       { DTOClass: ConfigDTO }, 
     ],
     services: [
       SomeEntityService,
     ],
   }),
 ],
 providers: [
   SomeEntityResolver, SomeEntityService,
   ConfigResolver, ConfigService,
 ],
})
export class SomeModule {}

Resolver

@Resolver(() => ConfigDTO)
export class ConfigResolver extends CRUDResolver(ConfigDTO, {
 CreateDTOClass: CreateConfigDTO,
 UpdateDTOClass: UpdateConfigDTO,
}) {
 constructor(
   @Inject(ConfigService) readonly configService: configService,
 ) {
   super(NoOpQueryService.getInstance());
 }

 @ResolveField('nestedEntity', (_returns) => NestedEntityDTO)
 async template(@Parent() config: ConfigDTO) {
   return this.configService.getNestedEntityById(
     config.nestedEntity,
   );
 }
}

Service:

@QueryService(ConfigDTO)
export class ConfigService extends NoOpQueryService<ConfigDTO> {
 private readonly logger = new Logger(ConfigService.name);

 constructor(
   @InjectModel(NestedEntity.name) private readonly nestedEntityModel: Model<NestedEntity>,
 ) {
   super();
 }

 async getNestedEntityById(nestedEntityId: string) {
   return this.nestedEntityModel.findOne({ _id: nestedEntityId });
 }
}

[graddaniel]

An alternative approach is not to implement the custom Field on the Resolver, and the getter method on the Service, but extending the findRelation method on the Service, which for every relation must return a Map<DTO, RelationDTO>, but it's more complicated than the above.