@companix/xeo-server 0.0.2

package/tests/app/module/app.dto.ts

@@ -0,0 +1,394 @@
+import { Type } from 'class-transformer'
+import {
+  IsArray,
+  IsBoolean,
+  IsEmail,
+  IsIn,
+  IsNotEmptyObject,
+  IsNumber,
+  IsObject,
+  IsString,
+  ValidateIf,
+  ValidateNested
+} from 'class-validator'
+import type { DateFormat, FileFormat } from '@companix/utils-js'
+import { WorkerEntities, DictionaryEntities, RoleEntities, AppKey, AppKeys } from '@companix/xeo-devkit'
+
+export class DateFormatDto implements DateFormat {
+  @IsNumber()
+  year: number
+
+  @IsNumber()
+  month: number
+
+  @IsNumber()
+  day: number
+}
+
+export class FilmDto implements WorkerEntities.Film {
+  @IsString()
+  anime: string
+
+  @IsBoolean()
+  isTheater: boolean
+
+  @IsArray()
+  @IsString({ each: true })
+  actors: string[]
+}
+
+export class ContactsDto implements WorkerEntities.Contacts {
+  @IsString()
+  phone_base: string
+
+  @IsBoolean()
+  phone_base_verified: boolean
+
+  @IsString()
+  phone_extra: string
+
+  @IsBoolean()
+  phone_extra_verified: boolean
+
+  @IsString()
+  whatsapp_phone: string
+
+  @IsBoolean()
+  whatsapp_verified: boolean
+
+  @IsString()
+  viber_phone: string
+
+  @IsBoolean()
+  viber_verified: boolean
+
+  @IsString()
+  telegram_nickname: string
+
+  @IsString()
+  telegram_phone: string
+
+  @IsBoolean()
+  telegram_phone_verified: boolean
+
+  @ValidateNested()
+  @Type(() => FilmDto)
+  film: FilmDto
+}
+
+export class AboutDto implements WorkerEntities.About {
+  @ValidateIf((_, value) => value !== null)
+  @IsNumber()
+  height: number | null
+
+  @IsString()
+  shoe_size: string
+
+  @IsString()
+  clothing_size: string
+
+  @IsArray()
+  @IsString({ each: true })
+  regions: string[]
+
+  @IsArray()
+  @IsString({ each: true })
+  kind_of_work: string[]
+
+  @IsArray()
+  @IsString({ each: true })
+  employments: string[]
+}
+
+export class DocumentsDto implements WorkerEntities.Documents {
+  @ValidateIf((_, value) => value !== null)
+  @IsIn(AppKeys.Citizenship)
+  citizenship: AppKey.Citizenship | null
+
+  @IsString()
+  passport_number: string
+
+  @IsString()
+  passport_serial: string
+
+  @IsString()
+  passport_issued_by: string
+
+  @ValidateIf((_, value) => value !== null)
+  @ValidateNested()
+  @Type(() => DateFormatDto)
+  passport_issued_date: DateFormat | null
+
+  @IsString()
+  place_of_birth: string
+
+  @IsString()
+  registration_place: string
+
+  @IsString()
+  inn: string
+
+  @IsString()
+  snils: string
+}
+
+export class WorkerBaseDto implements WorkerEntities.BaseWorker {
+  @IsNumber()
+  workerId: number
+
+  @IsIn(['office', 'revisor'])
+  type: 'office' | 'revisor'
+
+  @ValidateIf((_, value) => value !== null)
+  @IsNumber()
+  tgid: number | null
+
+  @IsNumber()
+  createdAt: number
+
+  @IsObject()
+  avatar: FileFormat
+
+  @IsString()
+  name: string
+
+  @IsString()
+  surname: string
+
+  @IsString()
+  patronymic: string
+
+  @IsEmail()
+  email: string
+
+  @IsIn(AppKeys.Sex)
+  sex: AppKey.Sex
+
+  @IsIn(AppKeys.WorkerStatus)
+  status: AppKey.WorkerStatus
+
+  @ValidateNested()
+  @Type(() => DateFormatDto)
+  date_birth: DateFormat
+
+  @ValidateNested()
+  @Type(() => DateFormatDto)
+  date_employ: DateFormat
+
+  @ValidateNested()
+  @Type(() => ContactsDto)
+  contacts: ContactsDto
+
+  @ValidateNested()
+  @Type(() => DocumentsDto)
+  documents: DocumentsDto
+
+  @ValidateNested()
+  @Type(() => AboutDto)
+  about: AboutDto
+
+  @IsArray()
+  @IsString({ each: true })
+  scans: string[]
+
+  @IsArray()
+  @IsString({ each: true })
+  bank_cards: string[]
+
+  @IsArray()
+  @IsString({ each: true })
+  bank_details: string[]
+}
+
+export class OfficeProfileDto extends WorkerBaseDto implements WorkerEntities.OfficeProfile {
+  @IsIn(['office'])
+  type: 'office' = 'office'
+
+  @IsString()
+  password: string
+
+  @IsArray()
+  @IsString({ each: true })
+  roles: RoleEntities.Role['value'][]
+}
+
+export class RevisorProfileDto extends WorkerBaseDto implements WorkerEntities.RevisorProfile {
+  @IsIn(['revisor'])
+  type: 'revisor' = 'revisor'
+
+  @IsString()
+  password: string
+
+  @IsIn(AppKeys.RevisorRoles)
+  revisor_role: AppKey.RevisorRoles
+
+  @IsIn(AppKeys.JobType)
+  job_type: AppKey.JobType
+
+  seats: string[]
+}
+
+export class CreateWorkerDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => WorkerBaseDto, {
+    discriminator: {
+      property: 'type',
+      subTypes: [
+        { name: 'office', value: OfficeProfileDto },
+        { name: 'revisor', value: RevisorProfileDto }
+      ]
+    },
+    keepDiscriminatorProperty: true
+  })
+  worker: OfficeProfileDto | RevisorProfileDto
+}
+
+export class ScanDto implements WorkerEntities.Scan {
+  @IsString()
+  scanId: string
+
+  @IsString()
+  name: string
+
+  @IsObject()
+  file: FileFormat
+
+  @IsNumber()
+  createdAt: number
+}
+
+export class CreateScanDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => ScanDto)
+  scan: ScanDto
+}
+
+export class BankCardDto implements WorkerEntities.BankCard {
+  @IsString()
+  cardId: string
+
+  @IsString()
+  bank_name: string
+
+  @IsString()
+  bank_card_number: string
+
+  @IsString()
+  comment: string
+
+  @IsBoolean()
+  is_default_card: boolean
+
+  @IsObject()
+  image: FileFormat
+
+  @IsNumber()
+  createdAt: number
+}
+
+export class CreateBankCardDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => BankCardDto)
+  bankCard: BankCardDto
+}
+
+export class BankDetailDto implements WorkerEntities.BankDetail {
+  @IsString()
+  detailId: string
+
+  @IsString()
+  recipient_name: string
+
+  @IsString()
+  bank_name: string
+
+  @IsString()
+  recipient_count: string
+
+  @IsString()
+  kor: string
+
+  @IsString()
+  bik: string
+
+  @IsString()
+  kpp: string
+
+  @IsString()
+  inn: string
+
+  @IsNumber()
+  createdAt: number
+}
+
+export class CreateBankDetailDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => BankDetailDto)
+  bankDetail: BankDetailDto
+}
+
+export class RoleDto implements RoleEntities.Role {
+  @IsString()
+  value: string
+
+  @IsString()
+  title: string
+
+  @IsNumber()
+  createdAt: number
+}
+
+export class CreateRoleDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => RoleDto)
+  role: RoleDto
+}
+
+export class DictionaryDto implements DictionaryEntities.Dictionary {
+  @IsIn(AppKeys.Dictionaries)
+  dictionary: AppKey.Dictionaries
+
+  @IsString()
+  name: string
+
+  @IsArray()
+  @IsString({ each: true })
+  options: DictionaryEntities.Option['value'][]
+}
+
+export class CreateDictionaryDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => DictionaryDto)
+  dictionary: DictionaryDto
+}
+
+export class OptionDto implements DictionaryEntities.Option {
+  @IsIn(AppKeys.Dictionaries)
+  dictionary: AppKey.Dictionaries
+
+  @IsString()
+  value: string
+
+  @IsString()
+  title: string
+}
+
+export class CreateOptionDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => OptionDto)
+  option: OptionDto
+}
+
+export class UpdateOptionDto {
+  @IsNotEmptyObject()
+  @ValidateNested()
+  @Type(() => OptionDto)
+  option: OptionDto
+}

package/tests/app/module/app.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common'
+import { MongooseDriverModule } from '../../../lib'
+import { AppService } from './app.service'
+import { AppController } from './app.controller'
+import { dataScheme } from '@companix/xeo-devkit'
+
+@Module({
+  imports: [MongooseDriverModule.forFeature(dataScheme)],
+  controllers: [AppController],
+  providers: [AppService]
+})
+export class AppModule {}

package/tests/app/module/app.service.ts

@@ -0,0 +1,76 @@
+import { Injectable } from '@nestjs/common'
+import { InjectDataSource } from '../../../lib'
+import { dataScheme, AppScheme } from '@companix/xeo-devkit'
+import { DataSource } from '@companix/xeo-scheme'
+import {
+  CreateBankCardDto,
+  CreateBankDetailDto,
+  CreateDictionaryDto,
+  CreateOptionDto,
+  CreateRoleDto,
+  CreateScanDto,
+  CreateWorkerDto,
+  UpdateOptionDto
+} from './app.dto'
+import { MongoCollectionDriver } from '../../../lib/drivers/collection.driver'
+
+@Injectable()
+export class AppService {
+  constructor(
+    @InjectDataSource(dataScheme)
+    private readonly dataSource: DataSource<AppScheme, MongoCollectionDriver<AppScheme>>
+  ) {}
+
+  async addWorker({ worker }: CreateWorkerDto) {
+    return this.dataSource.collections.worker.create(worker)
+  }
+
+  async addScan({ scan }: CreateScanDto) {
+    return this.dataSource.collections.scan.create(scan)
+  }
+
+  async addBankCard({ bankCard }: CreateBankCardDto) {
+    return this.dataSource.collections.bankCard.create(bankCard)
+  }
+
+  async addBankDetail({ bankDetail }: CreateBankDetailDto) {
+    return this.dataSource.collections.bankDetail.create(bankDetail)
+  }
+
+  async addRole({ role }: CreateRoleDto) {
+    return this.dataSource.collections.role.create(role)
+  }
+
+  async addDictionary({ dictionary }: CreateDictionaryDto) {
+    return this.dataSource.collections.dictionaries.create(dictionary)
+  }
+
+  async addOption({ option }: CreateOptionDto) {
+    return this.dataSource.collections.options.create(option)
+  }
+
+  async updateOption({ option }: UpdateOptionDto) {
+    return this.dataSource.collections.options.update(option.value, (target) => {
+      target.dictionary = option.dictionary
+      target.title = option.title
+    })
+  }
+
+  async getState() {
+    return {
+      worker: await this.dataSource.collections.worker.getAll(),
+      scan: await this.dataSource.collections.scan.getAll(),
+      bankCard: await this.dataSource.collections.bankCard.getAll(),
+      bankDetail: await this.dataSource.collections.bankDetail.getAll(),
+      // role
+      role: await this.dataSource.collections.role.getAll(),
+      // options
+      dictionaries: await this.dataSource.collections.dictionaries.getAll(),
+      options: await this.dataSource.collections.options.getAll()
+    }
+  }
+
+  async getTables() {
+    return this.dataSource.driver.tables.getTables()
+  }
+}

package/tests/app/root.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common'
+import { AppModule } from './module/app.module'
+import { MongooseDriverModule } from '../../lib'
+import { getMongoConnectionOptions, getMongoConnectionURL } from './db'
+
+@Module({
+  imports: [
+    MongooseDriverModule.forRoot(getMongoConnectionURL(), getMongoConnectionOptions()),
+    AppModule //
+  ]
+})
+export class RootModule {}

package/tests/globals.d.ts

@@ -0,0 +1,6 @@
+/* eslint-disable no-var */
+declare global {
+  var __DEV__: boolean | undefined
+}
+
+export {}

package/tests/integrations/cases.test.ts

@@ -0,0 +1,154 @@
+import { writeFile } from 'fs'
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from '@jest/globals'
+import { DataSource, IndexedTableStore, TableRow, TableStore } from '@companix/xeo-scheme'
+import { getConnectionToken, getDataSourceToken } from '../../lib'
+
+import { bootstrap } from '../app/bootstrap'
+import { MongoCollectionDriver } from '../../lib/drivers/collection.driver'
+import { AppScheme, BaseParams, MockKit, cases, createMockKit, dataScheme } from '@companix/xeo-devkit'
+import { Connection } from 'mongoose'
+import { INestApplication } from '@nestjs/common'
+
+interface TestOptions {
+  params: BaseParams
+  commitChanges: (kit: MockKit, dataSource: DataSource<AppScheme>) => Promise<void>
+}
+
+const normalizeCollection = <T>(records: T[]) => {
+  return records.map((record) => {
+    if (!record || typeof record !== 'object' || Array.isArray(record)) {
+      return record
+    }
+
+    const { _id, __v, ...rest } = record as Record<string, unknown>
+    return rest as T
+  })
+}
+
+const normalizeTableState = (tableState: { m1: TableStore; m2: TableStore }) => {
+  const normalizeSide = (side: TableStore): TableStore => {
+    const normalized: TableStore = {}
+
+    for (const key of Object.keys(side).sort()) {
+      normalized[key] = [...side[key]].sort((a, b) => String(a).localeCompare(String(b)))
+    }
+
+    return normalized
+  }
+
+  return {
+    m1: normalizeSide(tableState.m1),
+    m2: normalizeSide(tableState.m2)
+  }
+}
+
+const getTablesState = async (tables: { [name: string]: TableRow[] }) => {
+  const state: BaseParams['expectations']['tables'] = {}
+
+  for (const table of dataScheme.tables) {
+    const indexedStore = new IndexedTableStore(table)
+    indexedStore.initialize(tables[table.tableName] ?? [])
+    state[table.tableName] = normalizeTableState(indexedStore.getStore())
+  }
+
+  return state
+}
+
+const runTest = async (app: INestApplication<any>, { params, commitChanges }: TestOptions) => {
+  const { expectations } = params
+  const dataSource = app.get<DataSource<AppScheme, MongoCollectionDriver<AppScheme>>>(
+    getDataSourceToken(dataScheme)
+  )
+
+  await commitChanges(createMockKit(dataSource), dataSource).catch((error) => {
+    expect(error).toEqual(expectations.error)
+  })
+
+  const snapshot = { result: {} as object, table: {} as object }
+
+  for (const collection in dataSource.collections) {
+    const collectionName = collection as keyof AppScheme
+
+    await dataSource.collections[collectionName].getAll().then((result) => {
+      snapshot.result[collectionName] = result
+      expect(normalizeCollection(result)).toEqual(expectations.scheme[collectionName] ?? [])
+    })
+  }
+
+  const tableRows = await dataSource.driver.tables.getTables()
+  const tables = await getTablesState(tableRows)
+
+  snapshot.table = tableRows
+
+  for (const table of dataScheme.tables) {
+    try {
+      expect(tables[table.tableName] ?? { m1: {}, m2: {} }).toEqual(
+        normalizeTableState(expectations.tables[table.tableName] ?? { m1: {}, m2: {} })
+      )
+    } catch (error) {
+      throw error
+    }
+  }
+
+  return snapshot
+}
+
+describe('DataSource', () => {
+  let app: INestApplication
+
+  const buffer: object[] = []
+
+  beforeAll(async () => {
+    app = await bootstrap(3222)
+  })
+
+  beforeEach(async () => {
+    const connection = app.get<Connection>(getConnectionToken())
+    await connection.dropDatabase()
+  })
+
+  afterAll(async () => {
+    const connection = app.get<Connection>(getConnectionToken())
+
+    await new Promise<void>((resolve) => {
+      writeFile(`./tests/${Date.now()}.test.json`, JSON.stringify(buffer), (err) => {
+        if (err) {
+          console.log('writeFile:', err)
+          return
+        }
+
+        resolve()
+      })
+    })
+
+    await connection.dropDatabase()
+    await app.close()
+  })
+
+  for (const item of cases) {
+    if (item.type === 'unit') {
+      test(item.name, async () => {
+        const snapshot = await runTest(app, {
+          params: item.params,
+          commitChanges: (kit, dataSource) => item.params.execute(kit, dataSource)
+        })
+
+        buffer.push({ name: item.name, snapshot })
+      })
+    }
+
+    if (item.type === 'dual') {
+      for (const marker of item.markers) {
+        test(`${item.name} / ${marker}`, async () => {
+          const snapshot = await runTest(app, {
+            params: item.params,
+            commitChanges: (kit, dataSource) => item.params.execute(kit, dataSource, marker)
+          })
+
+          buffer.push({ name: item.name, snapshot })
+        })
+      }
+    }
+  }
+})