@companix/xeo-server 0.0.2 → 0.0.3

package/lib/mongoose.module.ts

@@ -1,95 +0,0 @@
-import * as mongoose from 'mongoose'
-import { DynamicModule, Global, Inject, Module, OnApplicationShutdown } from '@nestjs/common'
-import { ModuleRef } from '@nestjs/core'
-import { ConnectOptions, Connection } from 'mongoose'
-import { defer, lastValueFrom } from 'rxjs'
-import { catchError } from 'rxjs/operators'
-import { MONGOOSE_CONNECTION_NAME } from './constants'
-import { getConnectionToken, handleRetry } from './common'
-import { MongooseModuleOptions } from './mongoose-options.interface'
-
-@Global()
-@Module({})
-export class MongooseCoreModule implements OnApplicationShutdown {
-  constructor(
-    @Inject(MONGOOSE_CONNECTION_NAME) private readonly connectionName: string,
-    private readonly moduleRef: ModuleRef
-  ) {}
-
-  static forRoot(uri: string, options: MongooseModuleOptions = {}): DynamicModule {
-    const {
-      retryAttempts,
-      retryDelay,
-      connectionName,
-      connectionFactory,
-      connectionErrorFactory,
-      lazyConnection,
-      onConnectionCreate,
-      verboseRetryLog,
-      ...mongooseOptions
-    } = options
-
-    const mongooseConnectionFactory = connectionFactory || ((connection) => connection)
-
-    const mongooseConnectionError = connectionErrorFactory || ((error) => error)
-
-    const mongooseConnectionName = getConnectionToken(connectionName)
-
-    const mongooseConnectionNameProvider = {
-      provide: MONGOOSE_CONNECTION_NAME,
-      useValue: mongooseConnectionName
-    }
-
-    const connectionProvider = {
-      provide: mongooseConnectionName,
-      useFactory: async (): Promise<any> =>
-        await lastValueFrom(
-          defer(async () =>
-            mongooseConnectionFactory(
-              await this.createMongooseConnection(uri, mongooseOptions, {
-                lazyConnection,
-                onConnectionCreate
-              }),
-              mongooseConnectionName
-            )
-          ).pipe(
-            handleRetry(retryAttempts, retryDelay, verboseRetryLog),
-            catchError((error) => {
-              throw mongooseConnectionError(error)
-            })
-          )
-        )
-    }
-    return {
-      module: MongooseCoreModule,
-      providers: [connectionProvider, mongooseConnectionNameProvider],
-      exports: [connectionProvider]
-    }
-  }
-
-  private static async createMongooseConnection(
-    uri: string,
-    mongooseOptions: ConnectOptions,
-    factoryOptions: {
-      lazyConnection?: boolean
-      onConnectionCreate?: MongooseModuleOptions['onConnectionCreate']
-    }
-  ): Promise<Connection> {
-    const connection = mongoose.createConnection(uri, mongooseOptions)
-
-    if (factoryOptions?.lazyConnection) {
-      return connection
-    }
-
-    factoryOptions?.onConnectionCreate?.(connection)
-
-    return connection.asPromise()
-  }
-
-  async onApplicationShutdown() {
-    const connection = this.moduleRef.get<any>(this.connectionName)
-    if (connection) {
-      await connection.close()
-    }
-  }
-}

package/lib/storages/data-source.ts

@@ -1,37 +0,0 @@
-import { CollectionScheme, DataScheme, DataSource } from '@companix/xeo-scheme'
-import { Connection } from 'mongoose'
-import { createMongoDriver } from '../drivers/collection.driver'
-import { DATA_SOURCE_TOKEN } from '../constants'
-
-class DataSourceStorageService {
-  private dataSource: DataSource<CollectionScheme> | null = null
-  private dataScheme: DataScheme<CollectionScheme> | null = null
-
-  getProviderToken(dataScheme: DataScheme<CollectionScheme>) {
-    if (this.dataScheme === null) {
-      this.dataScheme = dataScheme
-    }
-
-    if (this.dataScheme !== dataScheme) {
-      throw new Error(`[MongoDriver] driver cannot work with several dataSchemes`)
-    }
-
-    return DATA_SOURCE_TOKEN
-  }
-
-  getSource(dataScheme: DataScheme<CollectionScheme>, connection: Connection) {
-    if (this.dataScheme !== dataScheme) {
-      throw new Error(`[MongoDriver] driver cannot work with several dataSchemes`)
-    }
-
-    if (!this.dataSource) {
-      this.dataSource = new DataSource(dataScheme, {
-        createDriver: createMongoDriver(connection)
-      })
-    }
-
-    return this.dataSource
-  }
-}
-
-export const DataSourceStorage = new DataSourceStorageService()

package/tests/app/bootstrap.ts

@@ -1,16 +0,0 @@
-import { NestFactory } from '@nestjs/core'
-import { RootModule } from './root.module'
-import { ValidationPipe } from '@nestjs/common'
-import { AllExceptionsFilter } from './filters'
-
-export const bootstrap = async (port = 3111) => {
-  const app = await NestFactory.create(RootModule)
-
-  app.useGlobalFilters(new AllExceptionsFilter())
-  app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }))
-
-  await app.listen(port)
-  console.log(`Application is running on: http://localhost:${port}/app`)
-
-  return app
-}

package/tests/app/db.ts

@@ -1,22 +0,0 @@
-import { MongooseModuleOptions } from '../../lib/mongoose-options.interface'
-
-const DB_NAME = 'xeo-test'
-const DB_PORT = 27017
-const DB_AUTH = 'admin'
-const DB_PASS = 'example'
-const DB_HOST = '127.0.0.1'
-const DB_CERT = ''
-const DB_USER = 'root'
-
-export const getMongoConnectionURL = (): string => {
-  return `mongodb://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/`
-}
-
-export const getMongoConnectionOptions = (): MongooseModuleOptions => {
-  return {
-    tls: DB_CERT ? true : false,
-    tlsCAFile: DB_CERT,
-    dbName: DB_NAME,
-    authSource: DB_AUTH
-  }
-}

package/tests/app/filters.ts

@@ -1,25 +0,0 @@
-import { CoreError } from '@companix/xeo-scheme'
-import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common'
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  catch(exception: any, host: ArgumentsHost) {
-    const ctx = host.switchToHttp()
-    const response = ctx.getResponse()
-
-    // core conflicts
-    if (exception instanceof CoreError) {
-      console.log('core exception:', exception)
-      response.status(HttpStatus.BAD_REQUEST).json(exception)
-      return
-    }
-
-    // internal server errors
-    if (exception instanceof HttpException) {
-      response.status(exception.getStatus()).json(exception.getResponse())
-      return
-    }
-
-    response.status(HttpStatus.INTERNAL_SERVER_ERROR).json(exception?.response)
-  }
-}

package/tests/app/helpers/is-one-of.ts

@@ -1,58 +0,0 @@
-import { plainToInstance } from 'class-transformer'
-import {
-  ValidatorConstraint,
-  ValidatorConstraintInterface,
-  ValidationArguments,
-  validate,
-  ValidationOptions,
-  registerDecorator
-} from 'class-validator'
-
-@ValidatorConstraint({ async: true })
-export class IsOneOfDtoConstraint implements ValidatorConstraintInterface {
-  async validate(value: any, args: ValidationArguments) {
-    const [dtos, discriptor] = args.constraints as [any[], string]
-
-    if (!value) {
-      return false
-    }
-
-    const dto = dtos.find((some) => {
-      const classDescriptor = new some()[discriptor]
-
-      if (classDescriptor) {
-        return classDescriptor === value[discriptor]
-      }
-
-      console.warn('WARN: Set descriptor value to:', some)
-    })
-
-    if (dto) {
-      const errors = await validate(plainToInstance(dto, value))
-
-      if (errors.length === 0) {
-        return true
-      }
-
-      console.error('ERRORs: ', dto, errors)
-    }
-
-    return false
-  }
-
-  defaultMessage(args: ValidationArguments) {
-    return 'Data does not match'
-  }
-}
-
-export function IsOneOf(dtos: [Function[], string], validationOptions?: ValidationOptions) {
-  return function (object: Object, propertyName: string) {
-    registerDecorator({
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      constraints: dtos,
-      validator: IsOneOfDtoConstraint
-    })
-  }
-}

package/tests/app/main.ts

@@ -1,3 +0,0 @@
-import { bootstrap } from './bootstrap'
-
-bootstrap()

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

@@ -1,67 +0,0 @@
-import { Body, Controller, Get, Post } from '@nestjs/common'
-import {
-  CreateBankCardDto,
-  CreateBankDetailDto,
-  CreateDictionaryDto,
-  CreateOptionDto,
-  CreateRoleDto,
-  CreateScanDto,
-  CreateWorkerDto,
-  UpdateOptionDto
-} from './app.dto'
-import { AppService } from './app.service'
-
-@Controller('app')
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Post('addWorker')
-  async addWorker(@Body() dto: CreateWorkerDto) {
-    return this.appService.addWorker(dto)
-  }
-
-  @Post('addScan')
-  async addScan(@Body() dto: CreateScanDto) {
-    return this.appService.addScan(dto)
-  }
-
-  @Post('addBankCard')
-  async addBankCard(@Body() dto: CreateBankCardDto) {
-    return this.appService.addBankCard(dto)
-  }
-
-  @Post('addBankDetail')
-  async addBankDetail(@Body() dto: CreateBankDetailDto) {
-    return this.appService.addBankDetail(dto)
-  }
-
-  @Post('addRole')
-  async addRole(@Body() dto: CreateRoleDto) {
-    return this.appService.addRole(dto)
-  }
-
-  @Post('addDictionary')
-  async addDictionary(@Body() dto: CreateDictionaryDto) {
-    return this.appService.addDictionary(dto)
-  }
-
-  @Post('addOption')
-  async addOption(@Body() dto: CreateOptionDto) {
-    return this.appService.addOption(dto)
-  }
-
-  @Post('updateOption')
-  async updateOption(@Body() dto: UpdateOptionDto) {
-    return this.appService.updateOption(dto)
-  }
-
-  @Get()
-  async getState() {
-    return this.appService.getState()
-  }
-
-  @Get('tables')
-  async getTables() {
-    return this.appService.getTables()
-  }
-}

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

@@ -1,394 +0,0 @@
-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
-}