Ինչպես օգտագործել SQL տվյալների բազաները NestJS հավելվածում TypeORM-ով

Ինչու՞ չավելացնել ձեր տվյալների բազայի խաղը TypeORM-ի լիարժեք հնարավորություններով NestJS փաթեթով:

Object-Relational Mapper-ը (ORM) գրադարան է, որն իրականացնում է Օբյեկտ-հարաբերական քարտեզագրման տեխնիկան: Սա թույլ է տալիս գրել SQL տվյալների բազայի հարցումներ՝ օգտագործելով ձեր նախընտրած լեզվի օբյեկտ-կողմնորոշված պարադիգմը:

TypeORM-ը TypeScript ORM է, որը շատ հեշտ է դարձնում ինտերֆեյսը տարբեր տվյալների բազաների հետ: Այն աշխատում է SQL տվյալների շտեմարանների հետ, բայց նաև հիանալի կերպով համագործակցում է NoSQL տվյալների բազաների հետ, ինչպիսին է MongoDB-ն:

NestJS-ը տրամադրում է բարձր մակարդակի աջակցություն TypeORM-ին առանց տուփի: Հատուկ TypeORM փաթեթը համեմատաբար հեշտացնում է ինտեգրումը:

Քայլ 1. Կախվածությունների տեղադրում

Նախքան TypeORM-ը NestJS հավելվածում օգտագործելը, դուք պետք է այն տեղադրեք իր բնիկ NestJS փաթեթով և ձեր նախընտրած SQL տվյալների բազայով: SQLite-ը պարզ, առանց տեղադրման տարբերակ է:

Գործարկեք հետևյալ հրամանը՝ TypeORM-ը և նրա բնիկ NestJS փաթեթը տեղադրելու համար՝ օգտագործելով npm փաթեթների կառավարիչը.

npm install @nestjs/typeorm typeorm

SQLite-ը տեղադրելու համար գործարկեք հետևյալ հրամանը.

npm install sqlite3

Քայլ 2. Ստեղծել էություն

Սուբյեկտը դաշտերի հավաքածու է, որը սահմանում է տվյալների բազայում պահվող տվյալները: TypeORM-ն օգտագործում է էության ֆայլը՝ ձեր տվյալների բազայում աղյուսակ ստեղծելու համար:

Կազմակերպություն ստեղծելու համար հետևեք հետևյալ քայլերին.

  1. Ստեղծեք ֆայլ ձեր հավելվածի մոդուլում և անվանեք այն՝ համաձայն NestJS անվանման կոնվենցիայի (.entity.ts):
  2. Ձեր իրավաբանական ֆայլում ներմուծեք Entity, Column և PrimaryGeneratedColumn դեկորատորները typeorm-ից:
  3. Ձեր էության ֆայլում ստեղծեք և արտահանեք դաս:
  4. Լրացրեք դասը ձեր տվյալների բազայում ձեր ուզած արժեքներով, օրինակ՝ id, անուն և այլն:
  5. Նշեք ձեր օբյեկտի դասը Entity decorator-ով: Սա ձեր դասը ճանաչելի է դարձնում TypeORM-ին որպես էություն:
  6. Նշեք ձեր ID հատկությունը PrimaryGeneratedColumn դեկորատորի միջոցով: Սա TypeORM-ին հուշում է id-ը նշել որպես հիմնական բանալի և ավտոմատ կերպով ավելացնել այն:
  7. Նշեք մնացած հատկությունները Սյունակ դեկորատորով: Սա դրանք ավելացնում է որպես սյունակներ ձեր տվյալների բազայում:

Օրինակ:

// src/test/test.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
 
@Entity()
export class Test {
  @PrimaryGeneratedColumn()
  id: number;
 
  @Column()
  property_1: string;
 
  @Column()
  property_2: string;
 
  @Column()
  property_3: string;
}

Վերևում գտնվող օբյեկտի ֆայլը ստեղծում է այս աղյուսակը ձեր տվյալների բազայում.

test

id

int(11)

PRIMARY KEY AUTO_INCREMENT

property_1

varchar(255)

property_2

varchar(255)

property_3

varchar(255)

TypeORM-ի փաստաթղթերն ավելի մանրամասն ընդգրկում են կազմակերպությունները:

Քայլ 3. Ձեր հավելվածը միացնելով տվյալների շտեմարանին

Այժմ, երբ ձեր կազմակերպությունը ստեղծվել է, դուք պետք է ձեր դիմումը միացնեք տվյալների բազային: Այս օրինակը օգտագործում է SQLite:

Ձեր դիմումը տվյալների բազային միացնելու համար հետևեք հետևյալ քայլերին.

  1. Ձեր հավելվածների արմատային մոդուլում (սովորաբար app.module.ts ֆայլ) ներմուծեք TypeOrmModule @nestjs/typeorm-ից:
  2. Նույն ֆայլում ներմուծեք ձեր բոլոր սուբյեկտները:
  3. ներմուծումների զանգվածում կանչեք forRoot մեթոդը TypeOrmModule-ում: ForRoot մեթոդը կիսում է տվյալների բազայի կապը ձեր հավելվածի բոլոր մոդուլների միջոցով:
  4. Դատարկ օբյեկտը որպես փաստարկ փոխանցեք forRoot մեթոդին; սա կլինի TypeORM կոնֆիգուրացիայի օբյեկտը:
  5. Կազմաձևման օբյեկտին ավելացրեք հատկություն՝ type և դրեք այն «sqlite»: Type հատկությունը նշանակում է տվյալների բազայի անունը, որը դուք օգտագործում եք:
  6. Կազմաձևման օբյեկտին ավելացրեք մեկ այլ հատկություն՝ տվյալների բազա և դրեք այն “test.db”: Տվյալների բազայի հատկությունը նշանակում է ձեր նախընտրած անունը ձեր տվյալների բազայի համար:
  7. Կազմաձևման օբյեկտին ավելացրեք մեկ այլ հատկություն՝ սուբյեկտներ և դրեք այն դատարկ զանգվածի վրա: Լրացրեք դատարկ զանգվածը այն օբյեկտներով, որոնք ավելի վաղ ներմուծել եք:
  8. Ավելացրեք մեկ այլ հատկություն, համաժամացրեք և սահմանեք այն true; այս հատկությունը համաժամացնում է ձեր օբյեկտները ձեր տվյալների բազայի հետ և թարմացնում այն ամեն անգամ, երբ գործարկում եք կոդը: Մշակման ժամանակ դուք պետք է միայն սահմանեք այս հատկությունը true: Արտադրության ընթացքում դուք պետք է սահմանեք այն false, որպեսզի խուսափեք տվյալների կորստից:
// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Test } from './test/test.entity';
import { Entity2 } from './entity/entity.entity';
import { TestModule } from './test/test.module';
 
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'test.db',
      entities: [Test, Entity2],
      synchronize: true, //development only
    }),
    TestModule,
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

Քայլ 4. Պահեստի ստեղծում

Պահեստը կազմակերպության մուտքի շերտն է, որն օգտագործվում է տվյալների բազայում կազմակերպության կողմից ստեղծված աղյուսակում հարցումներ կատարելու համար (տեղադրել, ջնջել, պահել, գտնել և այլն): TypeORM-ն աջակցում է պահեստի նախագծման օրինաչափությանը, հետևաբար, յուրաքանչյուր կազմակերպություն ունի իր սեփական պահեստը:

TypeORM-ը ավտոմատ կերպով ստեղծում է պահոց ձեր կազմակերպության համար, երբ հետևում եք ստորև նշված քայլերին.

  1. Ձեր կազմակերպության մոդուլի ֆայլում ներմուծեք TypeOrmModule @nestjs/typeorm-ից և ներմուծեք ձեր կազմակերպությունը:
  2. Ստեղծեք ներմուծումների զանգված @Module դեկորատորում:
  3. Ներմուծման զանգվածում կանչեք forFeature մեթոդը TypeOrmModule-ում:
  4. Զանգվածը որպես փաստարկ փոխանցեք ձեր մեջ և լրացրեք զանգվածը ձեր էությամբ:
// src/test/test.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TestController } from './test.controller';
import { TestService } from './test.service';
import { Test } from './test.entity';
 
@Module({
  imports: [TypeOrmModule.forFeature([Test])],
  providers: [TestService],
  controllers: [TestController],
})

Քայլ 5. Ձեր պահեստի ներարկումն իր ծառայությանը՝ օգտագործելով կախվածության ներարկում

Կախվածության ներարկումը ծրագրային ինժեներական տեխնիկա է, որը կառավարման սկզբունքի հակադարձման ձև է: Այն տեղափոխում է կախվածության կառավարման բեռը հաճախորդի ծածկագրից դեպի գրադարան կամ ծառայություն, որից կախված է:

Հետևեք ստորև նշված քայլերին՝ ձեր պահեստը ծառայության մեջ ներարկելու համար.

  1. Ձեր սպասարկման ֆայլում ներմուծեք Repository typeorm-ից և InjectRepository դեկորատորը @nestjs/typeorm-ից: Նաև ներմուծեք այն կազմակերպությունը, որը ցանկանում եք ներարկել դրա պահեստը:
  2. Ձեր սպասարկման դասում ստեղծեք կոնստրուկտոր:
  3. Հայտարարեք մասնավոր փոփոխականը՝ repo, որպես պարամետր կոնստրուկտորում՝ այն սկզբնավորելու համար:
  4. Հանձնարարեք պահեստի մի տեսակ ռեպո ձեր կազմակերպության ընդհանուր տեսակի հետ:
  5. Նշեք ռեպո InjectRepository դեկորատորով և փոխանցեք ձեր էությունը որպես փաստարկ:
// test.service.ts
import { Injectable } from '@nestjs/common';
import { Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Test } from './test.entity';
 
@Injectable()
export class TestService {
  constructor(
    @InjectRepository(Test)
    private repo: Repository<Test>,
  ) {}
}

Այժմ, երբ ձեր կարգավորումն ավարտված է, դուք կարող եք SQL հարցումներ կատարել դրա վրա՝ տվյալներն առբերելու կամ փոփոխելու համար:

SQL հարցումների կատարում TypeORM-ով

Դուք կարող եք կատարել ցանկացած պարզ SQL հարցում՝ զանգահարելով TypeORM-ի պահեստավորման մեթոդները repo փոփոխականի վրա ձեր ծառայության դասի ներսում: Կարող եք նաև ստեղծել բարդ SQL հարցումներ՝ օգտագործելով TypeORM-ի հարցումների ստեղծողը: