NestJS இல் மெய்நிகர் நிறுவனங்களுக்கான MikroORM தொடர்புகளைக் கையாளுதல்

MikroORM 🚀 உடன் சிக்கலான மெய்நிகர் நிறுவன உறவுகளைத் தீர்ப்பது

அளவிடக்கூடிய பயன்பாடுகளை உருவாக்கும்போது NestJS பயன்படுத்தி MikroORM, டெவலப்பர்கள் பெரும்பாலும் உறவுகளை நிர்வகிப்பதில் சவால்களை எதிர்கொள்கின்றனர், குறிப்பாக மெய்நிகர் நிறுவனங்களுடன். உதாரணமாக, உங்களிடம் பல உறவுகளுடன் இணைக்கும் ஒரு `StockItem` நிறுவனம் இருப்பதாக கற்பனை செய்து பாருங்கள், மேலும் இந்த உறவுகளை ஒரே பார்வையில் சுருக்கமாகச் சொல்ல விரும்புகிறீர்கள்.

சரக்கு அமைப்புகளுடன் பணிபுரியும் போது இது ஒரு பொதுவான காட்சியாகும். காலப்போக்கில் பங்கு மாற்றங்கள் கண்காணிக்கப்பட்டுவிட்டன என்று வைத்துக்கொள்வோம், மேலும் பங்கு அளவை விரைவாகச் சுருக்கமாகக் கூற உங்களுக்கு-`StockItemStatus`-பார்வை தேவை. MikroORM நிறுவனத்திற்கும் மெய்நிகர் பார்வைக்கும் இடையிலான உறவை அடையாளம் காணத் தவறினால் சிக்கல் எழுகிறது.

சமீபத்தில், நான் ஒரு பிழையை எதிர்கொண்டேன்: "வகைப் பிழை: வரையறுக்கப்படாத ('மேட்ச்' படித்தல்) பண்புகளைப் படிக்க முடியாது." புதிய `StockItem` ஐ உருவாக்கி அதை `StockItemStatus` காட்சியுடன் இணைக்க முயற்சிக்கும்போது இது நிகழ்ந்தது. ஒரு டெவலப்பராக, உங்கள் நிறுவனங்களும் பார்வைகளும் ஒத்திசைவில் இல்லாதபோது இந்தச் சிக்கல்கள் எவ்வளவு ஏமாற்றமளிக்கும் என்பதை நான் புரிந்துகொள்கிறேன். 🤯

இந்தக் கட்டுரையில், செயல்திறனைக் கட்டுக்குள் வைத்திருக்கும் போது, ​​MikroORM இல் இந்தச் சிக்கலை எவ்வாறு திறம்பட நிவர்த்தி செய்வது என்பதை நான் உங்களுக்குக் கூறுகிறேன். நடைமுறை அணுகுமுறையைப் பகிர்வதன் மூலம், நீங்கள் பொதுவான இடர்பாடுகளைத் தவிர்த்து, உங்களுக்கானதை உறுதிசெய்வீர்கள் வரைபடம்QL API மற்றும் மெய்நிகர் நிறுவனங்கள் தடையின்றி ஒன்றாக வேலை செய்கின்றன. உள்ளே நுழைவோம்!

NestJS இல் MikroORM உடனான நிறுவன உறவுகளைத் தீர்ப்பது

உடன் பணிபுரியும் போது MikroORM மற்றும் தரவுத்தள காட்சிகள் a NestJS திட்டம், நிறுவனங்களுக்கும் மெய்நிகர் நிறுவனங்களுக்கும் இடையிலான உறவுகளைக் கையாள்வது தந்திரமானதாக இருக்கும். மேலே உள்ள எடுத்துக்காட்டில், `StockItemStatus` எனப்படும் மெய்நிகர் பார்வையுடன் `StockItem` உட்பொருளைத் தொடர்புபடுத்துவதில் உள்ள சிக்கலைச் சமாளித்தோம். உருவாக்கச் செயல்பாட்டின் போது மெய்நிகர் நிறுவனம் வழக்கமான அட்டவணையைப் போல் செயல்படாததால் சிக்கல் ஏற்பட்டது, இதன் விளைவாக "வகைப் பிழை: வரையறுக்கப்படாத ('மேட்ச்'' வாசிப்பு') பண்புகளைப் படிக்க முடியாது." வாழ்க்கை சுழற்சி கொக்கிகள், பரிவர்த்தனை செயல்பாடுகள் மற்றும் தொடர்புடைய மேப்பிங் கட்டளைகளை இணைப்பதன் மூலம், சிக்கலுக்கு ஒரு சுத்தமான தீர்வை அடைந்தோம். 🚀

முதலில், மெய்நிகர் நிறுவனத்தை வரையறுக்க `@Entity({ வெளிப்பாடு: 'SELECT * from stock_item_status' })` ஐப் பயன்படுத்தினோம். இது MikroORM இல் உள்ள சக்திவாய்ந்த அம்சமாகும், இது டெவலப்பர்கள் தரவுத்தள காட்சிகளை நேரடியாக தங்கள் பயன்பாட்டில் படிக்க-மட்டுமே நிறுவனங்களாக வரைபடமாக்க அனுமதிக்கிறது. எங்கள் விஷயத்தில், `StockItemStatus` என்பது அனைத்து பங்கு மாற்றங்களையும் ஒரே நிலை மதிப்பாக சுருக்கி, `@Formula` ஐப் பயன்படுத்தி மீண்டும் மீண்டும் கணக்கிடப்படுவதைத் தவிர்ப்பதன் மூலம் செயல்திறனை மேம்படுத்துகிறது. இந்த அமைப்பு குறிப்பாக சரக்கு மேலாண்மை போன்ற அமைப்புகளுக்கு உதவியாக இருக்கும், அங்கு தரவு ஒருங்கிணைப்பு முக்கியமானது.

`ஆவலுடன்: உண்மை` விருப்பத்துடன் `@OneToOne` அலங்கரிப்பாளர், `StockItem` வினவப்படும்போதெல்லாம், தொடர்புடைய `StockItemStatus` தானாகவே ஏற்றப்படுவதை உறுதி செய்வதில் முக்கியப் பங்கு வகிக்கிறது. இருப்பினும், உருவாக்கப் பிரச்சினைக்கு கூடுதல் தலையீடு தேவைப்பட்டது. அதை நிவர்த்தி செய்ய, `முன் உருவாக்கு' ஹூக் மற்றும் தனிப்பயன் பரிவர்த்தனை முறையை செயல்படுத்தினோம். இரு நிறுவனங்களும் ஒன்றாகச் சேமிக்கப்படும்போது பரிவர்த்தனை அணுசக்தியை உறுதி செய்யும் போது, ​​ஹூக் நிறுவனம் தொடர்வதற்கு முன் தானாக உறவைத் துவக்குகிறது. நிஜ வாழ்க்கைக் காட்சியானது ஆன்லைன் ஸ்டோராக இருக்கலாம், அங்கு நீங்கள் தயாரிப்பு இருப்புப் பொருட்களைப் பதிவுசெய்து அவற்றின் கணக்கிடப்பட்ட நிலைகளுடன் ஒரே சீரான செயல்பாட்டில் இணைக்க வேண்டும். 🛒

இறுதியாக, எங்கள் தீர்வை சரிபார்க்க, நாங்கள் Jest ஐப் பயன்படுத்தி அலகு சோதனைகளைச் சேர்த்துள்ளோம். `EntityManager` ஐ கேலி செய்வது, தரவுத்தள செயல்பாடுகளை உருவகப்படுத்தவும், உருவாக்கம் மற்றும் உறவு துவக்கம் இரண்டும் எதிர்பார்த்தபடி செயல்படுவதை உறுதிசெய்யவும் எங்களை அனுமதித்தது. குறிப்பாக நிறுவனங்கள் மற்றும் மெய்நிகர் பார்வைகளுக்கு இடையே உள்ள சிக்கலான உறவுகளைக் கையாளும் போது, ​​பின்தளத்தில் தீர்வுகளின் நம்பகத்தன்மையை உறுதி செய்வதற்கு சோதனை மிகவும் முக்கியமானது. குறியீட்டை மாடுலரைஸ் செய்வதன் மூலமும், சிறந்த நடைமுறைகளைப் பயன்படுத்துவதன் மூலமும், எதிர்காலத் திட்டங்களில் இதே போன்ற சிக்கல்களுக்கு எளிதில் மாற்றியமைக்கக்கூடிய வலுவான, மீண்டும் பயன்படுத்தக்கூடிய தீர்வை நாங்கள் உருவாக்கியுள்ளோம்.

// --- StockItem Entity ---
import { Entity, PrimaryKey, OneToOne, Ref } from '@mikro-orm/core';
@Entity()
export class StockItem {
  @PrimaryKey()
  id: number;
  @OneToOne(() => StockItemStatus, (status) => status.stockItem, { eager: true })
  status: Ref<StockItemStatus>;
}
// --- StockItemStatus Virtual View Entity ---
@Entity({ expression: 'SELECT * FROM stock_item_status' })
export class StockItemStatus {
  @PrimaryKey()
  id: number;
  @OneToOne(() => StockItem, { joinColumn: 'stock_item_id', inverseJoinColumn: 'id' })
  stockItem: Ref<StockItem>;
}
// --- Service Layer: Custom Creation Method with Transaction Handling ---
import { Injectable } from '@nestjs/common';
import { EntityManager } from '@mikro-orm/core';
import { StockItem } from './stock-item.entity';
import { StockItemStatus } from './stock-item-status.entity';
@Injectable()
export class StockService {
  constructor(private readonly em: EntityManager) {}
  async createStockItem(data: Partial<StockItem>): Promise<StockItem> {
    return this.em.transactional(async (em) => {
      const stockItem = em.create(StockItem, data);
      await em.persistAndFlush(stockItem);
      const status = em.create(StockItemStatus, { stockItem });
      await em.persistAndFlush(status);
      return stockItem;
    });
  }
}
// --- Unit Test for StockService ---
import { Test, TestingModule } from '@nestjs/testing';
import { StockService } from './stock.service';
import { EntityManager } from '@mikro-orm/core';
describe('StockService', () => {
  let service: StockService;
  let mockEm: Partial<EntityManager>;
  beforeEach(async () => {
    mockEm = { transactional: jest.fn((fn) => fn({} as any)) };
    const module: TestingModule = await Test.createTestingModule({
      providers: [StockService, { provide: EntityManager, useValue: mockEm }],
    }).compile();
    service = module.get<StockService>(StockService);
  });
  it('should create a StockItem and its status', async () => {
    const result = await service.createStockItem({ id: 1 });
    expect(result).toBeDefined();
  });
});

// --- StockItem Entity with BeforeCreate Hook ---
import { Entity, PrimaryKey, OneToOne, Ref, BeforeCreate } from '@mikro-orm/core';
@Entity()
export class StockItem {
  @PrimaryKey()
  id: number;
  @OneToOne(() => StockItemStatus, (status) => status.stockItem, { eager: true })
  status: Ref<StockItemStatus>;
  @BeforeCreate()
  createStatus() {
    this.status = new StockItemStatus(this);
  }
}
// --- StockItemStatus Entity ---
import { Entity, PrimaryKey, OneToOne, Ref } from '@mikro-orm/core';
@Entity()
export class StockItemStatus {
  constructor(stockItem: StockItem) {
    this.stockItem = stockItem;
  }
  @PrimaryKey()
  id: number;
  @OneToOne(() => StockItem)
  stockItem: Ref<StockItem>;
}
// --- Stock Service (Same as Above) ---
import { Injectable } from '@nestjs/common';
import { EntityManager } from '@mikro-orm/core';
import { StockItem } from './stock-item.entity';
@Injectable()
export class StockService {
  constructor(private readonly em: EntityManager) {}
  async createStockItem(data: Partial<StockItem>) {
    const stockItem = this.em.create(StockItem, data);
    await this.em.persistAndFlush(stockItem);
    return stockItem;
  }
}

MikroORM மெய்நிகர் காட்சிகளுடன் நிறுவன உறவுகளை மேம்படுத்துதல்

தரவுத்தள காட்சிகளைக் கையாளும் போது MikroORM, வினவல் செயல்திறனை மேம்படுத்துதல் மற்றும் தரவு நிலைத்தன்மையை பராமரிப்பது என்பது அடிக்கடி கவனிக்கப்படாத ஒரு அம்சமாகும். `StockItemStatus` போன்ற ஒரு மெய்நிகர் நிறுவனத்தை உருவாக்கும் போது, ​​தரவைச் சுருக்கிச் சொல்வதில் உள்ள சிக்கலைத் தீர்க்கிறது, திறமையான புதுப்பிப்புகள் மற்றும் தடையற்ற உறவுகளை உறுதி செய்வது சவாலானதாகவே உள்ளது. NestJS இன் சூழலில், டெவலப்பர்கள் பார்வைகளை கவனமாக வரைபடமாக்க வேண்டும் மற்றும் நெகிழ்வுத்தன்மையை அடைய தனிப்பயன் வினவல்கள் போன்ற கருவிகளைப் பயன்படுத்த வேண்டும்.

மெய்நிகர் நிறுவனங்களுக்கு MikroORM இன் தனிப்பயன் வினவல் திறன்களைப் பயன்படுத்துவதே ஒரு தீர்வாகும். எக்ஸ்பிரஷனுடன் `@Entity` ஐ கண்டிப்பாகச் சார்ந்திருப்பதற்குப் பதிலாக, டெவலப்பர்கள் மேம்பட்ட பயன்பாட்டு நிகழ்வுகளுக்கு மூல SQL வினவல்களைச் செயல்படுத்தும் களஞ்சியங்களை உருவாக்கலாம். எடுத்துக்காட்டாக, `stock_item_status` போன்ற ஒரு பார்வை பங்கு மாற்றங்களை ஒருங்கிணைத்தால், ஒரு களஞ்சிய முறையானது தேவையான தரவை மட்டும் எடுத்து கணக்கிட முடியும், சுமை நேரத்தை குறைக்கிறது. இந்த அணுகுமுறை செயல்திறனை மேம்படுத்த விர்ச்சுவல் காட்சிகளை தனிப்பயன் தர்க்கத்துடன் இணைக்கிறது.

கூடுதலாக, MikroORM இல் உள்ள மற்றொரு சக்திவாய்ந்த கருவி `@Filter` அலங்காரம் ஆகும். வினவல்களை மீண்டும் எழுதாமல் மாறும் வகையில் நிபந்தனைகளைப் பயன்படுத்த வடிகட்டிகள் உங்களை அனுமதிக்கின்றன. எடுத்துக்காட்டாக, இயங்கும் நேரத்தில் அவற்றின் நிலையின் அடிப்படையில் நீங்கள் பங்கு பொருட்களை வடிகட்டலாம். நீங்கள் ஒரு ஈ-காமர்ஸ் தளத்தை உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள், அங்கு பங்கு நிலை அடிக்கடி மாறும்: உங்கள் சரக்குகளை திறமையாக வைத்து, நிகழ்நேர புதுப்பிப்புகளுக்கு தொடர்புடைய தரவு மட்டுமே மீட்டெடுக்கப்படுவதை உறுதிசெய்ய வடிப்பான்கள் உதவும். 🚀