A TypeORM egy objektum-relációs leképező eszköz, aminek segítségével TypeScript osztályokat különböző adatbázisokkal tudjuk anélkül használni, hogy konkrét adatbázis-kezelő specifikus parancsokat használnánk (TypeORM segítségével nem csak relációs adatbázist lehet kezelni, hanem NoSQL-t – pl. MongoDB-t – is).

Használatát egy példán keresztül érdemes megismerni.

A következő parancsot egyszer kell futtatni, ennek hatására rendszer szinten települnek a szükséges csomagok:

npm install -g typeorm

• Indítsuk el a WAMPServer szoftvercsomagot, mely tartalmazza a MySQL adatbázist és a PHPMyAdmin klienst.
• Jelentkezzünk be a PHPMyAdmin-ba a következő címen: http://localhost/phpmyadmin (felhasználónév root, jelszót nem kell megadni).
• Ezután a felület baloldalán megjelennek a MySQL-ben létrehozott adatbázisok. Új adatbázis hozzáadásához kattintsunk az „Új” gombra.
• Adatbázisunk neve legyen infrend_typeorm, karakterkészletként használjuk a utf8mb4_hungarian_ci lehetőséget.
• Ha az adatbázist sikeresen létrehoztuk, az megjelenik a baloldali menüben. Erre kattintva a későbbiekben ellenőrizni tudjuk a TypeORM által végrehajtott műveletek eredményét.

• Meglévő projektbe történő telepítéskor ezt az útmutatót érdemes követni.
• Új, MySQL alapú projekt létrehozásakor elég ezt a parancsot futtatni: typeorm init –name typeorm-tutorial –database mysql

A projektben a következő fájlstruktúra jött létre:

.
├── package.json
├── package-lock.json
├── README.md
├── src
│   ├── data-source.ts
│   ├── entity
│   │   └── User.ts
│   ├── migration
│   └── index.ts
└── tsconfig.json

Nézzünk bele a létrejött fájlok tartalmába!

• data-source.ts: A TypeORM konfigurációs fájlja.
• entity: Ez a könyvtár tartalmazza az adatbázis modelleket.
• migration: Ez a könyvtár tartalmazza az adatbázis migrációs szkripteket. Ez elsősorban éles rendszerek fejlesztésekor szükséges.
• index.ts: Az alkalmazás belépési pontja.
• tsconfig.json: A TypeScript compiler beállításai.

Nyissuk meg a data-source.ts fájlt, és módosítsuk a beállításokat az alábbiak szerint:

import "reflect-metadata"
import { DataSource } from "typeorm"
import { User } from "./entity/User"

export const AppDataSource = new DataSource({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "root",
    password: undefined,
    database: "infrend_typeorm",
    synchronize: true,
    logging: true,
    entities: [User],
    migrations: [],
    subscribers: [],
});

Futtassuk az npm start parancsot.

Ha hiba nélkül lefutott, akkor a PHPMyAdmin felületén megtekinthetjük a létrejött sort az adatbázisban.

A tábláink gyakran kapcsolatban vannak egymással. Három alap relációt különböztetünk meg:

• One-to-One: 1:1 reláció, ahol két táblát úgy kapcsolunk össze, hogy 1 rekord csak 1 másik rekordnak felelhet meg egy másik táblában.
• One-to-Many: 1:N reláció, ahol 1 rekord több másik táblabeli rekorddal is össze lehet kapcsolva.
• Many-to-Many: N:M reláció, ahol 1 rekord több másik táblabeli rekorddal is össze lehet kapcsolva, és ez fordítva is teljesül.

Adjunk hozzá két entitást az src/entity/ mappához: Dog.ts és Owner.ts.

// Dog.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from "typeorm";
import { Owner } from "./Owner";

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

    @Column()
    name: string;

    @ManyToOne(type => Owner, owner => owner.dogs)
    owner: Owner;
}

// Owner.ts
import {Entity, PrimaryGeneratedColumn, Column, OneToMany} from "typeorm";
import { Dog } from "./Dog";

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

    @Column()
    name: string;

    @OneToMany(type => Dog, dog => dog.owner)
    dogs: Dog[];
}

Módosítsuk a data-source.ts fájlt, az entities tömbhöz adjuk hozzá az új entitásokat: entities: [Dog, Owner].

Módosítsuk az index.ts fájlt:

import { AppDataSource } from "./data-source"
import { Dog } from "./entity/Dog";
import { Owner } from "./entity/Owner";

AppDataSource.initialize().then(async () => {
    const dog1 = new Dog();
    dog1.name = 'Bodri';

    const dog2 = new Dog();
    dog2.name = 'Buksi';

    const owner = new Owner();
    owner.name = "Kovács Lajos";
    owner.dogs = [ dog1, dog2 ];

    await AppDataSource.manager.save(owner);
    console.log("Owner is saved.");

    AppDataSource.destroy();
}).catch(error => {
    console.log(error);
    AppDataSource.destroy();
});

A kutyák automatikus létrehozásához módosítsuk az Owner.ts fájlban:

@OneToMany(type => Dog, dog => dog.owner, { cascade: true })

Kaszkádolt törlés beállítása a Dog.ts fájlban:

@ManyToOne(type => Owner, owner => owner.dogs, { onDelete: 'CASCADE' })
owner: Owner;

Hozzuk létre a Role.ts fájlt:

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

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

    @Column()
    name: string;
}

Ezután a User.ts fájlt:

import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from "typeorm";
import { Role } from "./Role";

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

    @Column()
    name: string;

    @ManyToMany(type => Role, { cascade: true })
    @JoinTable()
    roles: Role[];
}

Frissítsük a data-source.ts fájlt:

entities: [User, Role, Dog, Owner]

Az index.ts fájl:

import { AppDataSource } from "./data-source"
import { Role } from "./entity/Role";
import { User } from "./entity/User";

AppDataSource.initialize().then(async () => {
    const roleAdmin = new Role();
    roleAdmin.name = "admin";

    const roleUser = new Role();
    roleUser.name = "user";

    const user = new User();
    user.name = "administrator";
    user.roles = [roleAdmin, roleUser];

    await AppDataSource.manager.save(user);
    console.log("User is saved.");

    AppDataSource.destroy();
}).catch(error => {
    console.log(error);
    AppDataSource.destroy();
});

Futtassuk a kódot (npm start), majd a PHPMyAdmin felületén ellenőrizzük az adatbázisban létrejött táblákat.

Létrejön egy user és egy role tábla, valamint egy user_roles_role kapcsolótábla is, amely a több-több kapcsolatot valósítja meg.