NestJS 无法解析依赖

Question

我正在尝试将 servicerequestservice 添加到 ordersservice 中

我不断收到此错误。 est 无法解析 ServiceRequestsService 的依赖关系（ServiceRequestRepository、[object Object]、CounterService、?、+）。请确保索引 [3] 处的参数依赖项在 ServiceRequestsModule 上下文中可用。

我尝试像文档一样转发彼此的依赖关系，但这似乎也没有帮助。

服务请求.module.ts

import { ServiceRequestsService } from './service-requests.service';
import { ServiceRequestsController } from './service-requests.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ServiceRequest } from './entities/service-request.entity';
import { OrdersModule } from 'src/orders/orders.module';
import { ProductsModule } from 'src/products/products.module';
import { OrderItemsModule } from 'src/order-items/order-items.module';

@Module({
  imports: [TypeOrmModule.forFeature([ServiceRequest]), forwardRef(() => OrdersModule), ProductsModule, OrderItemsModule,],
  controllers: [ServiceRequestsController],
  providers: [ServiceRequestsService]
})
export class ServiceRequestsModule {}

orders.module.ts

import { forwardRef, Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { OrdersService } from './orders.service';
import { OrdersController } from './orders.controller';
import { Order } from './order.entity';
import { OrderItemsModule } from 'src/order-items/order-items.module';
import { ProductsModule } from 'src/products/products.module';
import { CommentsModule } from 'src/comments/comment.module';
import { RetailersModule } from 'src/retailers/retailers.module';
import { PurchasesModule } from 'src/purchases/purchases.module';
import { DeliveriesModule } from 'src/deliveries/deliveries.module';
import { ServiceRequestsModule } from 'src/service-requests/service-requests.module';


@Module({
  imports: [TypeOrmModule.forFeature([Order]), forwardRef(() => OrderItemsModule), forwardRef(() => ServiceRequestsModule), ProductsModule, CommentsModule, RetailersModule, PurchasesModule, DeliveriesModule],
  providers: [OrdersService],
  controllers: [OrdersController],
  exports: [OrdersService]
})
export class OrdersModule {}

服务请求.service.ts

import { InjectRepository } from '@nestjs/typeorm';
import { CounterService } from 'src/counter/counter.service';
import { OrderItemsService } from 'src/order-items/order-items.service';
import { Order } from 'src/orders/order.entity';
import { OrdersService } from 'src/orders/orders.service';
import { Product } from 'src/products/product.entity';
import { ProductsService } from 'src/products/products.service';
import { PurchasesService } from 'src/purchases/purchases.service';
import { Repository } from 'typeorm';
import { CreateServiceRequestDto } from './dto/create-service-request.dto';
import { UpdateServiceRequestDto } from './dto/update-service-request.dto';
import { ServiceRequest } from './entities/service-request.entity';
import {format} from "date-fns";

@Injectable()
export class ServiceRequestsService {
  constructor(
    @InjectRepository(ServiceRequest)
    private repo: Repository<ServiceRequest>,
    
    @Inject(forwardRef(() => OrdersService))
    private readonly orders: OrdersService,
    private readonly counter: CounterService,
    private readonly purchases: PurchasesService,
    private readonly orderItems: OrderItemsService,

  ) {}

order.service.ts

import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { FindConditions, getMongoRepository, MongoRepository, Repository } from 'typeorm';
import { Order } from './order.entity';
import { isValidObjectId } from 'mongoose';
import { OrderItemsService } from 'src/order-items/order-items.service';
import { DeliveriesService } from 'src/deliveries/deliveries.service';
import { CounterService } from 'src/counter/counter.service';
import { ObjectId } from 'mongodb';
import {format, parseISO, toDate} from 'date-fns';
import { formatAddress } from 'src/addresses/address.entity';
import { PurchasesService } from 'src/purchases/purchases.service';
import { ActivitiesService } from 'src/activities/activities.service';
import { CommentsService } from 'src/comments/comment.service';
import { ServiceRequestsService } from 'src/service-requests/service-requests.service';


// let lastSku = 0;

@Injectable()
export class OrdersService {
  constructor(
    
    @InjectRepository(Order)
    private repository: Repository<Order>,

    @InjectRepository(Order)
    private mongoRepository: MongoRepository<Order>,
    @Inject(forwardRef(() => OrderItemsService))
    private readonly orderItems: OrderItemsService,

    @Inject(forwardRef(() => PurchasesService))
    private readonly purchases: PurchasesService,
    private readonly deliveries: DeliveriesService,
    private readonly counter: CounterService,
    @Inject(forwardRef(() => ServiceRequestsService))
    private readonly service_request: ServiceRequestsService,
    private readonly comments: CommentsService,
    private readonly activities: ActivitiesService,
  ) {
  }

purchases.module.ts

import { forwardRef, Global, Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { PurchasesService } from './purchases.service';
import { PurchasesController } from './purchases.controller';
import { Purchase } from './purchase.entity';
import { OrderItemsModule } from 'src/order-items/order-items.module';
import { ForecastModule } from 'src/forecast/forecast.module';
import { ProductsModule } from '../products/products.module';

@Global()
@Module({
  imports: [TypeOrmModule.forFeature([Purchase]), forwardRef(() => OrderItemsModule), ForecastModule, ProductsModule],
  providers: [PurchasesService],
  controllers: [PurchasesController],
  exports: [PurchasesService]
})
export class PurchasesModule {}

Purchases.service.ts

import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { getMongoRepository, IsNull, MongoRepository, Not, Repository } from 'typeorm';
import { Purchase, PurchaseItem } from './purchase.entity';
import { isValidObjectId } from 'mongoose';
import { OrderItem } from 'src/order-items/order-item.entity';

import { OrderItemsService } from 'src/order-items/order-items.service';
import { ForecastService } from 'src/forecast/forecast.service';
import { getDate, getWeek, toDate , format} from 'date-fns';
import {CounterService} from "../counter/counter.service";
import { ProductsService } from 'src/products/products.service';
//import { ProductsService } from '../products/products.service';

@Injectable()
export class PurchasesService {
  constructor(
    @InjectRepository(Purchase)
    private repository: Repository<Purchase>,
    private orderItems: OrderItemsService,
    //private productsService: ProductsService,
    private forecast: ForecastService,
    private readonly counter: CounterService,
    private readonly products: ProductsService,
  ) {}```

Answer 1

从错误中可以看出，ServiceRequestService 和 PurchasesService 之间存在循环依赖关系（或至少是循环文件引用）。 Nest 无法解析 PurchasesService 的名称，因此您可能需要 forwardRef 它，就像您已经为 OrderService 所做的那样

---

编辑：

在看到PurchasesService 的结构之后，似乎这是因为确实存在循环引用，但不像您通常看到的那样。所以ServiceRequestService 导入OrdersService 和OrdersService 导入ServiceRequestService。这种循环依赖已经被处理了。现在，ServiceRequestService（SRS）也导入了PurchasesService，但PurchasesService导入了OrdersService，后者导入了SRS，形成了另一个循环依赖。为了解决这个问题，PurchasesService 应该 forwardRef OrdersService 和 OrdersService 应该 forwardRef PurchasesService 和 SRS 应该 forwardRef OrdersService 和 @98765434。这应该小心，否则cannot resolve dependency 错误。

旁注：您可能需要处理更多的循环依赖项。确保您正在监视您的导入，并且它们以不产生循环依赖的方式解析。