NestJS dependency injection - delete garbage from constructor in resolver

So I have been working on a NestJs+Graphql+Postgresql application using ddd architecture. And now it just adds user to a database.

I have the following user.resolver in the presentation layer:

@Resolver(of => UserBaseWithPassword)
export class UserResolver {
    private readonly userApplication: UserApplication
    constructor(private readonly userRepo: UserPostgresql) {
        const userService = new UserService(userRepo)
        this.userApplication = new UserApplication(userService)
    }
    
    @Query(returns => String)
    users() : string {
        return "";
    }

    @Mutation(returns => String)
    async createUser(@Args('createUserDTO') createUserWithPasswordDTO: CreateUserWithPasswordDTO): Promise<string> {
        return await this.userApplication.create(createUserWithPasswordDTO=createUserWithPasswordDTO)
    }

}

It works fine, but I need to get rid of garbage in the constructor.
Here is my application layer's
user.ts :

export class UserApplication{
    constructor(private userService: UserService) {}

    async create(createUserWithPasswordDTO: CreateUserWithPasswordDTO): Promise<string> {
        return await this.userService.create(createUserWithPasswordDTO=createUserWithPasswordDTO);
    }
}

In the domain layer i have user.service.ts :

@Injectable()
export class UserService {
    constructor(private readonly userRepo: IUserRepo) {}

    async create(createUserWithPasswordDTO: CreateUserWithPasswordDTO): Promise<string> {
        this.validateEmail(createUserWithPasswordDTO.email)
        this.validatePassword(createUserWithPasswordDTO.password)
        try{
            createUserWithPasswordDTO.password = await this.hashPassword(createUserWithPasswordDTO.password);
            return await this.userRepo.create(createUserWithPasswordDTO);
        }catch(e){
            throw new Error("DEFAULT_USER_ERROR"+e)
        }
    }

    private async hashPassword(password: string): Promise<string> {
        const saltRounds = process.env.PASSWORD_SALT_ROUNDS;
        return await bcrypt.hash(password, saltRounds);;
    }

    private validateEmail(email: string): boolean {
        if(email.length < MIN_EMAIL_LENGTH)
            throw new Error(EMAIL_MIN_LENGTH_TEXT)
        if(email.length > MAX_EMAIL_LENGTH)
            throw new Error(EMAIL_MAX_LENGTH_TEXT)
        if(!EMAIL_REGEX.test(email))
            throw new Error(EMAIL_REGEX_TEXT)
        return true;
    }

    private validatePassword(password: string): boolean {
        if(password.length < MIN_PASSWORD_LENGTH || password.length > MAX_PASSWORD_LENGTH)
            throw new Error(PASSWORD_LENGTH_ERROR_TEXT)
        if(!PASSWORD_HAS_NUMBER_REGEX.test(password))
            throw new Error(PASSWORD_NOT_INCLUDES_NUMBER_TEXT)
        if(!PASSWORD_HAS_LETTER_REGEX.test(password))
            throw new Error(PASSWORD_NOT_INCLUDES_LETTER_TEXT)
        return true;
    }
}

and an Interface user.repo :

import { CreateUserWithPasswordDTO } from "./dtos/create-user.dto";

export interface IUserRepo  {    
    create(createUserWithPasswordDTO: CreateUserWithPasswordDTO): Promise<string>
}

And lastly, in the infrustructure layer I have repo.ts, that implements interface UserRepo :

@Injectable()
export class UserPostgresql implements IUserRepo{
    constructor(@InjectDataSource() private dataSource: DataSource) {}
    async create(createUserWithPasswordDTO: CreateUserWithPasswordDTO): Promise<string> {
        const parameters = [uuidv4(), createUserWithPasswordDTO.email, createUserWithPasswordDTO.password]
        const reply = await this.dataSource.query(CREATE_USER, parameters)
        return reply[0].id
    }
}

I mention all above in the user.module :

import * as dotenv from 'dotenv';

const ENV_FILE_PATH = './ci/postgres/.env'
dotenv.config({path: ENV_FILE_PATH});

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [],
  providers: [ 
    Object,
    UserPostgresql,
    UserService,
    UserApplication,
    UserPostgresql,
    UserResolver
  ]
})
export class UserModule {}

I write Object in the @Module, because program doesn't compile without it which is also an issue.

I tried to write in user.module something like

{
      provide: UserRepoSymbol,
      useClass: UserPostgresql,
},

then changing constructor in the user.service to :

constructor(@Inject(UserRepoSymbol) private readonly userRepo: IUserRepo) {}

and also changing the user.resolver's constructor just to:


constructor(private readonly userApplication: UserApplication) {}


but it seems not to work and i get an error :

TypeError: Cannot read properties of undefined (reading 'create')
    at UserApplication.create (C:\path\api-service\src\application\user.ts:8:39)
    at UserResolver.createUser (C:\path\src\presentation\user\user.resolver.ts:20:43)...

I forgot @Injectable decorator in user.application