NestJs no puede resolver las dependencias de servicio en una dependencia circular.

Tengo un problema de dependencia circular en mi proyecto. Desafortunadamente, no puedo resolverlo con forwardRef.

La siguiente estructura:

OrderModule

• OrderService
  • Tengo las siguientes dependencias en OrderService
  • PriceService
  • CustomerService
  • SalePriceService
  • …

PriceModule

• PriceService
  • Tengo las siguientes dependencias en PriceService
  • OrderService
  • ProductService
  • …

He intentado todas las opciones de la Documentación Oficial.

¿Qué hay que tener en cuenta si hay más dependencias en un servicio?

Muchas gracias. Saludos cordiales.

Actualización:

order.module.ts

@Module({
  imports: [
    CustomerModule,
    ProductModule,
    MongooseModule.forFeature([{ name: 'Order', schema: OrderSchema }]),
    forwardRef(() => PriceModule),
  ],
  controllers: [OrderController],
  providers: [OrderService],
  exports: [OrderService],
})
export class OrderModule {}

order.service.ts

@Injectable()
export class OrderService extends GenericCrudService<orderdocument> {
  constructor(
    @InjectModel(Order.name) readonly order: Model<orderdocument>,
    private readonly productService: ProductService,
    @Inject(forwardRef(() => PriceService))
    private readonly priceService: PriceService,
  ) {
    super(order);
  }
}

price.module.ts

@Module({
  imports: [
    CustomerModule,
    SalePriceModule,
    MongooseModule.forFeature([{ name: 'Price', schema: PriceSchema }]),
    forwardRef(() => OrderModule),
  ],
  controllers: [],
  providers: [PriceService],
  exports: [PriceService],
})
export class PriceModule {}

price.service.ts

@Injectable()
export class PriceService extends GenericCrudService<pricedocument> {
  constructor(
    @InjectModel(Price.name) readonly price: Model<pricedocument>,
    private readonly customerService: CustomerService,
    private readonly salePriceService: SalePriceService,
    @Inject(forwardRef(() => OrderService))
    private readonly orderService: OrderService,
  ) {
    super(price);
  }
}

product.module.ts

@Module({
  imports: [
    PriceModule,
    MongooseModule.forFeature([{ name: 'Product', schema: ProductSchema }]),
  ],
  controllers: [ProductController],
  providers: [ProductService],
  exports: [ProductService],
})
export class ProductModule {}

product.service.ts

@Injectable()
export class ProductService extends GenericCrudService<productdocument> {
  constructor(
    @InjectModel(Product.name) readonly product: Model<productdocument>,
  ) {
    super(product);
  }
}

El error que estoy obteniendo es:

“The module at index 1 of the OrderModule “imports” array is undefined.

Potential causes:
– A circular dependency between modules. Use forwardRef() to avoid it.Read more: https://docs.nestjs.com/fundamentals/circular-dependency
– The module at index 1 is of type “undefined”. Check your import statements and the type of the module.

Scope [AppModule -> ProductModule -> PriceModule]
Error: Nest cannot create the OrderModule instance.
The module at index 1 of the OrderModule “imports” array is undefined.

Potential causes:
– A circular dependency between modules. Use forwardRef() to avoid it. Read more: https://docs.nestjs.com/fundamentals/circular-dependency
– The module at index 1 is of type “undefined”. Check your import statements and the type of the module.

Scope [AppModule -> ProductModule -> PriceModule]”