Example using TypeORM with Express

​Initial setup​
​Adding Express to the application​
​Adding TypeORM to the application​
Initial setup
Let's create a simple application called "user" which stores users in the database and allows us to create, update, remove, and get a list of all users, as well as a single user by id within web api.
First, create a directory called "user":
1
mkdir user
Copied!
Then switch to the directory and create a new project:
1
cd user
2
npm init
Copied!
Finish the init process by filling in all required application information.
Now we need to install and setup a TypeScript compiler. Lets install it first:
1
npm i typescript --save-dev
Copied!
Then let's create a tsconfig.json file which contains the configuration required for the application to compile and run. Create it using your favorite editor and put the following configuration:
1
{
2
  "compilerOptions": {
3
    "lib": ["es5", "es6", "dom"],
4
    "target": "es5",
5
    "module": "commonjs",
6
    "moduleResolution": "node",
7
    "emitDecoratorMetadata": true,
8
    "experimentalDecorators": true
9
  }
10
}
Copied!
Now let's create a main application endpoint - app.ts inside the src directory:
1
mkdir src
2
cd src
3
touch app.ts
Copied!
Let's add a simple console.log inside it:
1
console.log("Application is up and running");
Copied!
Now it's time to run our application. To run it, you need to compile your typescript project first:
1
tsc
Copied!
Once you compile it, you should have a src/app.js file generated. You can run it using:
1
node src/app.js
Copied!
You should see the, "Application is up and running" message in your console right after you run the application.
You must compile your files each time you make a change. Alternatively, you can setup watcher or install ts-node to avoid manual compilation each time.
Adding Express to the application
Let's add Express to our application. First, let's install the packages we need:
1
npm i express  @types/express --save
Copied!
express is the express engine itself. It allows us to create a web api
@types/express is used to have a type information when using express
Let's edit the src/app.ts file and add express-related logic:
1
import * as express from "express";
2
import {Request, Response} from "express";
3
​
4
// create and setup express app
5
const app = express();
6
app.use(express.json());
7
​
8
// register routes
9
​
10
app.get("/users", function(req: Request, res: Response) {
11
    // here we will have logic to return all users
12
});
13
​
14
app.get("/users/:id", function(req: Request, res: Response) {
15
    // here we will have logic to return user by id
16
});
17
​
18
app.post("/users", function(req: Request, res: Response) {
19
    // here we will have logic to save a user
20
});
21
​
22
app.put("/users/:id", function(req: Request, res: Response) {
23
    // here we will have logic to update a user by a given user id
24
});
25
​
26
app.delete("/users/:id", function(req: Request, res: Response) {
27
    // here we will have logic to delete a user by a given user id
28
});
29
​
30
// start express server
31
app.listen(3000);
Copied!
Now you can compile and run your project. You should have an express server running now with working routes. However, those routes do not return any content yet.
Adding TypeORM to the application
Finally, let's add TypeORM to the application. In this example, we will use mysql driver. Setup process for other drivers is similar.
Let's install the required packages first:
1
npm i typeorm mysql reflect-metadata --save
Copied!
typeorm is the typeorm package itself
mysql is the underlying database driver. If you are using a different database system, you must install the appropriate package
reflect-metadata is required to make decorators to work properly
Now let's create ormconfig.json with the database connection configuration we will use.
1
  {
2
    "type": "mysql",
3
    "host": "localhost",
4
    "port": 3306,
5
    "username": "test",
6
    "password": "test",
7
    "database": "test",
8
    "entities": ["src/entity/*.js"],
9
    "logging": true,
10
    "synchronize": true
11
  }
Copied!
Configure each option as you need. Learn more about connection options.
Let's create a User entity inside src/entity:
1
import {Entity, Column, PrimaryGeneratedColumn} from "typeorm";
2
​
3
@Entity()
4
export class User {
5
​
6
    @PrimaryGeneratedColumn()
7
    id: number;
8
​
9
    @Column()
10
    firstName: string;
11
​
12
    @Column()
13
    lastName: string;
14
​
15
}
Copied!
Let's change src/app.ts:
1
import * as express from "express";
2
import {Request, Response} from "express";
3
import {createConnection} from "typeorm";
4
import {User} from "./entity/User";
5
​
6
// create typeorm connection
7
createConnection().then(connection => {
8
    const userRepository = connection.getRepository(User);
9
​
10
    // create and setup express app
11
    const app = express();
12
    app.use(express.json());
13
​
14
    // register routes
15
​
16
    app.get("/users", async function(req: Request, res: Response) {
17
        const users = await userRepository.find();
18
        res.json(users);
19
    });
20
​
21
    app.get("/users/:id", async function(req: Request, res: Response) {
22
        const results = await userRepository.findOne(req.params.id);
23
        return res.send(results);
24
    });
25
​
26
    app.post("/users", async function(req: Request, res: Response) {
27
        const user = await userRepository.create(req.body);
28
        const results = await userRepository.save(user);
29
        return res.send(results);
30
    });
31
​
32
    app.put("/users/:id", async function(req: Request, res: Response) {
33
        const user = await userRepository.findOne(req.params.id);
34
        userRepository.merge(user, req.body);
35
        const results = await userRepository.save(user);
36
        return res.send(results);
37
    });
38
​
39
    app.delete("/users/:id", async function(req: Request, res: Response) {
40
        const results = await userRepository.delete(req.params.id);
41
        return res.send(results);
42
    });
43
​
44
    // start express server
45
    app.listen(3000);
46
});
Copied!
If you want to extract action callbacks into separate files and you need the connection instance, you can simply use getConnection:
1
import {getConnection} from "typeorm";
2
import {User} from "./entity/User";
3
​
4
export function UsersListAction(req: Request, res: Response) {
5
    return getConnection().getRepository(User).find();
6
}
Copied!
You don't even need getConnection in this example - you can directly use the getRepository function:
1
import {getRepository} from "typeorm";
2
import {User} from "./entity/User";
3
​
4
export function UsersListAction(req: Request, res: Response) {
5
    return getRepository(User).find();
6
}
Copied!

Entity Metadata

FAQ

Last modified 30d ago

Copy link

Contents

Initial setup

Adding Express to the application

Adding TypeORM to the application