Nest can't resolve dependencies of the MerchantsService

I am learning nestjs and really like its modular approach. I am trying to import a service into another service to avoid code duplication. Here is the error message:

Nest can't resolve dependencies of the MerchantsService (?). 
Please make sure that the argument MerchantEntityRepository 
at index [0] is available in the RewardsModule context.

Potential solutions:
- Is RewardsModule a valid NestJS module?
- If MerchantEntityRepository is a provider, is it part of the current RewardsModule?
- If MerchantEntityRepository is exported from a separate @Module, is that module imported within RewardsModule?
  @Module({
    imports: [ /* the Module containing MerchantEntityRepository */ ]
  })

Here is my basic setup. Note, everything works except for the service import. Please also note that I do not have a "MerchantEntityRepository" class that it is asking about.

merchants.controller.ts

import {
  Controller,
  Get,
  Param,

} from '@nestjs/common';
import { MerchantsService } from './merchants.service';


@Controller('merchants')
export class MerchantsController {
  constructor(private readonly merchantsService: MerchantsService) {}

  @Get(':id')
  async findOne(@Param('id') id: number) {
    return this.merchantsService.findOne(+id);
  }

}

merchants.services.ts

import {
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { MerchantEntity } from './entities/merchant.entity';
import { Repository } from 'typeorm';
import { errorMessages } from 'src/utility/common/error-mssages';


@Injectable()
export class MerchantsService {
  constructor(
    @InjectRepository(MerchantEntity)
    private merchantRepository: Repository<MerchantEntity>, 
  ) {}

  async findOne(id: number): Promise<MerchantEntity> {
    const merchant: MerchantEntity = await this.merchantRepository.findOneBy({
      id,
    });

    if (!merchant)
      throw new NotFoundException(errorMessages.MERCHANT_UNKNOWN_ID);

    return merchant;
  }


}

merchants.module.ts

import { Module } from '@nestjs/common';
import { MerchantsService } from './merchants.service';
import { MerchantsController } from './merchants.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { MerchantEntity } from './entities/merchant.entity';

@Module({
  imports: [TypeOrmModule.forFeature([MerchantEntity])],
  controllers: [MerchantsController],
  providers: [MerchantsService],
})
export class MerchantsModule {}

rewards.controller.ts

import {
  Controller,
  Post,
  Body,
  Param,
  UseGuards,
} from '@nestjs/common';
import { RewardsService } from './rewards.service';
import { CreateRewardDto } from './dto/create-reward.dto';
import { AuthenticationGuard } from 'src/utility/guards/authentication.guard';
import { AuthorizeGuard } from 'src/utility/guards/authorization.guard';
import { Roles } from 'src/utility/common/user-rules.enum';
import { CurrentUser } from 'src/utility/decorators/current-user.decorator';
import { UserEntity } from 'src/users/entities/user.entity';

@Controller('rewards')
export class RewardsController {
  constructor(private readonly rewardsService: RewardsService) {}

  @UseGuards(AuthenticationGuard, AuthorizeGuard([Roles.MERCHANT]))
  @Post('merchantID/:id/create')
  create(
    @Body() createRewardDto: CreateRewardDto,
    @Param('id') merchantID: number,
    @CurrentUser() currentUser: UserEntity,
  ) {
    return this.rewardsService.create(createRewardDto, merchantID, currentUser);
  }
}

rewards.services.ts

import { Injectable } from '@nestjs/common';
import { CreateRewardDto } from './dto/create-reward.dto';
import { UserEntity } from 'src/users/entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { RewardEntity } from './entities/reward.entity';
import { Repository } from 'typeorm';
import { MerchantsService } from 'src/merchants/merchants.service';

@Injectable()
export class RewardsService {
  constructor(
    @InjectRepository(RewardEntity)
    private rewardRepository: Repository<RewardEntity>,

    private readonly merchantsService: MerchantsService,
  ) {}

  create(
    createRewardDto: CreateRewardDto,
    merchantID: number,
    currentUser: UserEntity,
  ) {
    const id = merchantID;
    const merchant = this.merchantsService.findOne(id);

    console.log(merchant);
  }

rewards.module.ts

import { Module } from '@nestjs/common';
import { RewardsService } from './rewards.service';
import { RewardsController } from './rewards.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { RewardEntity } from './entities/reward.entity';
import { MerchantsService } from 'src/merchants/merchants.service';
import { MerchantsModule } from 'src/merchants/merchants.module';

@Module({
  imports: [TypeOrmModule.forFeature([RewardEntity]), MerchantsModule],
  controllers: [RewardsController],
  providers: [RewardsService, MerchantsService],
})
export class RewardsModule {}

In your merchants.module.ts you have to add exports: [MerchantService] in order to use MerchantService in your code.

From NestJs docs, exports is:

> the subset of providers that are provided by this module and should be available in other modules which import this module.

import { Module } from '@nestjs/common';
import { MerchantsService } from './merchants.service';
import { MerchantsController } from './merchants.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { MerchantEntity } from './entities/merchant.entity';

@Module({
  imports: [TypeOrmModule.forFeature([MerchantEntity])],
  controllers: [MerchantsController],
  providers: [MerchantsService],
  exports: [MerchantsService],  // <-- add this line
})
export class MerchantsModule {}

After examining a median post, I found the proper configuration to be this for the rewards.module.ts

import { Module } from '@nestjs/common';
import { RewardsService } from './rewards.service';
import { RewardsController } from './rewards.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { RewardEntity } from './entities/reward.entity';
import { MerchantsModule } from 'src/merchants/merchants.module';
@Module({
  imports: [TypeOrmModule.forFeature([RewardEntity]), MerchantsModule],
  controllers: [RewardsController],
  providers: [RewardsService],
})
export class RewardsModule {}

after I export the

  exports: [MerchantsService], 

from the merchants.module.ts as pointed out by @Wuagliono.