How to use existing Resolvers as FieldResolvers for circular & nested Refs

[cnebs]

Question: If I have two typegoose/type-graphql models, each which reference each other as refs in some of their fields, how can I use the Resolver of each Model as the FieldResolver for each respective field that references the other?

To explain with context...
What if I have two mongoose models: User and ProgramTemplate.

Model User:

@ObjectType()
@modelOptions({
  schemaOptions: {
    timestamps: true 
  }
})
export class User {
  @Field() 
  readonly _id!: string

  @Field()
  readonly token!: string

  @Field()
  @prop({ required: true })
  username!: string
 
  @Field()
  @IsEmail()
  @prop({ required: true })
  email!: string

  @Field()
  @prop({ required: true })
  password!: string

  @Field(_type => [LiftMax])
  @prop({ 
    required: true, 
    type: () => [LiftMax] 
  })
  liftMaxes!: LiftMax[]

  //! FIRST CIRCULAR REFERENCE
  @Field(_type => [ProgramTemplate])
  @prop({ 
    required: false, 
    ref: () => ProgramTemplate, 
    type: () => [String],
  })
  programTemplates!: Ref<ProgramTemplate, string>[]
}

As you can see, User has a field programTemplates with an array of refs to ProgramTemplate.

Model ProgramTemplate:

@ObjectType()
@modelOptions({
  schemaOptions: {
    timestamps: true
  }
})

export class ProgramTemplate {
  //! SECOND CIRCULAR REFERENCE
  @Field(type => User) 
  @prop({ 
    required: false, 
    ref:() => User, 
    type: () => String,
   })
  public author!: Ref<User>

  @Field(type => User)
  @prop({
    required: false,
    ref: () => User,
    type: () => String
  })
  public owner!: Ref<User>

  @Field() 
  @prop({ required: true })
  name!: string;

  @Field() 
  @prop({ required: true })
  description!: string;

  @Field(type => [Lift]) 
  @prop({ 
    required: true, 
    ref: Lift, 
    type: () => [String] 
  })
  public lifts!: Ref<Lift, string>[];
};

Now, ProgramTemplate has a fields owner and author with refs to User. There is also a lifts property which is an array of refs to another, somewhat unrelated model. But useful in that it's yet another ref that needs to be resolved.

I have a ProgramTemplate resolver with field resolvers that resolve most fields with refs to other objects as values.

A sample of ProgramTemplateResolver:

@Service()
@Resolver(of => ProgramTemplate)
export class ProgramTemplateResolver {
  constructor(
    private readonly programTemplateService: ProgramTemplateService,
    private readonly userRepo: UserRepository,
    private readonly liftRepo: LiftRepository
  ) { }

  @Query(of => ProgramTemplatesResponse)
  async defaultProgramTemplates(
    @Ctx() context: MyContext,
    @Arg("type") type: ProgramTemplateType
  ): Promise<typeof ProgramTemplatesResponse> {
    // ...
  }

  // This will not resolve any of the fields in User which are refs (including User.programTemplates)
  @FieldResolver(of => User)
  async owner(@Root() template: DocumentType<ProgramTemplate>): Promise<User> {
    const user = await this.userRepo.getUser({_id: template.owner as string})
    return user!
  }

  @FieldResolver(of => [Lift])
  async lifts(@Root() template: DocumentType<ProgramTemplate>): Promise<Lift[]> {
    const liftIds = template.lifts
    const lifts = this.liftRepo.getLiftsByIds(liftIds as string[])
    return lifts!
  }
}

The @FieldResolver(of => User) will not resolve any fields (of the resolved User) with ObjectId (ref) values, as is expected but not desired; I'd have to manually add more nested resolvers for those, effectively re-coding what has already been done in the UserResolver.

Similarly, If I want to resolve the programTemplates field on User, do I have to re-write all the field resolvers that exist on ProgramTemplateResolver just to get their nested ref values? i.e. any of the nested refs within the resolved owner field (a User), such as User.owner.programTemplates (which, as you can see, is a schema with potentially infinite nesting)

Here is the UserResolver sample:

@Service()
@Resolver(of => User)
export class UserResolver {
  constructor(
    private readonly userService: UserService, 
    private readonly programTemplateRepo: ProgramTemplateRepository
  ) {}

  @UseMiddleware(authUser)
  @Query(() => UserResponse)
  async me(@Ctx() context: MyContext): Promise<typeof UserResponse> {
    // ...
  }
  
  @Query(returns => UserResponse, { description: "Returns the a user" } )
  async userById(
    @Ctx() context: MyContext, 
    @Arg("id") id: string
  ): Promise<typeof UserResponse> {
   // ...
  }

  @UseMiddleware(validateInput(RegisterUserInput))
  @Mutation(returns => UserResponse)
  async registerUser(
    @Arg("registerUserParams") registerUserParams: RegisterUserInput,
    @Ctx() context: MyContext
  ): Promise<typeof UserResponse> {
    // ...
  }

  @UseMiddleware(validateInput(LoginUserInput))
  @Mutation(returns => UserResponse)
  async loginUser (
    @Arg("loginUserParams") loginUserParams: LoginUserInput, 
    @Ctx() context: MyContext
  ): Promise<typeof UserResponse> {
   // ...
  }

  // This will not resolve any of the fields in ProgramTemplate which are refs (including programTemplates)
  @FieldResolver(of => [ProgramTemplate])
  async programTemplates(@Root() user: DocumentType<User>): Promise<ProgramTemplate[]> {
    const programTemplateIds = user.programTemplates
    const templates = await this.programTemplateRepo.getProgramTemplatesByIds(programTemplateIds as string[])
    console.log(templates) // None of the ProgramTemplates fields are resolved
    return templates
  }
}

As you can see, @FieldResolver(of => [ProgramTemplate]) will not resolve any of the refs that exist on each ProgramTemplate.

So how can I use the existing Resolvers that I wrote for each Model as a FieldResolver for these circular refs of User and ProgramTemplate?

Or, what is the best way to handle this kind of situation? Below are two use-cases from the UI that highlight why I'm choosing to use a sort of circular schema.

Use cases in UI (Apollo Client):
Sometimes I want to query (from User) details from a ProgramTemplate that exists on the user's array of programTemplates.

query MyProgramTemplates {
    User {
      ... on Error {
        message
      }
      ... on User {
        programTemplates {
          name
          description
          type
          cycleLength
          daysPerWeek
          lifts {
            name
          }
        }
      }
    }
  }

Sometimes I want to query (from ProgramTemplate) the details of User that exist on the template's owner field.

query DefaultRoutineSummaries($type: String!) {
  defaultProgramTemplates(type: $type) {
    ... on Error {
      message
    }
    ... on ProgramTemplates {
      programTemplates {
        name
        owner {
          username
        }
        description
        cycleLength
        daysPerWeek
        lifts {
          name
        }
      }
    }
  }
}

[cnebs]

Fixed by using repositories to prepopulate dependent data

[enheit]

@cnebs Could you please explain how you resolved this issue?

I also have a problem where one model refer another model and vice versa. Is it possible to re-use existing resolvers? Or It should be done using repositories?

[cnebs]

@enheit
I think there must have been an error in my code somewhere. As long as, for each resolver the proper field resolvers return the expected data, I'm finding the circular references to resolvers are populated. Maybe if you can show some example code or provide a high level description I can see if it's a similar situation to mine...