Injecting custom repository using inversify

[ksromero]

I'm practicing mikroorm with inversify.

I have TodoEntity

import { Entity, Property, PrimaryKey, EntityRepositoryType } from '@mikro-orm/core'
import { TodoRepository } from '../../repositories'


@Entity({tableName: 'todo'})
export class TodoEntity {

  // [EntityRepositoryType]?: TodoRepository;

  @PrimaryKey()
  id?: number

  @Property()
  title: string

  @Property()
  description: string

  constructor(title: string, description: string) {
    this.title = title
    this.description = description
  }
} 

And this is the custom repository TodoRepository

import { EntityRepository } from '@mikro-orm/mysql'
import { Repository } from '@mikro-orm/core'
import { TodoEntity } from '../models/entities'
import { injectable } from "inversify"


@injectable()
@Repository(TodoEntity)
export class TodoRepository extends EntityRepository<TodoEntity> {} 

I'm injecting the repository into the service via

import { injectable, inject } from "inversify"
import { TodoRepository } from "../repositories"
import TYPES from "../../di/types"
import autoBind from "auto-bind";

@injectable()
export class TodoService {

  private todoRepository: TodoRepository

  constructor (@inject(TYPES.TodoRepository) todoRepository: TodoRepository) {
    this.todoRepository = todoRepository
    autoBind(this)
  }

  public async getTodos() {
    return await this.todoRepository.findAll()
  }
}

and this is my controller

import { injectable, inject } from "inversify"
import { TodoService } from "../services/todoService"
import { Request, Response, NextFunction} from "express";
import TYPES from "../../di/types";
import autoBind from "auto-bind";

@injectable()
export class TodoController {

  todoService: TodoService

  constructor(@inject(TYPES.TodoService) todoService: TodoService) {
    this.todoService = todoService
    autoBind(this)
  }

  public async getAllTodos(req: Request, res: Response, next: NextFunction) {
    res.send(await this.todoService.getTodos())
  }
}

This is the types

const TYPES = {
  TodoRepository: Symbol.for("TodoRepository"),
  TodoService: Symbol.for("TodoService"),
  TodoController: Symbol.for("TodoController")
};

export default TYPES

Container

import { TodoRepository } from "../todos/repositories"
import { TodoService } from "../todos/services/todoService"
import { TodoController } from "../todos/controllers/todoController"
import { Container } from "inversify"
import TYPES from "./types"



const container = new Container();

container.bind<TodoController>(TYPES.TodoController).to(TodoController);
container.bind<TodoService>(TYPES.TodoService).to(TodoService);
container.bind<TodoRepository>(TYPES.TodoRepository).to(TodoRepository);


export { container }

How can I inject the custom repository to service, i'm having an error saying
Error: Missing required @injectable annotation in: SqlEntityRepository

But when I did not include the repository only the service and the controller and I tried to test dump. the DI is just working fined

Im following this example Inversify example with mikro orm

but on the example he's not using the custom repo, any idea where can I start to fix the issue? Thanks in advanced

[B4nan]

cc @PodaruDragos

[ksromero]

btw link is broken. I tried your example,

const bindEntityToRepository = <T, U>(
  bind: interfaces.Bind,
  binding: symbol,
  connection: MikroORM<IDatabaseDriver<Connection>>,
  entity: { new(...args: string[] & U): T; }
) => {
    bind<EntityRepository<T>>(binding)
    .toDynamicValue((): EntityRepository<T> => {
      return connection.em.getRepository<T>(entity);
    })
    .inRequestScope();

};


export const bindings = new AsyncContainerModule(async (bind): Promise<void> => {

  bind<TodoController>(TYPES.TodoController).to(TodoController);
  bind<TodoService>(TYPES.TodoService).to(TodoService);
  bind<TodoRepository>(TYPES.TodoRepository).to(TodoRepository);

  const databaseClient: DatabaseClient = new DatabaseClient();
  const connection = await databaseClient.connect();


  bind<TodoRepository>(TYPES.TodoRepository).toDynamicValue(() => {
    return connection.em.fork().getRepository(TodoEntity)
  })

  bind<MikroORM<IDatabaseDriver<Connection>>>(TYPES.DATABASE_CONNECTION).toConstantValue(connection);


  bindEntityToRepository(bind, TYPES.TodoRepository, connection, TodoEntity);
});

my repository

import { EntityRepository } from '@mikro-orm/mysql'
import { Repository } from '@mikro-orm/core'
import { TodoEntity } from '../models/entities'
import { injectable} from "inversify"


@injectable()
@Repository(TodoEntity)
export class TodoRepository extends EntityRepository<TodoEntity> {

} 

injecting in onto service

@injectable()
export class TodoService {
 
  private todoRepository: EntityRepository<TodoEntity>

  constructor (@inject(TYPES.TodoRepository) todoRepository: EntityRepository<TodoEntity>) {
    this.todoRepository = todoRepository
    autoBind(this)
  }

  public async getTodos() {
    console.log(this.todoRepository)
  }
}

the console.log(this.todoRepository) returns TodoRepository { _em: undefined, entityName: undefined }

[PodaruDragos]

if you do it like that you don't need the @repository you already have a repository.

@inject(TYPES.TEST_REPOSITORY)
    private testRepository: EntityRepository<Test>,

I have to test that out, might be an inversify issue

[ksromero]

tried removing the @repository but still i'm getting TodoRepository { _em: undefined, entityName: undefined }

[PodaruDragos]

if you can create a repro rep I can take a look ( there are some other moving parts there )

[ksromero]

u can check the repo here https://github.com/ksromero/test