How to Set Up TypeORM in a Node.js Project

Introduction to TypeORM and Its Benefits

TypeORM is a powerful Object-Relational Mapper (ORM) tool for TypeScript and JavaScript. It allows developers to interact with databases using object-oriented programming. This approach simplifies database operations and enhances productivity.

One of the major benefits of TypeORM is its support for multiple database systems. Whether you’re using PostgreSQL, MySQL, SQLite, or others, TypeORM has got you covered. This flexibility makes it a popular choice for developers handling diverse projects.

Additionally, TypeORM is designed with TypeScript in mind. This integration means developers can enjoy the advantages of static typing. Expect fewer runtime errors and improved code maintainability as a result.

TypeORM also offers a feature-rich API that supports complex queries, migrations, and relations. These features allow developers to build scalable and robust applications efficiently. Furthermore, it supports both Active Record and Data Mapper patterns, catering to different development preferences.

In summary, TypeORM is a versatile and developer-friendly ORM. It streamlines database management tasks and enhances code quality. If you’re working on a Node.js project, setting up TypeORM could be a game-changer.

Installing TypeORM and Related Dependencies

Setting up TypeORM in a Node.js project involves a few simple steps. First, you need to install TypeORM and the necessary database driver for your specific database. This setup ensures that your application can interact with the database effectively.

To get started, open your terminal and navigate to your project directory. Once there, run the following command to install TypeORM:

npm install typeorm --save

Next, you’ll need to install a database driver. TypeORM supports various databases, so choose a driver that matches your database of choice. For instance, if you’re using PostgreSQL, run:

npm install pg --save

If you’re using MySQL, the installation command would be:

npm install mysql --save

After installing these dependencies, it’s important to ensure that your tsconfig.json file is configured correctly, especially if you’re using TypeScript. Here is a simple example of what your configuration might look like:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "./dist",
    "rootDir": "./src"
  }
}
  

Installing TypeORM and its related dependencies is a crucial first step in configuring your Node.js application to work seamlessly with databases. With these installations in place, you’ll be ready to start defining your entities and setting up your database connections.

Configuring the TypeORM Connection

When working with TypeORM in a Node.js project, setting up a database connection is a critical step. Proper configuration ensures your application communicates efficiently with the database. Let’s dive into how you can achieve that.

First, you need to install TypeORM and a database driver. For instance, if you’re using PostgreSQL, install the following packages:

    npm install typeorm pg
  

After installation, configure the connection in your project. Create a new file named ormconfig.json in your project’s root directory. This file will hold your database configuration details. Here’s a basic example:

    {
      "type": "postgres",
      "host": "localhost",
      "port": 5432,
      "username": "your-username",
      "password": "your-password",
      "database": "your-database",
      "synchronize": true,
      "logging": false,
      "entities": [
        "src/entity/**/*.ts"
      ],
      "migrations": [
        "src/migration/**/*.ts"
      ],
      "subscribers": [
        "src/subscriber/**/*.ts"
      ]
    }
  

The above configuration specifies the database type, connection details, and paths to entities, migrations, and subscribers. The synchronize option automatically updates the database schema, which is great for development but not recommended for production.

To establish the connection, import and use the TypeORM connection API in your application. Here’s a snippet to get you started:

    import { createConnection } from "typeorm";

    createConnection().then(async connection => {
      console.log("Database connection established");
    }).catch(error => console.log("Error: ", error));
  

By following these steps, you’ll configure a robust TypeORM connection, laying the foundation for seamless data operations in your Node.js project. Remember, a well-configured connection is crucial for optimal application performance.

Creating Database Entities with TypeORM

When setting up TypeORM in your Node.js project, creating database entities is a crucial step. Entities in TypeORM are the equivalent of models in other ORMs and define the structure of your database tables.

To create an entity, start by defining a TypeScript class. This class will map to a database table, and each instance will represent a row in that table. Use decorators to define the properties and their respective database columns.

For example, let’s create a simple User entity:

  import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

  @Entity()
  export class User {
      @PrimaryGeneratedColumn()
      id: number;

      @Column()
      firstName: string;

      @Column()
      lastName: string;

      @Column({ default: true })
      isActive: boolean;
  }
  

In this example, we use the @Entity decorator to mark the class as a database entity. The @PrimaryGeneratedColumn decorator is used for the primary key, which automatically generates unique IDs for each user. The @Column decorator specifies attributes like firstName, lastName, and isActive.

TypeORM supports various column types and options. You can customize columns by passing options like length for strings or nullable to allow null values. This flexibility makes TypeORM a powerful tool in designing your database schema.

Running Migrations in TypeORM

Working with databases often demands structural changes. TypeORM simplifies this process with migrations. Migrations are essential for evolving your database schema without losing data.

Before running migrations, ensure you’ve configured TypeORM. Your configuration file should specify database details and paths to migration files. Once set up, you can generate and run migrations effortlessly.

Generating Migrations

Use the TypeORM CLI to generate migrations. This command creates a blank migration file:

    typeorm migration:generate -n MigrationName
  

After generation, edit the migration file. Define the changes in the up and down methods. This ensures your migration can be undone if necessary.

Running Migrations

With your migrations defined, execute them using the following command:

    typeorm migration:run
  

This command applies all pending migrations to the database. It’s vital for keeping your database in sync with your application’s state.

Reverting Migrations

If you need to undo a migration, TypeORM makes it simple. Use this command to revert the last migration:

    typeorm migration:revert
  

Migrations in TypeORM provide a robust way to manage database changes. They ensure your application evolves smoothly, maintaining data integrity.

Using TypeORM Repositories for CRUD Operations

TypeORM is a powerful tool to manage your database interactions in a Node.js project. It simplifies CRUD operations through repositories, which act as a layer between your application and the database. Understanding how to leverage these repositories can streamline your development process.

Repositories in TypeORM are designed to handle the common tasks of Create, Read, Update, and Delete (CRUD) without boilerplate code. They offer a programmatic approach to manage entities, making database interactions more efficient and less error-prone.

Creating Records

To create a new record, you first instantiate the entity and then use the repository’s save() method. This method is responsible for inserting new records and updating existing ones.

const userRepo = AppDataSource.getRepository(User);
const newUser = userRepo.create({ name: "John Doe", email: "john@example.com" });
await userRepo.save(newUser);
  

Reading Records

TypeORM repositories provide methods like find() and findOne() to fetch data. These methods allow you to query the database with various conditions.

const users = await userRepo.find();
const user = await userRepo.findOne({ where: { email: "john@example.com" } });
  

Updating Records

Updating records involves retrieving the entity, modifying it, and then saving it back to the database.

const userToUpdate = await userRepo.findOne({ where: { id: 1 } });
userToUpdate.name = "Jane Doe";
await userRepo.save(userToUpdate);
  

Deleting Records

To delete a record, retrieve the entity and use the remove() method. This will remove the entity from the database.

const userToDelete = await userRepo.findOne({ where: { id: 1 } });
await userRepo.remove(userToDelete);
  

By using TypeORM repositories, developers can focus on business logic rather than database intricacies. This leads to cleaner

@Entity()
class User {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => Profile)
  @JoinColumn()
  profile: Profile;
}
  

@Entity()
class Author {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToMany(() => Book, book => book.author)
  books: Book[];
}

@Entity()
class Book {
  @PrimaryGeneratedColumn()
  id: number;

  @ManyToOne(() => Author, author => author.books)
  author: Author;
}
  

@Entity()
class Student {
  @PrimaryGeneratedColumn()
  id: number;

  @ManyToMany(() => Course)
  @JoinTable()
  courses: Course[];
}

@Entity()
class Course {
  @PrimaryGeneratedColumn()
  id: number;

  @ManyToMany(() => Student)
  students: Student[];
}
  

npm install --save-dev jest ts-jest @types/jest

import { getConnection } from 'typeorm';
import { YourEntity } from './YourEntity';
import { YourService } from './YourService';

test('should create a new entity', async () => {
  const service = new YourService();
  const entity = await service.createEntity({ name: 'Test' });
  expect(entity.name).toBe('Test');
});

const connection = await createConnection({
  // your connection options
  logging: ['query', 'error']
});

try {
  const entity = await connection.getRepository(YourEntity).findOne({ id: 1 });
  if (!entity) throw new Error('Entity not found');
} catch (error) {
  console.error('Error fetching entity:', error);
}

const connectionOptions = {
  type: "postgres",
  host: "localhost",
  port: 5432,
  username: "test",
  password: "test",
  database: "test",
  synchronize: true,
  logging: false,
  entities: [
    "src/entity/**/*.ts"
  ],
  cli: {
    entitiesDir: "src/entity"
  },
  extra: {
    max: 5, // maximum number of connections
    min: 1  // minimum number of connections
  }
};
  

  import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

  @Entity()
  export class User {
      @PrimaryGeneratedColumn()
      id: number;

      @Column()
      name: string;

      @Column()
      email: string;
  }