跨nestjs模块共享服务

Question

我正在做一个个人项目，在这个项目中，我遵循存储库模式，并将存储库注入到我的服务中(我不使用typeorm，我使用prisma(。现在我遇到了一个问题，在身份验证模块中，我想使用usersService访问数据，该服务在我的usersModule中导出，而我的身份验证模块也导入了usersModuce，但它总是给出一个错误，即嵌套无法解决对authService中usersService的依赖。你们能帮我解决这个问题吗？

users.service.ts:

import { Inject, Injectable } from "@nestjs/common";
import { CreateUserDto } from "./dto/create-user.dto";
import { IUserRepository } from "./user.types";
import { TYPES } from "../app.types";
import { UserOutput } from "./dto/user.output";
@Injectable()
export class UsersService {
constructor(
@Inject(TYPES.User) private readonly userRepository: IUserRepository
) {}
async create(data: CreateUserDto): Promise<UserOutput | null> {
return await this.userRepository.createUser(data);
}
}

users.pository.ts:

import { HttpStatus, Injectable } from "@nestjs/common";
import { PrismaService } from "../prisma/prisma.service";
import { CreateUserDto } from "./dto/create-user.dto";
import { UserOutput } from "./dto/user.output";
import { IUserRepository } from "./user.types";
import { ConfigService } from "@nestjs/config";
import { IEnv } from "../env.types";
import { HttpException } from "@nestjs/common";
@Injectable()
export class UserRepository implements IUserRepository {
constructor(
private readonly prismaService: PrismaService,
private readonly configService: ConfigService<IEnv>
) {}
async createUser(data: CreateUserDto): Promise<UserOutput> {
let { userName, password } = data;
try {
const user = await this.prismaService.user.findFirst({
where: { userName: userName },
});
if (user) {
throw new HttpException(
"User Already Exists",
HttpStatus.UNPROCESSABLE_ENTITY
);
}
const userCreated = await this.prismaService.user.create({
data: { userName: userName, password: hashedPassword as any },
});
} catch (e) {
console.log(e);
throw e;
}

}

users.module.ts

import { Module } from "@nestjs/common";
import { UsersService } from "./users.service";
import { UsersController } from "./users.controller";
import { TYPES } from "../app.types";
import { UserRepository } from "./users.repository";
@Module({
controllers: [UsersController],
providers: [
UsersService,
{
provide: TYPES.User,
useClass: UserRepository,
},
],
exports: [UsersService],
})
export class UsersModule {}

auth.module.ts:

import { Global, Module } from "@nestjs/common";
import { UsersModule } from "../users/users.module";
import { ValidateService } from "./validate.token.service";
@Global()
@Module({
imports: [UsersModule],
providers: [ValidateService],
exports: [ValidateService],
})
export class AuthModule {}

auth.service.ts:

import { Injectable, UnauthorizedException } from "@nestjs/common";
import { Request } from "express";
import { ConfigService } from "@nestjs/config";
import { IEnv } from "../env.types";
import jwt from "jwt-simple";
import { UsersService } from "../users/users.service";
@Injectable()
export class AuthService {
constructor(
private readonly userService: UsersService,
private readonly configService: ConfigService<IEnv>
) {}
async verifyToken(request: Request): Promise<boolean> {
const token = request.headers.authorization;
if (!token) throw new UnauthorizedException();
try {
const secretKey = this.configService.get("SECRET_KEY");
const payload = jwt.decode(token, secretKey);
const user = await this.userService.findOne(payload.sub);
if (user) {
return true;
}
return false;
} catch (e) {
return false;
}
}
}

btw，TYPES.user=符号("用户"(

Answer 1

在这种情况下，他们通常建议使用forwardRef来处理循环依赖关系。