TypeDI Service container integration with TypeORM
This package provides decorators for TypeORM that can be used with TypeDI.
Installation
To start using TypeDI install the required packages via NPM:
npm install typeorm-typedi-extensions typedi reflect-metadataImport the reflect-metadata package at the first line of your application:
import 'reflect-metadata';
// Your other imports and initialization code
// comes here after you imported the reflect-metadata package!You need to enable emitting decorator metadata in your Typescript config. Add these two lines to your tsconfig.json file under the compilerOptions key:
"emitDecoratorMetadata": true,
"experimentalDecorators": true,Configure TypeORM in your app to use the TypeDI container before you create a connection:
import { createConnection, useContainer } from 'typeorm';
import { Container } from 'typeorm-typedi-extensions';
// â–² Notice how we import container from this library, instead of TypeDI.
/** Tell TypeORM to use the container provided by this lib to resolve it's dependencies. */
useContainer(Container);
/** Create a connection and start using TypeORM. */
createConnection({
/* <connection options> */
}).catch(error => {
console.error(`Couldn't connect to the database!`);
console.error(error);
});Usage
This package exposes three decorators all three decorators can be used on properties or on constructor parameters.
IMPORTANT: To allow TypeDI to resolve the dependencies on your classes you must mark them with
@Servicedecorator from the TypeDI package.
@InjectConnection decorator
Injects Connection from where you can access anything in your connection.
Optionally, you can specify a connection to inject by name in the decorator parameter.
import { Service } from 'typedi';
import { Connection } from 'typeorm';
import { InjectConnection } from 'typeorm-typedi-extensions';
@Service()
export class MyCustomClass {
@InjectConnection()
private propertyInjectedConnection: Connection;
constructor(@InjectConnection() private constructorInjectedConnection: Connection) {}
}@InjectManager decorator
Injects EntityManager from where you can access any entity in your connection.
Optionally, you can specify a connection to inject by name in the decorator parameter.
import { Service } from 'typedi';
import { EntityManager } from 'typeorm';
import { InjectManager } from 'typeorm-typedi-extensions';
@Service()
export class MyCustomClass {
@InjectManager()
private propertyInjectedEntityManager: EntityManager;
constructor(@InjectManager() private constructorInjectedEntityManager: EntityManager) {}
}@InjectRepository decorator
Injects Repository, MongoRepository, TreeRepository or custom repository of some Entity.
Optionally, you can specify a connection to inject by name in the decorator parameter.
import { Service } from 'typedi';
import { Repository } from 'typeorm';
import { InjectRepository } from 'typeorm-typedi-extensions';
// MyDatabaseModel is a TypeORM entity (class marked with `@Entity()` decorator)
import { MyDatabaseModel } from './entities/post.entity.ts';
@Service()
export class MyCustomClass {
@InjectRepository(MyDatabaseModel)
private propertyInjectedRepository: Repository<MyDatabaseModel>;
constructor(@InjectRepository(MyDatabaseModel) private constructorInjectedRepository: Repository<MyDatabaseModel>) {}
}Example with custom connection name:
@Service()
export class PostRepository {
@InjectRepository(Post, 'custom-con-name')
private repository: Repository<Post>;
}You can also inject custom Repository of some Entity. To make this work have to create the class which extends the
generic Repository<T> class and decorate it with EntityRepository<T> decorator.
import { Service } from 'typedi';
import { Repository, EntityRepository } from 'typeorm';
import { InjectRepository } from 'typeorm-typedi-extensions';
// UserModel is a TypeORM entity (class marked with `@Entity()` decorator)
import { UserModel } from './entities/user.entity.ts';
@Service()
@EntityRepository(UserModel)
export class UserRepository extends Repository<UserModel> {
public findByEmail(email: string) {
return this.findOne({ email });
}
}
@Service()
export class PostService {
constructor(
@InjectRepository()
private readonly userRepository: UserRepository
) {}
public async userExist(user: User): boolean {
return (await this.userRepository.findByEmail(user.email)) ? true : false;
}
}