NestJs fail inserting data into mongoDb

Question

In my application i have a simple method as register and into that i want to insert a simple data into mongo-db and retrieve all saved documents after that, but i get empty always and i can't resolve this issue:

problem is this: i can store data into database on main controller of application but when i try to send request to microservice, i can't and my code doesn't work

//HestiaController - getting request
@Controller()
export class HestiaController {
  constructor(private readonly hestiaService: HestiaService) {}

  @Post()
  async createUser(@Body() request: RequestCreateNewUser){
    return this.hestiaService.createNewUser(request);
  }
}

//HestiaService - send request to microservice
@Injectable()
export class HestiaService {
    constructor(@Inject(REGISTER_SERVICE) private registerClient: ClientProxy) {
    }

    async createNewUser(request: RequestCreateNewUser) {
        this.registerClient.emit('register_request', request);
    }
}

//hestia-module.ts
@Module({
    imports: [
        ConfigModule.forRoot({
            isGlobal: true,
            validationSchema: Joi.object({
                PORT: Joi.string().required(),
            }),
            envFilePath:'./apps/hestia/.env'
        }),
        RmqModule.register({
            name:REGISTER_SERVICE
        }),
    ],
    controllers: [HestiaController],
    providers: [HestiaService],
})
export class HestiaModule {
}

register.controller.ts:

@Controller()
export class RegisterController {
  private logger = new Logger(RegisterController.name);
  constructor(private readonly registerService: RegisterService) {}

  @EventPattern('register_request')
  async handleRegisterRequest(@Payload() data:RequestCreateNewUser,@Ctx() context:RmqContext){
    await this.registerService.register(data);
  }
}

register.service.ts:

@Injectable()
export class RegisterService {
  private logger = new Logger(RegisterService.name);

  constructor(private readonly registerRepository:RegisterRepository) {
  }

  async register(data: RequestCreateNewUser) {
    return await this.registerRepository.create(data);
  }
}

register.repository:

@Injectable()
export class RegisterRepository extends AbstractRepository<Register> {
    protected readonly logger = new Logger(RegisterRepository.name);

    constructor(@InjectModel(Register.name) registerModel: Model<Register>, @InjectConnection() connection: Connection) {
        super(registerModel, connection);
    }
}

register.schema.ts

@Schema({versionKey: false})
export class Register extends AbstractDocument {
    @Prop()
    mobileNumber: string;
    @Prop()
    username: string;
    @Prop()
    password: string;
}

export const RegisterSchema = SchemaFactory.createForClass(Register);

abstract.repository

export abstract class AbstractRepository<TDocument extends AbstractDocument> {
    protected abstract readonly logger: Logger;

    protected constructor(
        protected readonly model: Model<TDocument>,
        private readonly connection: Connection,
    ) {
    }

    async create(
        document: Omit<TDocument, '_id'>,
        options?: SaveOptions,
    ): Promise<TDocument> {
        const createdDocument = new this.model({
            ...document,
            _id: new Types.ObjectId(),
        });

        this.logger.log(createdDocument);
        return (
            await createdDocument.save(options)
        ).toJSON() as unknown as TDocument;
    }

    async find(filterQuery: FilterQuery<TDocument>) {
        return this.model.find(filterQuery, {}, {lean: true});
    }

    async startTransaction(): Promise<ClientSession> {
        const session = await this.connection.startSession();
        session.startTransaction();
        return session;
    }
}

and log:

 [Nest] 55  - 11/27/2022, 8:17:06 PM     LOG [RegisterRepository] 

 {
   _id: new ObjectId("6383c5c2efd642a95f171566"),
   mobileNumber: 'mobileNumber',
   username: 'username',
   password: 'password'
 }
 [Nest] 55  - 11/27/2022, 8:17:06 PM     LOG [RegisterService] user created successful
 [Nest] 55  - 11/27/2022, 8:17:06 PM     LOG [RegisterService] {}

Answer 1

Try checking directly against the database. When logging results from a find, you need to put await

this.logger.log(JSON.stringify(await this.registerRepository.find({})));