Prisma / Graphql resolver

Good morning all, I m currently back in the famous world of web development and I have in mind to develop a tool by using Nest/Prisma/Graphl. However, I'm struggling a little bit on key element like the following one.

Basically, I can see that, by using the "include" function in Prisma (module.service.ts), I'm getting subModules list: this is the expected behavior.

However, on Graphl side, to cover field resolver (module.resolver.ts), I can see that the same request is executing again to cover SubModules field.....

What am I missing?????

See below the code:

module.module.ts

import { Field, ID, ObjectType } from '@nestjs/graphql'
import { SubModule } from './submodule.model'

@ObjectType()
export class Module {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  @Field((type) => ID)
  id: number
  name: string
  description: string
  icon: string
  active: boolean
  position: number
  subModules?: SubModule[]
}

submodule.model.ts

import { Field, ObjectType, ID } from '@nestjs/graphql';
import { Module } from './module.model';

@ObjectType()
export class SubModule {
  @Field((type) => ID)
  id: number;
  name: string;
  description: string;
  icon: string;
  active: boolean;
  position: number;
  module: Module;
}

module.resolver.ts

import {
  Resolver,
  Query,
  ResolveField,
  Parent,
  Args,
  InputType,
} from '@nestjs/graphql'
import { Module } from 'src/models/module.model'
import { ModuleService } from './module.service'
import { SubModuleService } from './sub-module.service'

@InputType()
class FilterModules {
  name?: string
  description?: string
  icon?: string
  active?: boolean
}

// eslint-disable-next-line @typescript-eslint/no-unused-vars
@Resolver((of) => Module)
export class ModuleResolver {
  constructor(
    private moduleService: ModuleService,
    private subModuleService: SubModuleService,
  ) {}

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  @Query((returns) => Module)
  async module(@Args('ModuleId') id: number) {
    return this.moduleService.module(id)
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  @Query((returns) => [Module], { nullable: true })
  async modules(
    @Args({ name: 'skip', defaultValue: 0, nullable: true }) skip: number,
    @Args({ name: 'filterModules', defaultValue: '', nullable: true })
    filterModules: FilterModules,
  ) {
    return this.moduleService.modules({
      skip,
      where: {
        name: {
          contains: filterModules.name,
        },
      },
    })
  }

  @ResolveField()
  async subModules(@Parent() module: Module) {
    const { id } = module
    return this.subModuleService.subModules({ where: { moduleId: id } })
  }
}

module.service.ts

import { Injectable } from '@nestjs/common'
import { PrismaService } from 'src/prisma.service'
import { Prisma, Module } from '@prisma/client'

@Injectable()
export class ModuleService {
  constructor(private prisma: PrismaService) {
    prisma.$on<any>('query', (event: Prisma.QueryEvent) => {
      console.log('Query: ' + event.query)
      console.log('Params' + event.params)
      console.log('Duration: ' + event.duration + 'ms')
    })
  }

  async module(id: number): Promise<Module | null> {
    return this.prisma.module.findUnique({
      where: {
        id: id || undefined,
      },
    })
  }

  async modules(params: {
    skip?: number
    take?: number
    cursor?: Prisma.ModuleWhereUniqueInput
    where?: Prisma.ModuleWhereInput
    orderBy?: Prisma.ModuleOrderByWithRelationInput
  }): Promise<Module[]> {
    const { skip, take, cursor, where, orderBy } = params
    return this.prisma.module.findMany({
      skip,
      take,
      cursor,
      where,
      orderBy,
    })
  }

  async updateModule(params: {
    where: Prisma.ModuleWhereUniqueInput
    data: Prisma.ModuleUpdateInput
  }): Promise<Module> {
    const { where, data } = params
    return this.prisma.module.update({
      data,
      where,
    })
  }
}

Thanks in advance for your help