# TypeORM Contributors are welcome
# TypeORM v0.3.x
TypeORM v0.3.x is available and change the way on how to create connection (DataSource). His new API,
doesn't require to install the dedicated Ts.ED module. If you come from v0.2.0, keep the Ts.ED module installed and change the connection by DataSource and update your repositories' implementation.
See our next section for more details about DataSource and Custom Repository.
# Create new connection
Ts.ED CLI support DataSource creation. Just install the latest Ts.ED CLI version and run the followings command:
tsed generate
Then, select TypeORM DataSource options and follow the wizard.
You can also create your DataSource as following in your project:
import {registerProvider} from "@tsed/di";
import {DataSource} from "typeorm";
import {Logger} from "@tsed/logger";
import {User} from "../entities/User";
export const MYSQL_DATA_SOURCE = Symbol.for("MySqlDataSource");
export const MysqlDataSource = new DataSource({
// name: "default", if you come from v0.2.x
type: "mysql",
entities: [User], // add this to discover typeorm model
host: "localhost",
port: 3306,
username: "test",
password: "test",
database: "test"
});
registerProvider<DataSource>({
provide: MYSQL_DATA_SOURCE,
type: "typeorm:datasource",
deps: [Logger],
async useAsyncFactory(logger: Logger) {
await MysqlDataSource.initialize();
logger.info("Connected with typeorm to database: MySQL");
return MysqlDataSource;
},
hooks: {
$onDestroy(dataSource) {
return dataSource.isInitialized && dataSource.close();
}
}
});
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Finally, inject the DataSource in your controller or service:
import {Injectable, Inject} from "@tsed/di";
import {DataSource} from "typeorm";
import {MYSQL_DATA_SOURCE} from "../datasources/MysqlDataSource";
@Injectable()
export class MyService {
@Inject(MYSQL_DATA_SOURCE)
protected mysqlDataSource: DataSource;
$onInit() {
if (this.mysqlDataSource.isInitialized) {
console.log("INIT");
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Retrieve all DataSources from a Service
All data sources connection can be retrieved as following:
import {Inject, Injectable, InjectorService} from "@tsed/di";
@Injectable()
export class DataSourcesService {
@Inject()
protected injector: InjectorService;
getDataSources() {
return this.injector.getAll("typeorm:datasource");
}
}
2
3
4
5
6
7
8
9
10
11
# Use Entity TypeORM with Controller
We need to define an Entity TypeORM like this and use Ts.ED Decorator to define the JSON Schema.
import {Maximum, MaxLength, Minimum, Property, Required} from "@tsed/schema";
import {Column, Entity, PrimaryGeneratedColumn} from "typeorm";
@Entity()
export class User {
@PrimaryGeneratedColumn()
@Property()
id: number;
@Column()
@MaxLength(100)
@Required()
firstName: string;
@Column()
@MaxLength(100)
@Required()
lastName: string;
@Column()
@Minimum(0)
@Maximum(100)
age: number;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Now, the model is correctly defined and can be used with a Controller , AJV validation, Swagger and TypeORM (opens new window).
We can use this model with a Controller like that:
import {BodyParams} from "@tsed/platform-params";
import {Get, Post} from "@tsed/schema";
import {Controller, Inject} from "@tsed/di";
import {MYSQL_DATA_SOURCE} from "../datasources/MySqlDataSource";
import {User} from "../entities/User";
@Controller("/users")
export class UsersCtrl {
@Inject(MYSQL_DATA_SOURCE)
protected mysqlDataSource: DataSource;
@Post("/")
create(@BodyParams() user: User): Promise<User> {
return this.mysqlDataSource.manager.create(User, user);
}
@Get("/")
getList(): Promise<User[]> {
return this.mysqlDataSource.manager.find(User);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Create an injectable repository
Repository
is just like EntityManager
but its operations are limited to a concrete entity.
You can access the repository via DataSource
.
import {Injectable} from "@tsed/di";
import {DataSource} from "typeorm";
import {MySqlDataSource} from "../datasources/MySqlDataSource";
import {User} from "../entities/User";
export const UserRepository = MySqlDataSource.getRepository(User);
export const USER_REPOSITORY = Symbol.for("UserRepository");
export type USER_REPOSITORY = typeof UserRepository;
registerProvider({
provide: USER_REPOSITORY,
useValue: UserRepository
});
2
3
4
5
6
7
8
9
10
11
12
13
Then inject the UserRepository
in your controller:
import {BodyParams} from "@tsed/platform-params";
import {Get, Post} from "@tsed/schema";
import {Controller, Inject} from "@tsed/di";
import {USER_REPOSITORY} from "../repositories/UserRepository";
import {User} from "../entities/User";
@Controller("/users")
export class UsersCtrl {
@Inject(USER_REPOSITORY)
protected repository: USER_REPOSITORY;
@Post("/")
create(@BodyParams() user: User): Promise<User> {
return this.repository.save(user);
}
@Get("/")
getList(): Promise<User[]> {
return this.repository.find();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
In order to extend UserRepository
functionality you can use .extend
method of Repository
class:
import {Injectable} from "@tsed/di";
import {DataSource} from "typeorm";
import {MySqlDataSource} from "../datasources/MySqlDataSource";
import {User} from "../entities/User";
export const UserRepository = MySqlDataSource.getRepository(User).extends({
findByName(firstName: string, lastName: string) {
return this.createQueryBuilder("user")
.where("user.firstName = :firstName", {firstName})
.andWhere("user.lastName = :lastName", {lastName})
.getMany();
}
});
export const USER_REPOSITORY = Symbol.for("UserRepository");
export type USER_REPOSITORY = typeof UserRepository;
registerProvider({
provide: USER_REPOSITORY,
useValue: UserRepository
});
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Then inject the UserRepository
in your controller:
import {BodyParams} from "@tsed/platform-params";
import {Get, Post} from "@tsed/schema";
import {Controller, Inject} from "@tsed/di";
import {User} from "../../entities/User";
import {USER_REPOSITORY} from "../../repositories/UserRepository";
@Controller("/users")
export class UsersController {
@Inject(USER_REPOSITORY)
protected repository: USER_REPOSITORY;
@Get("/")
getByName(): Promise<User[]> {
return this.repository.findByName("john");
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# TypeORM v0.2.x (deprecated)
# Features
Currently, @tsed/typeorm
allows you to:
- Configure one or more TypeORM connections via the
@Configuration
configuration. All databases will be initialized when the server starts during the server'sOnInit
phase. - Use the Entity TypeORM as Model for Controllers, AJV Validation and Swagger.
- Declare a connection with asyncProvider or automatically by server configuration.
# Installation
To begin, install the TypeORM module for TS.ED:
npm install --save @tsed/typeorm
npm install --save typeorm
2
Then import @tsed/typeorm
in your Server:
import {Configuration} from "@tsed/di";
import "@tsed/platform-express";
import "@tsed/typeorm"; // !!! IMPORTANT TO ADD THIS !!!
@Configuration({
typeorm: [
{
name: "default",
type: "postgres",
// ...,
entities: [`./entity/*{.ts,.js}`],
migrations: [`./migrations/*{.ts,.js}`],
subscribers: [`./subscriber/*{.ts,.js}`]
},
{
name: "mongo",
type: "mongodb"
// ...
}
]
})
export class Server {}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Don't forget to import the TypeORM module in the Server. Ts.ED need it to load correctly the TypeORM DI,
entities and repositories!
# TypeORMService
TypeORMService lets you retrieve an instance of TypeORM Connection.
import {AfterRoutesInit} from "@tsed/common";
import {Injectable} from "@tsed/di";
import {TypeORMService} from "@tsed/typeorm";
import {Connection} from "typeorm";
import {User} from "../models/User";
@Injectable()
export class UsersService implements AfterRoutesInit {
private connection: Connection;
constructor(private typeORMService: TypeORMService) {}
$afterRoutesInit() {
this.connection = this.typeORMService.get("mongoose")!; // get connection by name
}
async create(user: User): Promise<User> {
// do something
// ...
// Then save
await this.connection.manager.save(user);
console.log("Saved a new user with id: " + user.id);
return user;
}
async find(): Promise<User[]> {
const users = await this.connection.manager.find(User);
console.log("Loaded users: ", users);
return users;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
For more information about TypeORM, look its documentation here (opens new window);
# Declare your connection as provider
It is also possible to create your connection with the useAsyncFactory
feature (
See custom providers)
This approach allows you to inject your connection as a Service to another one.
To create a new connection, declare your custom provider as follows:
import {Configuration, registerProvider} from "@tsed/di";
import {createConnection} from "@tsed/typeorm";
import {Connection, ConnectionOptions} from "typeorm";
export const CONNECTION = Symbol.for("CONNECTION"); // declare your own symbol
export type CONNECTION = Connection; // Set alias types (optional)
const CONNECTION_NAME = "default"; // change the name according to your server configuration
registerProvider({
provide: CONNECTION,
deps: [Configuration],
async useAsyncFactory(configuration: Configuration) {
const settings = configuration.get<ConnectionOptions[]>("typeorm")!;
const connectionOptions = settings.find((o) => o.name === CONNECTION_NAME);
return createConnection(connectionOptions!);
}
});
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Then inject your connection to another service or provide like this:
import {Inject, Injectable} from "@tsed/di";
import {CONNECTION} from "./typeorm-async-provider";
@Injectable()
export class UserService {
constructor(@Inject(CONNECTION) connection: CONNECTION) {}
}
2
3
4
5
6
7
# Use Entity TypeORM with Controller
We need to define an Entity TypeORM like this and use Ts.ED Decorator to define the JSON Schema.
import {Maximum, MaxLength, Minimum, Property, Required} from "@tsed/schema";
import {Column, Entity, PrimaryGeneratedColumn} from "typeorm";
@Entity()
export class User {
@PrimaryGeneratedColumn()
@Property()
id: number;
@Column()
@MaxLength(100)
@Required()
firstName: string;
@Column()
@MaxLength(100)
@Required()
lastName: string;
@Column()
@Minimum(0)
@Maximum(100)
age: number;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Now, the model is correctly defined and can be used with a Controller , AJV validation, Swagger and TypeORM (opens new window).
We can use this model with a Controller like that:
import {BodyParams} from "@tsed/platform-params";
import {Get, Post} from "@tsed/schema";
import {Controller} from "@tsed/di";
import {User} from "../entities/User";
import {UsersService} from "../services/UsersService";
@Controller("/users")
export class UsersCtrl {
constructor(private usersService: UsersService) {}
@Post("/")
create(@BodyParams() user: User): Promise<User> {
return this.usersService.create(user);
}
@Get("/")
getList(): Promise<User[]> {
return this.usersService.find();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# EntityRepository
You can create a custom repository which should contain methods to work with your database. Usually custom repositories
are created for a single entity and contain their specific queries. For example, let's say we want to have a method
called findByName(firstName: string, lastName: string)
which will search for users by a given first and last names.
The best place for this method is in Repository, so we could call it like userRepository.findByName(...)
. You can
achieve this using custom repositories.
@tsed/typeorm
plugin configures the DI so that repositories declared for TypeORM can be injected into a Ts.ED
controller or service.
The first way to create a custom repository is to extend Repository. Example:
import {Repository, EntityRepository} from "typeorm";
import {User} from "../entity/User";
@EntityRepository(User)
export class UserRepository extends Repository<User> {
findByName(firstName: string, lastName: string) {
return this.findOne({firstName, lastName});
}
}
2
3
4
5
6
7
8
9
Then inject your repository to another service:
import {Inject, Injectable} from "@tsed/di";
import {UseConnection} from "@tsed/typeorm";
import {UserRepository} from "./repository/UserRepository";
@Injectable()
export class OtherService {
@Inject()
@UseConnection("db2")
userRepository2: UserRepository;
constructor(public userRepository: UserRepository, @UseConnection("db3") public userRepository3: UserRepository) {}
}
2
3
4
5
6
7
8
9
10
11
12
Use @@UseConnection@@ decorator to select which database connection the injected repository should be used (
require Ts.ED v5.58.0+).
# Author
# Maintainers Help wanted
Other topics
- Session & cookies
- Passport.js
- Keycloak
- Prisma
- TypeORM
- MikroORM
- Mongoose
- GraphQL
- Socket.io
- Swagger
- AJV
- Multer
- Serve static files
- Templating
- Serverless HTTP
- Seq
- OIDC
- Stripe
- Agenda
- Terminus
- Serverless
- IORedis
- Controllers
- Providers
- Model
- JsonMapper
- Middlewares
- Pipes
- Interceptors
- Authentication
- Hooks
- Exceptions
- Throw HTTP Exceptions
- Cache
- Command
- Response Filter
- Injection scopes
- Custom providers
- Lazy-loading provider
- Custom endpoint decorator
- Testing
- Customize 404