typeorm 0.3.1-dev.d61f857 → 0.3.2-dev.b53a481

package/README.md

@@ -34,133 +34,138 @@ which means you can write high quality, loosely coupled, scalable,
 maintainable applications the most productive way.
 
 TypeORM is highly influenced by other ORMs, such as [Hibernate](http://hibernate.org/orm/),
- [Doctrine](http://www.doctrine-project.org/) and [Entity Framework](https://www.asp.net/entity-framework).
+[Doctrine](http://www.doctrine-project.org/) and [Entity Framework](https://www.asp.net/entity-framework).
 
 ## Features
 
-* Supports both [DataMapper](./docs/active-record-data-mapper.md#what-is-the-data-mapper-pattern) and [ActiveRecord](./docs/active-record-data-mapper.md#what-is-the-active-record-pattern) (your choice).
-* Entities and columns.
-* Database-specific column types.
-* Entity manager.
-* Repositories and custom repositories.
-* Clean object relational model.
-* Associations (relations).
-* Eager and lazy relations.
-* Uni-directional, bi-directional and self-referenced relations.
-* Supports multiple inheritance patterns.
-* Cascades.
-* Indices.
-* Transactions.
-* Migrations and automatic migrations generation.
-* Connection pooling.
-* Replication.
-* Using multiple database connections.
-* Working with multiple databases types.
-* Cross-database and cross-schema queries.
-* Elegant-syntax, flexible and powerful QueryBuilder.
-* Left and inner joins.
-* Proper pagination for queries using joins.
-* Query caching.
-* Streaming raw results.
-* Logging.
-* Listeners and subscribers (hooks).
-* Supports closure table pattern.
-* Schema declaration in models or separate configuration files.
-* Connection configuration in json / xml / yml / env formats.
-* Supports MySQL / MariaDB / Postgres / CockroachDB / SQLite / Microsoft SQL Server / Oracle / SAP Hana / sql.js.
-* Supports MongoDB NoSQL database.
-* Works in NodeJS / Browser / Ionic / Cordova / React Native / NativeScript / Expo / Electron platforms.
-* TypeScript and JavaScript support.
-* ESM and CommonJS support.
-* Produced code is performant, flexible, clean and maintainable.
-* Follows all possible best practices.
-* CLI.
+-   Supports both [DataMapper](./docs/active-record-data-mapper.md#what-is-the-data-mapper-pattern) and [ActiveRecord](./docs/active-record-data-mapper.md#what-is-the-active-record-pattern) (your choice).
+-   Entities and columns.
+-   Database-specific column types.
+-   Entity manager.
+-   Repositories and custom repositories.
+-   Clean object relational model.
+-   Associations (relations).
+-   Eager and lazy relations.
+-   Uni-directional, bi-directional and self-referenced relations.
+-   Supports multiple inheritance patterns.
+-   Cascades.
+-   Indices.
+-   Transactions.
+-   Migrations and automatic migrations generation.
+-   Connection pooling.
+-   Replication.
+-   Using multiple database instances.
+-   Working with multiple databases types.
+-   Cross-database and cross-schema queries.
+-   Elegant-syntax, flexible and powerful QueryBuilder.
+-   Left and inner joins.
+-   Proper pagination for queries using joins.
+-   Query caching.
+-   Streaming raw results.
+-   Logging.
+-   Listeners and subscribers (hooks).
+-   Supports closure table pattern.
+-   Schema declaration in models or separate configuration files.
+-   Connection configuration in json / xml / yml / env formats.
+-   Supports MySQL / MariaDB / Postgres / CockroachDB / SQLite / Microsoft SQL Server / Oracle / SAP Hana / sql.js.
+-   Supports MongoDB NoSQL database.
+-   Works in NodeJS / Browser / Ionic / Cordova / React Native / NativeScript / Expo / Electron platforms.
+-   TypeScript and JavaScript support.
+-   ESM and CommonJS support.
+-   Produced code is performant, flexible, clean and maintainable.
+-   Follows all possible best practices.
+-   CLI.
 
 And more...
 
 With TypeORM your models look like this:
 
 ```javascript
-import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";
+import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"
 
 @Entity()
 export class User {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column()
-    firstName: string;
+    firstName: string
 
     @Column()
-    lastName: string;
+    lastName: string
 
     @Column()
-    age: number;
-
+    age: number
 }
 ```
 
 And your domain logic looks like this:
 
 ```javascript
-const repository = connection.getRepository(User);
+const userRepository = MyDataSource.getRepository(User)
 
-const user = new User();
-user.firstName = "Timber";
-user.lastName = "Saw";
-user.age = 25;
-await repository.save(user);
+const user = new User()
+user.firstName = "Timber"
+user.lastName = "Saw"
+user.age = 25
+await userRepository.save(user)
 
-const allUsers = await repository.find();
-const firstUser = await repository.findOne(1); // find by id
-const timber = await repository.findOne({ firstName: "Timber", lastName: "Saw" });
+const allUsers = await userRepository.find()
+const firstUser = await userRepository.findOneBy({
+    id: 1,
+}) // find by id
+const timber = await userRepository.findOneBy({
+    firstName: "Timber",
+    lastName: "Saw",
+}) // find by firstName and lastName
 
-await repository.remove(timber);
+await userRepository.remove(timber)
 ```
 
 Alternatively, if you prefer to use the `ActiveRecord` implementation, you can use it as well:
 
 ```javascript
-import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm";
+import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm"
 
 @Entity()
 export class User extends BaseEntity {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column()
-    firstName: string;
+    firstName: string
 
     @Column()
-    lastName: string;
+    lastName: string
 
     @Column()
-    age: number;
-
+    age: number
 }
 ```
 
 And your domain logic will look this way:
 
 ```javascript
-const user = new User();
-user.firstName = "Timber";
-user.lastName = "Saw";
-user.age = 25;
-await user.save();
-
-const allUsers = await User.find();
-const firstUser = await User.findOne(1);
-const timber = await User.findOne({ firstName: "Timber", lastName: "Saw" });
+const user = new User()
+user.firstName = "Timber"
+user.lastName = "Saw"
+user.age = 25
+await user.save()
+
+const allUsers = await User.find()
+const firstUser = await User.findOneBy({
+    id: 1,
+})
+const timber = await User.findOneBy({
+    firstName: "Timber",
+    lastName: "Saw"
+})
 
-await timber.remove();
+await timber.remove()
 ```
 
 ## Installation
 
-
 1. Install the npm package:
 
     `npm install typeorm --save`
@@ -171,7 +176,7 @@ await timber.remove();
 
     and import it somewhere in the global place of your app (for example in `app.ts`):
 
-    `import "reflect-metadata";`
+    `import "reflect-metadata"`
 
 3. You may need to install node typings:
 
@@ -179,56 +184,55 @@ await timber.remove();
 
 4. Install a database driver:
 
-    * for **MySQL** or **MariaDB**
+    - for **MySQL** or **MariaDB**
 
         `npm install mysql --save` (you can install `mysql2` instead as well)
 
-    * for **PostgreSQL** or **CockroachDB**
+    - for **PostgreSQL** or **CockroachDB**
 
         `npm install pg --save`
 
-    * for **SQLite**
+    - for **SQLite**
 
         `npm install sqlite3 --save`
 
-    * for **Microsoft SQL Server**
+    - for **Microsoft SQL Server**
 
         `npm install mssql --save`
 
-    * for **sql.js**
+    - for **sql.js**
 
         `npm install sql.js --save`
 
-    * for **Oracle**
+    - for **Oracle**
 
         `npm install oracledb --save`
 
         To make the Oracle driver work, you need to follow the installation instructions from
         [their](https://github.com/oracle/node-oracledb) site.
 
-    * for **SAP Hana**
+    - for **SAP Hana**
 
         ```
         npm i @sap/hana-client
-		npm i hdb-pool
+        npm i hdb-pool
         ```
 
-        *SAP Hana support made possible by the sponsorship of [Neptune Software](https://www.neptune-software.com/).*
+        _SAP Hana support made possible by the sponsorship of [Neptune Software](https://www.neptune-software.com/)._
 
-    * for **MongoDB** (experimental)
+    - for **MongoDB** (experimental)
 
         `npm install mongodb@^3.6.0 --save`
 
-    * for **NativeScript**, **react-native** and **Cordova**
+    - for **NativeScript**, **react-native** and **Cordova**
 
         Check [documentation of supported platforms](./docs/supported-platforms.md)
 
-    Install only *one* of them, depending on which database you use.
-
+    Install only _one_ of them, depending on which database you use.
 
 ##### TypeScript configuration
 
-Also, make sure you are using TypeScript version **3.3** or higher,
+Also, make sure you are using TypeScript version **4.5** or higher,
 and you have enabled the following settings in `tsconfig.json`:
 
 ```json
@@ -244,16 +248,10 @@ The quickest way to get started with TypeORM is to use its CLI commands to gener
 Quick start works only if you are using TypeORM in a NodeJS application.
 If you are using other platforms, proceed to the [step-by-step guide](#step-by-step-guide).
 
-First, install TypeORM globally:
-
-```
-npm install typeorm -g
-```
-
-Then go to the directory where you want to create a new project and run the command:
+To create a new project using CLI, run the follwing command:
 
-```
-typeorm init --name MyProject --database mysql
+```shell
+npx typeorm init --name MyProject --database postgres
 ```
 
 Where `name` is the name of your project and `database` is the database you'll use.
@@ -264,49 +262,43 @@ This command will generate a new project in the `MyProject` directory with the f
 
 ```
 MyProject
-├── src              // place of your TypeScript code
-│   ├── entity       // place where your entities (database models) are stored
-│   │   └── User.ts  // sample entity
-│   ├── migration    // place where your migrations are stored
-│   └── index.ts     // start point of your application
-├── .gitignore       // standard gitignore file
-├── ormconfig.json   // ORM and database connection configuration
-├── package.json     // node module dependencies
-├── README.md        // simple readme file
-└── tsconfig.json    // TypeScript compiler options
+├── src                   // place of your TypeScript code
+│   ├── entity            // place where your entities (database models) are stored
+│   │   └── User.ts       // sample entity
+│   ├── migration         // place where your migrations are stored
+│   ├── data-source.ts    // data source and all connection configuration
+│   └── index.ts          // start point of your application
+├── .gitignore            // standard gitignore file
+├── package.json          // node module dependencies
+├── README.md             // simple readme file
+└── tsconfig.json         // TypeScript compiler options
 ```
 
 > You can also run `typeorm init` on an existing node project, but be careful - it may override some files you already have.
 
 The next step is to install new project dependencies:
 
-```
+```shell
 cd MyProject
 npm install
 ```
 
-While installation is in progress, edit the `ormconfig.json` file and put your own database connection configuration options in there:
+After you have all dependencies installed, edit the `data-source.ts` file and put your own database connection configuration options in there:
 
-```json
-{
-   "type": "mysql",
-   "host": "localhost",
-   "port": 3306,
-   "username": "test",
-   "password": "test",
-   "database": "test",
-   "synchronize": true,
-   "logging": false,
-   "entities": [
-      "src/entity/**/*.ts"
-   ],
-   "migrations": [
-      "src/migration/**/*.ts"
-   ],
-   "subscribers": [
-      "src/subscriber/**/*.ts"
-   ]
-}
+```ts
+export const AppDataSource = new DataSource({
+    type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "test",
+    password: "test",
+    database: "test",
+    synchronize: true,
+    logging: true,
+    entities: [Post, Category],
+    subscribers: [],
+    migrations: [],
+})
 ```
 
 Particularly, most of the time you'll only need to configure
@@ -314,7 +306,7 @@ Particularly, most of the time you'll only need to configure
 
 Once you finish with configuration and all node modules are installed, you can run your application:
 
-```
+```shell
 npm start
 ```
 
@@ -323,13 +315,13 @@ You can continue to work with this project and integrate other modules you need
 creating more entities.
 
 > You can generate an ESM project by running
-`typeorm init --name MyProject --database postgres --module esm` command.
+> `npx typeorm init --name MyProject --database postgres --module esm` command.
 
 > You can generate an even more advanced project with express installed by running
-`typeorm init --name MyProject --database mysql --express` command.
+> `npx typeorm init --name MyProject --database mysql --express` command.
 
 > You can generate a docker-compose file by running
-`typeorm init --name MyProject --database postgres --docker` command.
+> `npx typeorm init --name MyProject --database postgres --docker` command.
 
 ## Step-by-Step Guide
 
@@ -350,46 +342,46 @@ For example, you have a `Photo` model:
 
 ```javascript
 export class Photo {
-    id: number;
-    name: string;
-    description: string;
-    filename: string;
-    views: number;
-    isPublished: boolean;
+    id: number
+    name: string
+    description: string
+    filename: string
+    views: number
+    isPublished: boolean
 }
 ```
 
 And you want to store photos in your database.
 To store things in the database, first, you need a database table,
 and database tables are created from your models.
-Not all models, but only those you define as *entities*.
+Not all models, but only those you define as _entities_.
 
 ### Create an entity
 
-*Entity* is your model decorated by an `@Entity` decorator.
+_Entity_ is your model decorated by an `@Entity` decorator.
 A database table will be created for such models.
-You work with entities everywhere with TypeORM.
+You work with entities everywhere in TypeORM.
 You can load/insert/update/remove and perform other operations with them.
 
-Let's make our `Photo` model as an entity:
+Let's make our `Photo` model an entity:
 
 ```javascript
-import { Entity } from "typeorm";
+import { Entity } from "typeorm"
 
 @Entity()
 export class Photo {
-    id: number;
-    name: string;
-    description: string;
-    filename: string;
-    views: number;
-    isPublished: boolean;
+    id: number
+    name: string
+    description: string
+    filename: string
+    views: number
+    isPublished: boolean
 }
 ```
 
 Now, a database table will be created for the `Photo` entity and we'll be able to work with it anywhere in our app.
 We have created a database table, however, what table can exist without columns?
-Let's create a few columns in our database table.
+Let's create few columns in our database table.
 
 ### Adding table columns
 
@@ -397,28 +389,27 @@ To add database columns, you simply need to decorate an entity's properties you
 with a `@Column` decorator.
 
 ```javascript
-import { Entity, Column } from "typeorm";
+import { Entity, Column } from "typeorm"
 
 @Entity()
 export class Photo {
-
     @Column()
-    id: number;
+    id: number
 
     @Column()
-    name: string;
+    name: string
 
     @Column()
-    description: string;
+    description: string
 
     @Column()
-    filename: string;
+    filename: string
 
     @Column()
-    views: number;
+    views: number
 
     @Column()
-    isPublished: boolean;
+    isPublished: boolean
 }
 ```
 
@@ -437,28 +428,27 @@ This is a requirement and you can't avoid it.
 To make a column a primary key, you need to use the `@PrimaryColumn` decorator.
 
 ```javascript
-import { Entity, Column, PrimaryColumn } from "typeorm";
+import { Entity, Column, PrimaryColumn } from "typeorm"
 
 @Entity()
 export class Photo {
-
     @PrimaryColumn()
-    id: number;
+    id: number
 
     @Column()
-    name: string;
+    name: string
 
     @Column()
-    description: string;
+    description: string
 
     @Column()
-    filename: string;
+    filename: string
 
     @Column()
-    views: number;
+    views: number
 
     @Column()
-    isPublished: boolean;
+    isPublished: boolean
 }
 ```
 
@@ -468,28 +458,27 @@ Now, let's say you want your id column to be auto-generated (this is known as au
 To do that, you need to change the `@PrimaryColumn` decorator to a `@PrimaryGeneratedColumn` decorator:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
+import { Entity, Column, PrimaryGeneratedColumn } from "typeorm"
 
 @Entity()
 export class Photo {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column()
-    name: string;
+    name: string
 
     @Column()
-    description: string;
+    description: string
 
     @Column()
-    filename: string;
+    filename: string
 
     @Column()
-    views: number;
+    views: number
 
     @Column()
-    isPublished: boolean;
+    isPublished: boolean
 }
 ```
 
@@ -501,30 +490,29 @@ We don't want all our columns to be limited varchars or integers.
 Let's setup correct data types:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
+import { Entity, Column, PrimaryGeneratedColumn } from "typeorm"
 
 @Entity()
 export class Photo {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column({
-        length: 100
+        length: 100,
     })
-    name: string;
+    name: string
 
     @Column("text")
-    description: string;
+    description: string
 
     @Column()
-    filename: string;
+    filename: string
 
     @Column("double")
-    views: number;
+    views: number
 
     @Column()
-    isPublished: boolean;
+    isPublished: boolean
 }
 ```
 
@@ -532,79 +520,52 @@ Column types are database-specific.
 You can set any column type your database supports.
 More information on supported column types can be found [here](./docs/entities.md#column-types).
 
-### Creating a connection to the database
+### Creating a new `DataSource`
 
-Now, when our entity is created, let's create an `index.ts` (or `app.ts` whatever you call it) file and set up our connection there:
+Now, when our entity is created, let's create `index.ts` file and set up our `DataSource` there:
 
 ```javascript
-import "reflect-metadata";
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
+import "reflect-metadata"
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
 
-createConnection({
-    type: "mysql",
+const AppDataSource = new DataSource({
+    type: "postgres",
     host: "localhost",
-    port: 3306,
+    port: 5432,
     username: "root",
     password: "admin",
     database: "test",
-    entities: [
-        Photo
-    ],
+    entities: [Photo],
     synchronize: true,
-    logging: false
-}).then(connection => {
-    // here you can start to work with your entities
-}).catch(error => console.log(error));
+    logging: false,
+})
+
+// to initialize initial connection with the database, register all entities
+// and "synchronize" database schema, call "initialize()" method of a newly created database
+// once in your application bootstrap
+AppDataSource.initialize()
+    .then(() => {
+        // here you can start to work with your database
+    })
+    .catch((error) => console.log(error))
 ```
 
-We are using MySQL in this example, but you can use any other supported database.
+We are using Postgres in this example, but you can use any other supported database.
 To use another database, simply change the `type` in the options to the database type you are using:
 `mysql`, `mariadb`, `postgres`, `cockroachdb`, `sqlite`, `mssql`, `oracle`, `cordova`, `nativescript`, `react-native`,
 `expo`, or `mongodb`.
 Also make sure to use your own host, port, username, password and database settings.
 
-We added our Photo entity to the list of entities for this connection.
+We added our Photo entity to the list of entities for this data source.
 Each entity you are using in your connection must be listed there.
 
 Setting `synchronize` makes sure your entities will be synced with the database, every time you run the application.
 
-### Loading all entities from the directory
-
-Later, when we create more entities we need to add them to the entities in our configuration.
-This is not very convenient, so instead, we can set up the whole directory, from where all entities will be connected and used in our connection:
-
-```javascript
-import { createConnection } from "typeorm";
-
-createConnection({
-    type: "mysql",
-    host: "localhost",
-    port: 3306,
-    username: "root",
-    password: "admin",
-    database: "test",
-    entities: [
-        __dirname + "/entity/*.js"
-    ],
-    synchronize: true,
-}).then(connection => {
-    // here you can start to work with your entities
-}).catch(error => console.log(error));
-```
-
-But be careful with this approach.
-If you are using `ts-node` then you need to specify paths to `.ts` files instead.
-If you are using `outDir` then you'll need to specify paths to `.js` files inside the outDir directory.
-If you are using `outDir` and when you remove or rename your entities make sure to clear `outDir` directory
-and re-compile your project again, because when you remove your source `.ts` files their compiled `.js` versions
-aren't removed from output directory and still are loaded by TypeORM because they are present in the `outDir` directory.
-
 ### Running the application
 
 Now if you run your `index.ts`, a connection with the database will be initialized and a database table for your photos will be created.
 
-
 ```shell
 +-------------+--------------+----------------------------+
 |                         photo                           |
@@ -623,54 +584,25 @@ Now if you run your `index.ts`, a connection with the database will be initializ
 Now let's create a new photo to save it in the database:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(connection => {
-
-    let photo = new Photo();
-    photo.name = "Me and Bears";
-    photo.description = "I am near polar bears";
-    photo.filename = "photo-with-bears.jpg";
-    photo.views = 1;
-    photo.isPublished = true;
-
-    return connection.manager
-            .save(photo)
-            .then(photo => {
-                console.log("Photo has been saved. Photo id is", photo.id);
-            });
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
+
+const photo = new Photo()
+photo.name = "Me and Bears"
+photo.description = "I am near polar bears"
+photo.filename = "photo-with-bears.jpg"
+photo.views = 1
+photo.isPublished = true
 
-}).catch(error => console.log(error));
+await AppDataSource.manager.save(photo)
+console.log("Photo has been saved. Photo id is", photo.id)
 ```
 
 Once your entity is saved it will get a newly generated id.
 `save` method returns an instance of the same object you pass to it.
 It's not a new copy of the object, it modifies its "id" and returns it.
 
-### Using async/await syntax
-
-Let's take advantage of the latest ES8 (ES2017) features and use async/await syntax instead:
-
-```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(async connection => {
-
-    let photo = new Photo();
-    photo.name = "Me and Bears";
-    photo.description = "I am near polar bears";
-    photo.filename = "photo-with-bears.jpg";
-    photo.views = 1;
-    photo.isPublished = true;
-
-    await connection.manager.save(photo);
-    console.log("Photo has been saved");
-
-}).catch(error => console.log(error));
-```
-
 ### Using Entity Manager
 
 We just created a new photo and saved it in the database.
@@ -679,16 +611,12 @@ Using entity manager you can manipulate any entity in your app.
 For example, let's load our saved entity:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(async connection => {
-
-    /*...*/
-    let savedPhotos = await connection.manager.find(Photo);
-    console.log("All photos from the db: ", savedPhotos);
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
 
-}).catch(error => console.log(error));
+const savedPhotos = await AppDataSource.manager.find(Photo)
+console.log("All photos from the db: ", savedPhotos)
 ```
 
 `savedPhotos` will be an array of Photo objects with the data loaded from the database.
@@ -701,29 +629,25 @@ Now let's refactor our code and use `Repository` instead of `EntityManager`.
 Each entity has its own repository which handles all operations with its entity.
 When you deal with entities a lot, Repositories are more convenient to use than EntityManagers:
 
-
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(async connection => {
-
-    let photo = new Photo();
-    photo.name = "Me and Bears";
-    photo.description = "I am near polar bears";
-    photo.filename = "photo-with-bears.jpg";
-    photo.views = 1;
-    photo.isPublished = true;
-
-    let photoRepository = connection.getRepository(Photo);
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
+
+const photo = new Photo()
+photo.name = "Me and Bears"
+photo.description = "I am near polar bears"
+photo.filename = "photo-with-bears.jpg"
+photo.views = 1
+photo.isPublished = true
 
-    await photoRepository.save(photo);
-    console.log("Photo has been saved");
+const photoRepository = AppDataSource.getRepository(Photo)
 
-    let savedPhotos = await photoRepository.find();
-    console.log("All photos from the db: ", savedPhotos);
+await photoRepository.save(photo)
+console.log("Photo has been saved")
 
-}).catch(error => console.log(error));
+const savedPhotos = await photoRepository.find()
+console.log("All photos from the db: ", savedPhotos)
 ```
 
 Learn more about Repository [here](./docs/working-with-repository.md).
@@ -733,32 +657,32 @@ Learn more about Repository [here](./docs/working-with-repository.md).
 Let's try more load operations using the Repository:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
 
-createConnection(/*...*/).then(async connection => {
+const allPhotos = await photoRepository.find()
+console.log("All photos from the db: ", allPhotos)
 
-    /*...*/
-    let allPhotos = await photoRepository.find();
-    console.log("All photos from the db: ", allPhotos);
-
-    let firstPhoto = await photoRepository.findOne(1);
-    console.log("First photo from the db: ", firstPhoto);
-
-    let meAndBearsPhoto = await photoRepository.findOne({ name: "Me and Bears" });
-    console.log("Me and Bears photo from the db: ", meAndBearsPhoto);
+const firstPhoto = await photoRepository.findOneBy({
+    id: 1,
+})
+console.log("First photo from the db: ", firstPhoto)
 
-    let allViewedPhotos = await photoRepository.find({ views: 1 });
-    console.log("All viewed photos: ", allViewedPhotos);
+const meAndBearsPhoto = await photoRepository.findOneBy({
+    name: "Me and Bears",
+})
+console.log("Me and Bears photo from the db: ", meAndBearsPhoto)
 
-    let allPublishedPhotos = await photoRepository.find({ isPublished: true });
-    console.log("All published photos: ", allPublishedPhotos);
+const allViewedPhotos = await photoRepository.findBy({ views: 1 })
+console.log("All viewed photos: ", allViewedPhotos)
 
-    let [allPhotos, photosCount] = await photoRepository.findAndCount();
-    console.log("All photos: ", allPhotos);
-    console.log("Photos count: ", photosCount);
+const allPublishedPhotos = await photoRepository.findBy({ isPublished: true })
+console.log("All published photos: ", allPublishedPhotos)
 
-}).catch(error => console.log(error));
+const [photos, photosCount] = await photoRepository.findAndCount()
+console.log("All photos: ", photos)
+console.log("Photos count: ", photosCount)
 ```
 
 ### Updating in the database
@@ -766,17 +690,16 @@ createConnection(/*...*/).then(async connection => {
 Now let's load a single photo from the database, update it and save it:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(async connection => {
-
-    /*...*/
-    let photoToUpdate = await photoRepository.findOne(1);
-    photoToUpdate.name = "Me, my friends and polar bears";
-    await photoRepository.save(photoToUpdate);
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
 
-}).catch(error => console.log(error));
+const photoRepository = AppDataSource.getRepository(Photo)
+const photoToUpdate = await photoRepository.findOneBy({
+    id: 1,
+})
+photoToUpdate.name = "Me, my friends and polar bears"
+await photoRepository.save(photoToUpdate)
 ```
 
 Now photo with `id = 1` will be updated in the database.
@@ -786,16 +709,15 @@ Now photo with `id = 1` will be updated in the database.
 Now let's remove our photo from the database:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-
-createConnection(/*...*/).then(async connection => {
-
-    /*...*/
-    let photoToRemove = await photoRepository.findOne(1);
-    await photoRepository.remove(photoToRemove);
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { AppDataSource } from "./index"
 
-}).catch(error => console.log(error));
+const photoRepository = AppDataSource.getRepository(Photo)
+const photoToRemove = await photoRepository.findOneBy({
+    id: 1,
+})
+await photoRepository.remove(photoToRemove)
 ```
 
 Now photo with `id = 1` will be removed from the database.
@@ -806,33 +728,38 @@ Let's create a one-to-one relationship with another class.
 Let's create a new class in `PhotoMetadata.ts`. This PhotoMetadata class is supposed to contain our photo's additional meta-information:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn } from "typeorm";
-import { Photo } from "./Photo";
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToOne,
+    JoinColumn,
+} from "typeorm"
+import { Photo } from "./Photo"
 
 @Entity()
 export class PhotoMetadata {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column("int")
-    height: number;
+    height: number
 
     @Column("int")
-    width: number;
+    width: number
 
     @Column()
-    orientation: string;
+    orientation: string
 
     @Column()
-    compressed: boolean;
+    compressed: boolean
 
     @Column()
-    comment: string;
+    comment: string
 
-    @OneToOne(type => Photo)
+    @OneToOne(() => Photo)
     @JoinColumn()
-    photo: Photo;
+    photo: Photo
 }
 ```
 
@@ -868,43 +795,41 @@ If you run the app, you'll see a newly generated table, and it will contain a co
 Now let's save a photo, its metadata and attach them to each other.
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-import { PhotoMetadata } from "./entity/PhotoMetadata";
-
-createConnection(/*...*/).then(async connection => {
-
-    // create a photo
-    let photo = new Photo();
-    photo.name = "Me and Bears";
-    photo.description = "I am near polar bears";
-    photo.filename = "photo-with-bears.jpg";
-    photo.views = 1;
-    photo.isPublished = true;
-
-    // create a photo metadata
-    let metadata = new PhotoMetadata();
-    metadata.height = 640;
-    metadata.width = 480;
-    metadata.compressed = true;
-    metadata.comment = "cybershoot";
-    metadata.orientation = "portrait";
-    metadata.photo = photo; // this way we connect them
-
-    // get entity repositories
-    let photoRepository = connection.getRepository(Photo);
-    let metadataRepository = connection.getRepository(PhotoMetadata);
-
-    // first we should save a photo
-    await photoRepository.save(photo);
-
-    // photo is saved. Now we need to save a photo metadata
-    await metadataRepository.save(metadata);
-
-    // done
-    console.log("Metadata is saved, and the relation between metadata and photo is created in the database too");
-
-}).catch(error => console.log(error));
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { PhotoMetadata } from "./entity/PhotoMetadata"
+
+// create a photo
+const photo = new Photo()
+photo.name = "Me and Bears"
+photo.description = "I am near polar bears"
+photo.filename = "photo-with-bears.jpg"
+photo.views = 1
+photo.isPublished = true
+
+// create a photo metadata
+const metadata = new PhotoMetadata()
+metadata.height = 640
+metadata.width = 480
+metadata.compressed = true
+metadata.comment = "cybershoot"
+metadata.orientation = "portrait"
+metadata.photo = photo // this way we connect them
+
+// get entity repositories
+const photoRepository = AppDataSource.getRepository(Photo)
+const metadataRepository = AppDataSource.getRepository(PhotoMetadata)
+
+// first we should save a photo
+await photoRepository.save(photo)
+
+// photo is saved. Now we need to save a photo metadata
+await metadataRepository.save(metadata)
+
+// done
+console.log(
+    "Metadata is saved, and the relation between metadata and photo is created in the database too",
+)
 ```
 
 ### Inverse side of the relationship
@@ -917,31 +842,35 @@ To fix this issue we should add an inverse relation, and make relations between
 Let's modify our entities:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn } from "typeorm";
-import { Photo } from "./Photo";
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToOne,
+    JoinColumn,
+} from "typeorm"
+import { Photo } from "./Photo"
 
 @Entity()
 export class PhotoMetadata {
-
     /* ... other columns */
 
-    @OneToOne(type => Photo, photo => photo.metadata)
+    @OneToOne(() => Photo, (photo) => photo.metadata)
     @JoinColumn()
-    photo: Photo;
+    photo: Photo
 }
 ```
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne } from "typeorm";
-import { PhotoMetadata } from "./PhotoMetadata";
+import { Entity, Column, PrimaryGeneratedColumn, OneToOne } from "typeorm"
+import { PhotoMetadata } from "./PhotoMetadata"
 
 @Entity()
 export class Photo {
-
     /* ... other columns */
 
-    @OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)
-    metadata: PhotoMetadata;
+    @OneToOne(() => PhotoMetadata, (photoMetadata) => photoMetadata.photo)
+    metadata: PhotoMetadata
 }
 ```
 
@@ -960,31 +889,42 @@ If you use ESM in your TypeScript project, you should use the `Relation` wrapper
 Let's modify our entities:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, Relation } from "typeorm";
-import { Photo } from "./Photo";
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToOne,
+    JoinColumn,
+    Relation,
+} from "typeorm"
+import { Photo } from "./Photo"
 
 @Entity()
 export class PhotoMetadata {
-
     /* ... other columns */
 
-    @OneToOne(type => Photo, photo => photo.metadata)
+    @OneToOne(() => Photo, (photo) => photo.metadata)
     @JoinColumn()
-    photo: Relation<Photo>;
+    photo: Relation<Photo>
 }
 ```
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToOne, Relation } from "typeorm";
-import { PhotoMetadata } from "./PhotoMetadata";
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToOne,
+    Relation,
+} from "typeorm"
+import { PhotoMetadata } from "./PhotoMetadata"
 
 @Entity()
 export class Photo {
-
     /* ... other columns */
 
-    @OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)
-    metadata: Relation<PhotoMetadata>;
+    @OneToOne(() => PhotoMetadata, (photoMetadata) => photoMetadata.photo)
+    metadata: Relation<PhotoMetadata>
 }
 ```
 
@@ -996,17 +936,17 @@ Let's use `find*` methods first.
 `find*` methods allow you to specify an object with the `FindOneOptions` / `FindManyOptions` interface.
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-import { PhotoMetadata } from "./entity/PhotoMetadata";
-
-createConnection(/*...*/).then(async connection => {
-
-    /*...*/
-    let photoRepository = connection.getRepository(Photo);
-    let photos = await photoRepository.find({ relations: ["metadata"] });
-
-}).catch(error => console.log(error));
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { PhotoMetadata } from "./entity/PhotoMetadata"
+import { AppDataSource } from "./index"
+
+const photoRepository = AppDataSource.getRepository(Photo)
+const photos = await photoRepository.find({
+    relations: {
+        metadata: true,
+    },
+})
 ```
 
 Here, photos will contain an array of photos from the database, and each photo will contain its photo metadata.
@@ -1016,21 +956,15 @@ Using find options is good and dead simple, but if you need a more complex query
 `QueryBuilder` allows more complex queries to be used in an elegant way:
 
 ```javascript
-import { createConnection } from "typeorm";
-import { Photo } from "./entity/Photo";
-import { PhotoMetadata } from "./entity/PhotoMetadata";
+import { DataSource } from "typeorm"
+import { Photo } from "./entity/Photo"
+import { PhotoMetadata } from "./entity/PhotoMetadata"
+import { AppDataSource } from "./index"
 
-createConnection(/*...*/).then(async connection => {
-
-    /*...*/
-    let photos = await connection
-            .getRepository(Photo)
-            .createQueryBuilder("photo")
-            .innerJoinAndSelect("photo.metadata", "metadata")
-            .getMany();
-
-
-}).catch(error => console.log(error));
+const photos = await AppDataSource.getRepository(Photo)
+    .createQueryBuilder("photo")
+    .innerJoinAndSelect("photo.metadata", "metadata")
+    .getMany()
 ```
 
 `QueryBuilder` allows the creation and execution of SQL queries of almost any complexity.
@@ -1047,10 +981,10 @@ Let's change our photo's `@OneToOne` decorator a bit:
 export class Photo {
     /// ... other columns
 
-    @OneToOne(type => PhotoMetadata, metadata => metadata.photo, {
+    @OneToOne(() => PhotoMetadata, (metadata) => metadata.photo, {
         cascade: true,
     })
-    metadata: PhotoMetadata;
+    metadata: PhotoMetadata
 }
 ```
 
@@ -1058,34 +992,32 @@ Using `cascade` allows us not to separately save photo and separately save metad
 Now we can simply save a photo object, and the metadata object will be saved automatically because of cascade options.
 
 ```javascript
-createConnection(options).then(async connection => {
-
-    // create photo object
-    let photo = new Photo();
-    photo.name = "Me and Bears";
-    photo.description = "I am near polar bears";
-    photo.filename = "photo-with-bears.jpg";
-    photo.isPublished = true;
+import { AppDataSource } from "./index"
 
-    // create photo metadata object
-    let metadata = new PhotoMetadata();
-    metadata.height = 640;
-    metadata.width = 480;
-    metadata.compressed = true;
-    metadata.comment = "cybershoot";
-    metadata.orientation = "portrait";
+// create photo object
+const photo = new Photo()
+photo.name = "Me and Bears"
+photo.description = "I am near polar bears"
+photo.filename = "photo-with-bears.jpg"
+photo.isPublished = true
 
-    photo.metadata = metadata; // this way we connect them
+// create photo metadata object
+const metadata = new PhotoMetadata()
+metadata.height = 640
+metadata.width = 480
+metadata.compressed = true
+metadata.comment = "cybershoot"
+metadata.orientation = "portrait"
 
-    // get repository
-    let photoRepository = connection.getRepository(Photo);
+photo.metadata = metadata // this way we connect them
 
-    // saving a photo also save the metadata
-    await photoRepository.save(photo);
+// get repository
+const photoRepository = AppDataSource.getRepository(Photo)
 
-    console.log("Photo is saved, photo metadata is saved too.")
+// saving a photo also save the metadata
+await photoRepository.save(photo)
 
-}).catch(error => console.log(error));
+console.log("Photo is saved, photo metadata is saved too.")
 ```
 
 Notice that we now set the photo's `metadata` property, instead of the metadata's `photo` property as before. The `cascade` feature only works if you connect the photo to its metadata from the photo's side. If you set the metadata's side, the metadata would not be saved automatically.
@@ -1097,20 +1029,25 @@ Let's say a photo has one author, and each author can have many photos.
 First, let's create an `Author` class:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, OneToMany, JoinColumn } from "typeorm";
-import { Photo } from "./Photo";
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToMany,
+    JoinColumn,
+} from "typeorm"
+import { Photo } from "./Photo"
 
 @Entity()
 export class Author {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column()
-    name: string;
+    name: string
 
-    @OneToMany(type => Photo, photo => photo.author) // note: we will create author property in the Photo class below
-    photos: Photo[];
+    @OneToMany(() => Photo, (photo) => photo.author) // note: we will create author property in the Photo class below
+    photos: Photo[]
 }
 ```
 
@@ -1120,17 +1057,16 @@ export class Author {
 Now let's add the owner side of the relation into the Photo entity:
 
 ```javascript
-import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from "typeorm";
-import { PhotoMetadata } from "./PhotoMetadata";
-import { Author } from "./Author";
+import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from "typeorm"
+import { PhotoMetadata } from "./PhotoMetadata"
+import { Author } from "./Author"
 
 @Entity()
 export class Photo {
-
     /* ... other columns */
 
-    @ManyToOne(type => Author, author => author.photos)
-    author: Author;
+    @ManyToOne(() => Author, (author) => author.photos)
+    author: Author
 }
 ```
 
@@ -1139,7 +1075,6 @@ It means that the class that uses `@ManyToOne` will store the id of the related
 
 After you run the application, the ORM will create the `author` table:
 
-
 ```shell
 +-------------+--------------+----------------------------+
 |                          author                         |
@@ -1171,20 +1106,25 @@ Let's say a photo can be in many albums, and each album can contain many photos.
 Let's create an `Album` class:
 
 ```javascript
-import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from "typeorm";
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ManyToMany,
+    JoinTable,
+} from "typeorm"
 
 @Entity()
 export class Album {
-
     @PrimaryGeneratedColumn()
-    id: number;
+    id: number
 
     @Column()
-    name: string;
+    name: string
 
-    @ManyToMany(type => Photo, photo => photo.albums)
+    @ManyToMany(() => Photo, (photo) => photo.albums)
     @JoinTable()
-    photos: Photo[];
+    photos: Photo[]
 }
 ```
 
@@ -1196,12 +1136,12 @@ Now let's add the inverse side of our relation to the `Photo` class:
 export class Photo {
     /// ... other columns
 
-    @ManyToMany(type => Album, album => album.photos)
-    albums: Album[];
+    @ManyToMany(() => Album, (album) => album.photos)
+    albums: Album[]
 }
 ```
 
-After you run the application, the ORM will create a **album_photos_photo_albums** *junction table*:
+After you run the application, the ORM will create a **album_photos_photo_albums** _junction table_:
 
 ```shell
 +-------------+--------------+----------------------------+
@@ -1215,41 +1155,46 @@ After you run the application, the ORM will create a **album_photos_photo_albums
 Don't forget to register the `Album` class with your connection in the ORM:
 
 ```javascript
-const options: ConnectionOptions = {
+const options: DataSourceOptions = {
     // ... other options
-    entities: [Photo, PhotoMetadata, Author, Album]
-};
+    entities: [Photo, PhotoMetadata, Author, Album],
+}
 ```
 
 Now let's insert albums and photos to our database:
 
 ```javascript
-let connection = await createConnection(options);
+import { AppDataSource } from "./index"
 
 // create a few albums
-let album1 = new Album();
-album1.name = "Bears";
-await connection.manager.save(album1);
+const album1 = new Album()
+album1.name = "Bears"
+await AppDataSource.manager.save(album1)
 
-let album2 = new Album();
-album2.name = "Me";
-await connection.manager.save(album2);
+const album2 = new Album()
+album2.name = "Me"
+await AppDataSource.manager.save(album2)
 
 // create a few photos
-let photo = new Photo();
-photo.name = "Me and Bears";
-photo.description = "I am near polar bears";
-photo.filename = "photo-with-bears.jpg";
+const photo = new Photo()
+photo.name = "Me and Bears"
+photo.description = "I am near polar bears"
+photo.filename = "photo-with-bears.jpg"
 photo.views = 1
 photo.isPublished = true
-photo.albums = [album1, album2];
-await connection.manager.save(photo);
+photo.albums = [album1, album2]
+await AppDataSource.manager.save(photo)
 
 // now our photo is saved and albums are attached to it
 // now lets load them:
-const loadedPhoto = await connection
-    .getRepository(Photo)
-    .findOne(1, { relations: ["albums"] });
+const loadedPhoto = await AppDataSource.getRepository(Photo).findOne({
+    where: {
+        id: 1,
+    },
+    relations: {
+        albums: true,
+    },
+})
 ```
 
 `loadedPhoto` will be equal to:
@@ -1275,8 +1220,7 @@ const loadedPhoto = await connection
 You can use QueryBuilder to build SQL queries of almost any complexity. For example, you can do this:
 
 ```javascript
-let photos = await connection
-    .getRepository(Photo)
+const photos = await AppDataSource.getRepository(Photo)
     .createQueryBuilder("photo") // first argument is an alias. Alias is what you are selecting - photos. You must specify it.
     .innerJoinAndSelect("photo.metadata", "metadata")
     .leftJoinAndSelect("photo.albums", "album")
@@ -1286,7 +1230,7 @@ let photos = await connection
     .skip(5)
     .take(10)
     .setParameters({ photoName: "My", bearName: "Mishka" })
-    .getMany();
+    .getMany()
 ```
 
 This query selects all published photos with "My" or "Mishka" names.
@@ -1304,33 +1248,33 @@ Take a look at the samples in [sample](https://github.com/typeorm/typeorm/tree/m
 
 There are a few repositories which you can clone and start with:
 
-* [Example how to use TypeORM with TypeScript](https://github.com/typeorm/typescript-example)
-* [Example how to use TypeORM with JavaScript](https://github.com/typeorm/javascript-example)
-* [Example how to use TypeORM with JavaScript and Babel](https://github.com/typeorm/babel-example)
-* [Example how to use TypeORM with TypeScript and SystemJS in Browser](https://github.com/typeorm/browser-example)
-* [Example how to use TypeORM with TypeScript and React in Browser](https://github.com/ItayGarin/typeorm-react-swc)
-* [Example how to use Express and TypeORM](https://github.com/typeorm/typescript-express-example)
-* [Example how to use Koa and TypeORM](https://github.com/typeorm/typescript-koa-example)
-* [Example how to use TypeORM with MongoDB](https://github.com/typeorm/mongo-typescript-example)
-* [Example how to use TypeORM in a Cordova/PhoneGap app](https://github.com/typeorm/cordova-example)
-* [Example how to use TypeORM with an Ionic app](https://github.com/typeorm/ionic-example)
-* [Example how to use TypeORM with React Native](https://github.com/typeorm/react-native-example)
-* [Example how to use TypeORM with Nativescript-Vue](https://github.com/typeorm/nativescript-vue-typeorm-sample)
-* [Example how to use TypeORM with Nativescript-Angular](https://github.com/betov18x/nativescript-angular-typeorm-example)
-* [Example how to use TypeORM with Electron using JavaScript](https://github.com/typeorm/electron-javascript-example)
-* [Example how to use TypeORM with Electron using TypeScript](https://github.com/typeorm/electron-typescript-example)
+-   [Example how to use TypeORM with TypeScript](https://github.com/typeorm/typescript-example)
+-   [Example how to use TypeORM with JavaScript](https://github.com/typeorm/javascript-example)
+-   [Example how to use TypeORM with JavaScript and Babel](https://github.com/typeorm/babel-example)
+-   [Example how to use TypeORM with TypeScript and SystemJS in Browser](https://github.com/typeorm/browser-example)
+-   [Example how to use TypeORM with TypeScript and React in Browser](https://github.com/ItayGarin/typeorm-react-swc)
+-   [Example how to use Express and TypeORM](https://github.com/typeorm/typescript-express-example)
+-   [Example how to use Koa and TypeORM](https://github.com/typeorm/typescript-koa-example)
+-   [Example how to use TypeORM with MongoDB](https://github.com/typeorm/mongo-typescript-example)
+-   [Example how to use TypeORM in a Cordova/PhoneGap app](https://github.com/typeorm/cordova-example)
+-   [Example how to use TypeORM with an Ionic app](https://github.com/typeorm/ionic-example)
+-   [Example how to use TypeORM with React Native](https://github.com/typeorm/react-native-example)
+-   [Example how to use TypeORM with Nativescript-Vue](https://github.com/typeorm/nativescript-vue-typeorm-sample)
+-   [Example how to use TypeORM with Nativescript-Angular](https://github.com/betov18x/nativescript-angular-typeorm-example)
+-   [Example how to use TypeORM with Electron using JavaScript](https://github.com/typeorm/electron-javascript-example)
+-   [Example how to use TypeORM with Electron using TypeScript](https://github.com/typeorm/electron-typescript-example)
 
 ## Extensions
 
 There are several extensions that simplify working with TypeORM and integrating it with other modules:
 
-* [TypeORM + GraphQL framework](http://vesper-framework.com)
-* [TypeORM integration](https://github.com/typeorm/typeorm-typedi-extensions) with [TypeDI](https://github.com/pleerock/typedi)
-* [TypeORM integration](https://github.com/typeorm/typeorm-routing-controllers-extensions) with [routing-controllers](https://github.com/pleerock/routing-controllers)
-* Models generation from existing database - [typeorm-model-generator](https://github.com/Kononnable/typeorm-model-generator)
-* Fixtures loader - [typeorm-fixtures-cli](https://github.com/RobinCK/typeorm-fixtures)
-* ER Diagram generator - [typeorm-uml](https://github.com/eugene-manuilov/typeorm-uml/)
-* Create/Drop database - [typeorm-extension](https://github.com/Tada5hi/typeorm-extension)
+-   [TypeORM + GraphQL framework](http://vesper-framework.com)
+-   [TypeORM integration](https://github.com/typeorm/typeorm-typedi-extensions) with [TypeDI](https://github.com/pleerock/typedi)
+-   [TypeORM integration](https://github.com/typeorm/typeorm-routing-controllers-extensions) with [routing-controllers](https://github.com/pleerock/routing-controllers)
+-   Models generation from existing database - [typeorm-model-generator](https://github.com/Kononnable/typeorm-model-generator)
+-   Fixtures loader - [typeorm-fixtures-cli](https://github.com/RobinCK/typeorm-fixtures)
+-   ER Diagram generator - [typeorm-uml](https://github.com/eugene-manuilov/typeorm-uml/)
+-   Create/Drop database - [typeorm-extension](https://github.com/Tada5hi/typeorm-extension)
 
 ## Contributing