MongoDB

​MongoDB support​
​Defining entities and columns​
​Defining subdocuments (embed documents)​
​Using MongoEntityManager and MongoRepository​
MongoDB support
TypeORM has basic MongoDB support. Most of TypeORM functionality is RDBMS-specific, this page contains all MongoDB-specific functionality documentation.
Defining entities and columns
Defining entities and columns is almost the same as in relational databases, the main difference is that you must use @ObjectIdColumn instead of @PrimaryColumn or @PrimaryGeneratedColumn.
Simple entity example:
1
import {Entity, ObjectID, ObjectIdColumn, Column} from "typeorm";
2
​
3
@Entity()
4
export class User {
5
    
6
    @ObjectIdColumn()
7
    id: ObjectID;
8
    
9
    @Column()
10
    firstName: string;
11
    
12
    @Column()
13
    lastName: string;
14
    
15
}
Copied!
And this is how you bootstrap the app:
1
import {createConnection, Connection} from "typeorm";
2
​
3
const connection: Connection = await createConnection({
4
    type: "mongodb",
5
    host: "localhost",
6
    port: 27017,
7
    database: "test"
8
});
Copied!
Defining subdocuments (embed documents)
Since MongoDB stores objects and objects inside objects (or documents inside documents) you can do the same in TypeORM:
1
import {Entity, ObjectID, ObjectIdColumn, Column} from "typeorm";
2
​
3
export class Profile {
4
    
5
    @Column()
6
    about: string;
7
    
8
    @Column()
9
    education: string;
10
    
11
    @Column()
12
    career: string;
13
    
14
}
Copied!
1
import {Entity, ObjectID, ObjectIdColumn, Column} from "typeorm";
2
​
3
export class Photo {
4
    
5
    @Column()
6
    url: string;
7
    
8
    @Column()
9
    description: string;
10
    
11
    @Column()
12
    size: number;
13
    
14
    constructor(url: string, description: string, size: number) {
15
        this.url = url;
16
        this.description = description;
17
        this.size = size;
18
    }
19
    
20
}
Copied!
1
import {Entity, ObjectID, ObjectIdColumn, Column} from "typeorm";
2
​
3
@Entity()
4
export class User {
5
    
6
    @ObjectIdColumn()
7
    id: ObjectID;
8
    
9
    @Column()
10
    firstName: string;
11
    
12
    @Column()
13
    lastName: string;
14
    
15
    @Column(type => Profile)
16
    profile: Profile;
17
    
18
    @Column(type => Photo)
19
    photos: Photo[];
20
    
21
}
Copied!
If you save this entity:
1
import {getMongoManager} from "typeorm";
2
​
3
const user = new User();
4
user.firstName = "Timber";
5
user.lastName = "Saw";
6
user.profile = new Profile();
7
user.profile.about = "About Trees and Me";
8
user.profile.education = "Tree School";
9
user.profile.career = "Lumberjack";
10
user.photos = [
11
    new Photo("me-and-trees.jpg", "Me and Trees", 100),
12
    new Photo("me-and-chakram.jpg", "Me and Chakram", 200),
13
];
14
​
15
const manager = getMongoManager();
16
await manager.save(user);
Copied!
Following document will be saved in the database:
1
{
2
    "firstName": "Timber",
3
    "lastName": "Saw",
4
    "profile": {
5
        "about": "About Trees and Me",
6
        "education": "Tree School",
7
        "career": "Lumberjack"
8
    },
9
    "photos": [
10
        {
11
            "url": "me-and-trees.jpg",
12
            "description": "Me and Trees",
13
            "size": 100
14
        },
15
        {
16
            "url": "me-and-chakram.jpg",
17
            "description": "Me and Chakram",
18
            "size": 200
19
        }
20
    ]
21
}
Copied!
Using MongoEntityManager and MongoRepository
You can use the majority of methods inside the EntityManager (except for RDBMS-specific, like query and transaction). For example:
1
import {getManager} from "typeorm";
2
​
3
const manager = getManager(); // or connection.manager
4
const timber = await manager.findOne(User, { firstName: "Timber", lastName: "Saw" });
Copied!
For MongoDB there is also a separate MongoEntityManager which extends EntityManager.
1
import {getMongoManager} from "typeorm";
2
​
3
const manager = getMongoManager(); // or connection.mongoManager
4
const timber = await manager.findOne(User, { firstName: "Timber", lastName: "Saw" });
Copied!
Just like separate like MongoEntityManager there is a MongoRepository with extended Repository:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User); // or connection.getMongoRepository
4
const timber = await userRepository.findOne({ firstName: "Timber", lastName: "Saw" });
Copied!
Use Advanced options in find():
Equal:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
const timber = await userRepository.find({
5
  where: {
6
    firstName: {$eq: "Timber"},
7
  }
8
});
Copied!
LessThan:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
const timber = await userRepository.find({
5
  where: {
6
    age: {$lt: 60},
7
  }
8
});
Copied!
In:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
const timber = await userRepository.find({
5
  where: {
6
    firstName: {$in: ["Timber","Zhang"]},
7
  }
8
});
Copied!
Not in:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
const timber = await userRepository.find({
5
  where: {
6
firstName: {$not: {$in: ["Timber","Zhang"]}},
7
}
8
});
Copied!
Or:
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
const timber = await userRepository.find({
5
  where: {
6
    $or: [
7
        {firstName:"Timber"},
8
        {firstName:"Zhang"}
9
      ]
10
  }
11
});
Copied!
Querying subdocuments
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
// Query users with education Tree School
5
const users = await userRepository.find({
6
  where: {
7
   'profile.education': { $eq: "Tree School"}
8
  }
9
});
Copied!
Querying Array of subdocuments
1
import {getMongoRepository} from "typeorm";
2
​
3
const userRepository = getMongoRepository(User);
4
// Query users with photos of size less than 500
5
const users = await userRepository.find({
6
  where: {
7
   'photos.size': { $lt: 500}
8
  }
9
});
Copied!
Both MongoEntityManager and MongoRepository contain lot of useful MongoDB-specific methods:
createCursor
Creates a cursor for a query that can be used to iterate over results from MongoDB.
createEntityCursor
Creates a cursor for a query that can be used to iterate over results from MongoDB. This returns a modified version of the cursor that transforms each result into Entity models.
aggregate
Execute an aggregation framework pipeline against the collection.
bulkWrite
Perform a bulkWrite operation without a fluent API.
count
Count number of matching documents in the db to a query.
createCollectionIndex
Creates an index on the db and collection.
createCollectionIndexes
Creates multiple indexes in the collection, this method is only supported in MongoDB 2.6 or higher. Earlier version of MongoDB will throw a command not supported error. Index specifications are defined at http://docs.mongodb.org/manual/reference/command/createIndexes/.
deleteMany
Delete multiple documents on MongoDB.
deleteOne
Delete a document on MongoDB.
distinct
The distinct command returns a list of distinct values for the given key across a collection.
dropCollectionIndex
Drops an index from this collection.
dropCollectionIndexes
Drops all indexes from the collection.
findOneAndDelete
Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
findOneAndReplace
Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
findOneAndUpdate
Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
geoHaystackSearch
Execute a geo search using a geo haystack index on a collection.
geoNear
Execute the geoNear command to search for items in the collection.
group
Run a group command across a collection.
collectionIndexes
Retrieve all the indexes on the collection.
collectionIndexExists
Retrieve if an index exists on the collection
collectionIndexInformation
Retrieves this collections index info.
initializeOrderedBulkOp
Initiate an In order bulk write operation, operations will be serially executed in the order they are added, creating a new operation for each switch in types.
initializeUnorderedBulkOp
Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
insertMany
Inserts an array of documents into MongoDB.
insertOne
Inserts a single document into MongoDB.
isCapped
Returns if the collection is a capped collection.
listCollectionIndexes
Get the list of all indexes information for the collection.
mapReduce
Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
parallelCollectionScan
Return N number of parallel cursors for a collection allowing parallel reading of entire collection. There are no ordering guarantees for returned results
reIndex
Reindex all indexes on the collection Warning: reIndex is a blocking operation (indexes are rebuilt in the foreground) and will be slow for large collections.
rename
Changes the name of an existing collection.
replaceOne
Replace a document on MongoDB.
stats
Get all the collection statistics.
updateMany
Updates multiple documents within the collection based on the filter.
updateOne
Updates a single document within the collection based on the filter.

Migrations

Multiple connections, databases, schemas and replication setup

Last modified 1mo ago

Copy link

Contents

MongoDB support

Defining entities and columns

Defining subdocuments (embed documents)

Using MongoEntityManager and MongoRepository

MongoDB support

Defining entities and columns

Defining subdocuments (embed documents)

Using `MongoEntityManager` and `MongoRepository`

`createCursor`

`createEntityCursor`

`aggregate`

`bulkWrite`

`count`

`createCollectionIndex`

`createCollectionIndexes`

`deleteMany`

`deleteOne`

`distinct`

`dropCollectionIndex`

`dropCollectionIndexes`

`findOneAndDelete`

`findOneAndReplace`

`findOneAndUpdate`

`geoHaystackSearch`

`geoNear`

`group`

`collectionIndexes`

`collectionIndexExists`

`collectionIndexInformation`

`initializeOrderedBulkOp`

`initializeUnorderedBulkOp`

`insertMany`

`insertOne`

`isCapped`

`listCollectionIndexes`

`mapReduce`

`parallelCollectionScan`

`reIndex`

`rename`

`replaceOne`

`stats`

`updateMany`

`updateOne`