To resolve the issue, you must eliminate the Imports of ItemsController and ItemsService from the app.module.ts file.

This solution was necessary because:

1. You have already imported ItemsController and ItemsService in your items.module.ts file, so there is no need to import them again in the app.module.ts file.
2. In your items.module.ts, you have the following line:

   @Module({
     imports: [MongooseModule.forFeature([{ name: 'Item', schema: ItemSchema }])],
     ...
   })
   

   This line is crucial for proper dependency injection to work in the items.service.ts file. As you can see in the app.module.ts file, that line is missing.
3. You can certainly add that line to your app.module.ts file, but it would negate the purpose of having the items.module.ts file in the first place.

Feel free to check out my repository. 😁

It is recommended to exclude ItemsController and ItemsService from the AppModule. Since you have already imported the ItemsModule into the AppModule, there is no need to include them again.

app.module.ts

import { AppService } from './app.service';
import { ItemsModule } from "./items/items.module";
import { MongooseModule} from '@nestjs/mongoose';
import config from './config/keys';


@Module({
  imports: [ItemsModule, MongooseModule.forRoot(config.mongoURI)],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

items.service.ts

import { Injectable } from '@nestjs/common';
import { Item } from './interfaces/items.interface';
import { Model } from 'mongoose';
import { InjectModel } from '@nestjs/mongoose';

@Injectable()
export class ItemsService {

    constructor(@InjectModel('Item') private readonly itemModel:Model<Item>){}   

    async findAll(): Promise<Item[]> {
        return await this.itemModel.find();
    }

    async fineOne(id: string): Promise<Item> {
        return await this.itemModel.findOne({_id: id});
    }
}

I encountered the same issue and was able to resolve it by making some adjustments in the app.module.ts file. I decided to remove the ItemsController and ItemsService files from the module configuration, which ultimately fixed the problem for me. As a result, my app.module.ts now appears like this:

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import {MongooseModule} from '@nestjs/mongoose';
import { ItemsModule } from './items/items.module';
import config from './config/keys';

@Module({
  imports: [ItemsModule,MongooseModule.forRoot(config.mongoURI)],
  controllers: [AppController ],
  providers: [AppService ],
})
export class AppModule {}

Avoid using controllers or providers from other modules in the app module, such as UserController.

Here is an example of app.module.ts:

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/nest'),
    UserModule,
    TasksModule,
    AuthModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})

Similarly, in user.module.ts and other modules:

@Module({
  imports: [
    MongooseModule.forFeature([
      {
        name: 'users',
        schema: UserSchema,
      },
    ]),
  ],
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService],
})

If you find yourself in a situation where two modules depend on each other, it's best practice not to import them directly. Instead, use forwardRef() in both modules.

Source Circular dependency

@Module({
  imports: [
     MongooseModule.forFeature([
       { name: 'User', schema: UserSchema },
     ]),
    forwardRef(() => BusinessModule),
  ],
  providers: [UserService, UserResolver],
  exports: [MongooseModule],
})
export class UserModule {}

Similarly, in the other module:

@Module({
  imports: [
    MongooseModule.forFeature([
       { name: 'Business', schema: BusinessSchema },
     ]),
    forwardRef(() => UserModule),
  ],
  providers: [BusinessService, BusinessResolver],
  exports: [MongooseModule],
})
export class BusinessModule {}

My approach to solving the problem is as follows:

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: '',
      database: 'nest-react-auth',
      entities: [User],
      synchronize: true,
    }),
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [AppController],
  providers: [AppService],
})

In this solution, I included my entity file User using

TypeOrmModule.forFeature([User]),

By inserting this into the item module, I was able to successfully resolve the issue.

imports: [TypeOrmModule.forFeature([Item])],

After encountering a similar issue, I found that the problem stemmed from missing the ServiceClass in the providers field within a submodule. To rectify this, I made the necessary adjustment as shown below and successfully resolved the error:

@Module({
  imports: [MongooseModule.forFeature([{ name: 'test', schema: testSchema }])],
  controllers: [TestController],
  providers: [TestService],
})

Make sure to include @ItemModule in the module where you wish to utilize it. Learn more about authentication in NestJS here.

I encountered a similar issue, but was able to resolve it by removing the itemService and itemController lines from both the controller and provider files.