NestJS无法解析依赖关系

Question

我正在尝试将服务请求服务添加到订单服务中

est无法解析ServiceRequestsService(ServiceRequestRepository，[object Object]，CounterService，？，+)的依赖关系。请确保索引 [3] 处的参数依赖项在 ServiceRequestsModule 上下文中可用。

我尝试像文档一样将依赖项相互转发，但这似乎也无济于事。

service-requests.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-requests.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,
) {}

订单.服务.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,
) {
}

购买.模块.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导入OrdersServiceSRS，形成另一个循环依赖。要解决此问题，PurchasesService应forwardRefOrdersService，OrdersService应forwardRefPurchasesService，SRS应同时forwardRefOrdersService和PurchasesService。这应该注意或cannot resolve dependency错误。

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