typeorm 0.3.0-rc.2 → 0.3.0-rc.23

package/README.md

@@ -4,19 +4,16 @@
   </a>
   <br>
   <br>
-	<a href="https://travis-ci.org/typeorm/typeorm">
-		<img src="https://travis-ci.org/typeorm/typeorm.svg?branch=master">
+	<a href="https://app.circleci.com/pipelines/github/typeorm/typeorm">
+		<img src="https://circleci.com/gh/typeorm/typeorm/tree/master.svg?style=shield">
 	</a>
 	<a href="https://badge.fury.io/js/typeorm">
 		<img src="https://badge.fury.io/js/typeorm.svg">
 	</a>
-	<a href="https://david-dm.org/typeorm/typeorm">
-		<img src="https://david-dm.org/typeorm/typeorm.svg">
-	</a>
     <a href="https://codecov.io/gh/typeorm/typeorm">
         <img alt="Codecov" src="https://img.shields.io/codecov/c/github/typeorm/typeorm.svg">
     </a>
-	<a href="https://join.slack.com/t/typeorm/shared_invite/enQtNDQ1MzA3MDA5MTExLTUxNTZhM2Q4NDNhMjMzNjQ2NGM1ZjI1ZGRkNjJjYzI4OTZjMGYyYTc0MzAxYTdjMWE3ZDIxOWUzZTdlM2QxNTY">
+	<a href="https://join.slack.com/t/typeorm/shared_invite/zt-uu12ljeb-OH_0086I379fUDApYJHNuw">
 		<img src="https://img.shields.io/badge/chat-on%20slack-blue.svg">
 	</a>
   <br>
@@ -39,51 +36,52 @@ 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).
 
-Some TypeORM 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 / sql.js
-* supports MongoDB NoSQL database
-* works in NodeJS / Browser / Ionic / Cordova / React Native / NativeScript / Expo / Electron platforms
-* TypeScript and JavaScript support
-* produced code is performant, flexible, clean and maintainable
-* follows all possible best practices
-* CLI
+## 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.
 
 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 {
@@ -106,6 +104,8 @@ export class User {
 And your domain logic looks like this:
 
 ```javascript
+const repository = connection.getRepository(User);
+
 const user = new User();
 user.firstName = "Timber";
 user.lastName = "Saw";
@@ -122,7 +122,7 @@ await repository.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 {
@@ -175,7 +175,7 @@ await timber.remove();
 
 3. You may need to install node typings:
 
-    `npm install @types/node --save`
+    `npm install @types/node --save-dev`
 
 4. Install a database driver:
 
@@ -203,24 +203,32 @@ await timber.remove();
 
         `npm install oracledb --save`
 
-        Install only *one* of them, depending on which database you use.
-
         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**
+
+        ```
+        npm i @sap/hana-client
+		npm i hdb-pool
+        ```
+
+        *SAP Hana support made possible by the sponsorship of [Neptune Software](https://www.neptune-software.com/).*
+
     * for **MongoDB** (experimental)
 
-        `npm install mongodb --save`
+        `npm install mongodb@^3.6.0 --save`
 
     * 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.
 
 
 ##### TypeScript configuration
 
-Also, make sure you are using TypeScript compiler version **3.3** or greater,
+Also, make sure you are using TypeScript version **3.3** or higher,
 and you have enabled the following settings in `tsconfig.json`:
 
 ```json
@@ -314,16 +322,22 @@ That's it, your application should successfully run and insert a new user into t
 You can continue to work with this project and integrate other modules you need and start
 creating more entities.
 
+> You can generate an ESM project by running
+`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.
 
+> You can generate a docker-compose file by running
+`typeorm init --name MyProject --database postgres --docker` command.
+
 ## Step-by-Step Guide
 
 What are you expecting from ORM?
 First of all, you are expecting it will create database tables for you
 and find / insert / update / delete your data without the pain of
 having to write lots of hardly maintainable SQL queries.
-This guide will show you how to setup TypeORM from scratch and make it do what you are expecting from an ORM.
+This guide will show you how to set up TypeORM from scratch and make it do what you are expecting from an ORM.
 
 ### Create a model
 
@@ -346,7 +360,7 @@ export class Photo {
 ```
 
 And you want to store photos in your database.
-To store things in the database, first you need a database table,
+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*.
 
@@ -360,7 +374,7 @@ You can load/insert/update/remove and perform other operations with them.
 Let's make our `Photo` model as an entity:
 
 ```javascript
-import {Entity} from "typeorm";
+import { Entity } from "typeorm";
 
 @Entity()
 export class Photo {
@@ -374,7 +388,7 @@ export class Photo {
 ```
 
 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?
+We have created a database table, however, what table can exist without columns?
 Let's create a few columns in our database table.
 
 ### Adding table columns
@@ -383,7 +397,7 @@ 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 {
@@ -411,7 +425,7 @@ export class Photo {
 Now `id`, `name`, `description`, `filename`, `views` and `isPublished` columns will be added to the `photo` table.
 Column types in the database are inferred from the property types you used, e.g.
 `number` will be converted into `integer`, `string` into `varchar`, `boolean` into `bool`, etc.
-But you can use any column type your database supports by implicitly specifying a column type into the `@Column` decorator.
+But you can use any column type your database supports by explicitly specifying a column type into the `@Column` decorator.
 
 We generated a database table with columns, but there is one thing left.
 Each database table must have a column with a primary key.
@@ -420,10 +434,10 @@ Each database table must have a column with a primary key.
 
 Each entity **must** have at least one primary key column.
 This is a requirement and you can't avoid it.
-To make a column a primary key, you need to use `@PrimaryColumn` decorator.
+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 {
@@ -448,13 +462,13 @@ export class Photo {
 }
 ```
 
-### Creating an auto generated column
+### Creating an auto-generated column
 
 Now, let's say you want your id column to be auto-generated (this is known as auto-increment / sequence / serial / generated identity column).
 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 {
@@ -481,13 +495,13 @@ export class Photo {
 
 ### Column data types
 
-Next, let's fix our data types. By default, string is mapped to a varchar(255)-like type (depending on the database type).
-Number is mapped to a integer-like type (depending on the database type).
+Next, let's fix our data types. By default, the string is mapped to a varchar(255)-like type (depending on the database type).
+The number is mapped to an integer-like type (depending on the database type).
 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 {
@@ -524,8 +538,8 @@ Now, when our entity is created, let's create an `index.ts` (or `app.ts` whateve
 
 ```javascript
 import "reflect-metadata";
-import {createConnection} from "typeorm";
-import {Photo} from "./entity/Photo";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection({
     type: "mysql",
@@ -558,10 +572,10 @@ Setting `synchronize` makes sure your entities will be synced with the database,
 ### 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:
+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";
+import { createConnection } from "typeorm";
 
 createConnection({
     type: "mysql",
@@ -581,14 +595,14 @@ createConnection({
 
 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 outDir directory.
+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 database will be initialized and a database table for your photos will be created.
+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
@@ -609,8 +623,8 @@ Now if you run your `index.ts`, a connection with database will be initialized a
 Now let's create a new photo to save it in the database:
 
 ```javascript
-import {createConnection} from "typeorm";
-import {Photo} from "./entity/Photo";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(connection => {
 
@@ -639,8 +653,8 @@ It's not a new copy of the object, it modifies its "id" and returns it.
 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -665,8 +679,8 @@ 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -689,8 +703,8 @@ When you deal with entities a lot, Repositories are more convenient to use than
 
 
 ```javascript
-import {createConnection} from "typeorm";
-import {Photo} from "./entity/Photo";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -719,8 +733,8 @@ 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 { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -752,8 +766,8 @@ 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -772,8 +786,8 @@ 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -788,12 +802,12 @@ Now photo with `id = 1` will be removed from the database.
 
 ### Creating a one-to-one relation
 
-Let's create a one-to-one relation with another class.
+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 {
@@ -854,9 +868,9 @@ 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
+import { PhotoMetadata } from "./entity/PhotoMetadata";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -865,6 +879,7 @@ createConnection(/*...*/).then(async connection => {
     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
@@ -873,7 +888,7 @@ createConnection(/*...*/).then(async connection => {
     metadata.width = 480;
     metadata.compressed = true;
     metadata.comment = "cybershoot";
-    metadata.orientation = "portait";
+    metadata.orientation = "portrait";
     metadata.photo = photo; // this way we connect them
 
     // get entity repositories
@@ -887,7 +902,7 @@ createConnection(/*...*/).then(async connection => {
     await metadataRepository.save(metadata);
 
     // done
-    console.log("Metadata is saved, and relation between metadata and photo is created in the database too");
+    console.log("Metadata is saved, and the relation between metadata and photo is created in the database too");
 
 }).catch(error => console.log(error));
 ```
@@ -902,8 +917,8 @@ 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 {
@@ -917,8 +932,8 @@ export class PhotoMetadata {
 ```
 
 ```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 {
@@ -935,10 +950,44 @@ Here we show that the metadata property of the Photo class is where we store Pho
 Instead of passing a function that returns a property of the photo, you could alternatively simply pass a string to `@OneToOne` decorator, like `"metadata"`.
 But we used this function-typed approach to make our refactoring easier.
 
-Note that we should use `@JoinColumn` decorator only on one side of a relation.
+Note that we should use the `@JoinColumn` decorator only on one side of a relation.
 Whichever side you put this decorator on will be the owning side of the relationship.
 The owning side of a relationship contains a column with a foreign key in the database.
 
+### Relations in ESM projects
+
+If you use ESM in your TypeScript project, you should use the `Relation` wrapper type in relation properties to avoid circular dependency issues.
+Let's modify our entities:
+
+```javascript
+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)
+    @JoinColumn()
+    photo: Relation<Photo>;
+}
+```
+
+```javascript
+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>;
+}
+```
+
 ### Loading objects with their relations
 
 Now let's load our photo and its photo metadata in a single query.
@@ -947,9 +996,9 @@ 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";
+import { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
+import { PhotoMetadata } from "./entity/PhotoMetadata";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -967,9 +1016,9 @@ 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 { createConnection } from "typeorm";
+import { Photo } from "./entity/Photo";
+import { PhotoMetadata } from "./entity/PhotoMetadata";
 
 createConnection(/*...*/).then(async connection => {
 
@@ -984,14 +1033,14 @@ createConnection(/*...*/).then(async connection => {
 }).catch(error => console.log(error));
 ```
 
-`QueryBuilder` allows creation and execution of SQL queries of almost any complexity.
+`QueryBuilder` allows the creation and execution of SQL queries of almost any complexity.
 When you work with `QueryBuilder`, think like you are creating an SQL query.
 In this example, "photo" and "metadata" are aliases applied to selected photos.
 You use aliases to access columns and properties of the selected data.
 
 ### Using cascades to automatically save related objects
 
-We can setup cascade options in our relations, in the cases when we want our related object to be saved whenever the other object is saved.
+We can set up cascade options in our relations, in the cases when we want our related object to be saved whenever the other object is saved.
 Let's change our photo's `@OneToOne` decorator a bit:
 
 ```javascript
@@ -1024,7 +1073,7 @@ createConnection(options).then(async connection => {
     metadata.width = 480;
     metadata.compressed = true;
     metadata.comment = "cybershoot";
-    metadata.orientation = "portait";
+    metadata.orientation = "portrait";
 
     photo.metadata = metadata; // this way we connect them
 
@@ -1039,15 +1088,17 @@ createConnection(options).then(async connection => {
 }).catch(error => console.log(error));
 ```
 
+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.
+
 ### Creating a many-to-one / one-to-many relation
 
-Let's create a many-to-one / one-to-many relation.
+Let's create a many-to-one/one-to-many relation.
 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 {
@@ -1064,14 +1115,14 @@ export class Author {
 ```
 
 `Author` contains an inverse side of a relation.
-`OneToMany` is always an inverse side of relation, and it can't exist without `ManyToOne` on the other side of the relation.
+`OneToMany` is always an inverse side of the relation, and it can't exist without `ManyToOne` on the other side of the relation.
 
 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 {
@@ -1115,12 +1166,12 @@ It will also modify the `photo` table, adding a new `author` column and creating
 
 ### Creating a many-to-many relation
 
-Let's create a many-to-one / many-to-many relation.
+Let's create a many-to-many relation.
 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 {
@@ -1189,6 +1240,8 @@ 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
 photo.albums = [album1, album2];
 await connection.manager.save(photo);
 
@@ -1237,10 +1290,10 @@ let photos = await connection
 ```
 
 This query selects all published photos with "My" or "Mishka" names.
-It will select results from position 5 (pagination offset),
+It will select results from position 5 (pagination offset)
 and will select only 10 results (pagination limit).
 The selection result will be ordered by id in descending order.
-The photo's albums will be left-joined and their metadata will be inner joined.
+The photo's albums will be left joined and their metadata will be inner joined.
 
 You'll use the query builder in your application a lot.
 Learn more about QueryBuilder [here](./docs/select-query-builder.md).
@@ -1255,6 +1308,7 @@ There are a few repositories which you can clone and start with:
 * [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)
@@ -1275,6 +1329,8 @@ There are several extensions that simplify working with TypeORM and integrating
 * [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
 
@@ -1286,12 +1342,12 @@ This project exists thanks to all the people who contribute:
 
 ## Sponsors
 
-Open source is hard and time-consuming. If you want to invest into TypeORM's future you can become a sponsor and make our core team to spend more time on TypeORM's improvements and new features. [Become a sponsor](https://opencollective.com/typeorm)
+Open source is hard and time-consuming. If you want to invest in TypeORM's future you can become a sponsor and allow our core team to spend more time on TypeORM's improvements and new features. [Become a sponsor](https://opencollective.com/typeorm)
 
 <a href="https://opencollective.com/typeorm" target="_blank"><img src="https://opencollective.com/typeorm/tiers/sponsor.svg?width=890"></a>
 
 ## Gold Sponsors
 
-Become a gold sponsor and get a premium technical support from our core contributors. [Become a gold sponsor](https://opencollective.com/typeorm)
+Become a gold sponsor and get premium technical support from our core contributors. [Become a gold sponsor](https://opencollective.com/typeorm)
 
 <a href="https://opencollective.com/typeorm" target="_blank"><img src="https://opencollective.com/typeorm/tiers/gold-sponsor.svg?width=890"></a>