@companix/xeo-server 0.0.2

package/lib/factories/definitions.factory.ts

@@ -0,0 +1,129 @@
+import {
+  CollectionScheme,
+  DataScheme,
+  ModelProperties,
+  PropertyRelation,
+  PropertyMetadata,
+  ModelScheme
+} from '@companix/xeo-scheme'
+import type { SchemaDefinition, SchemaDefinitionProperty } from 'mongoose'
+import { Schema } from 'mongoose'
+
+const TypesTranslator = {
+  string: String,
+  number: Number,
+  json: Object,
+  boolean: Boolean
+}
+
+export class DefinitionsFactory<T extends CollectionScheme> {
+  constructor(private dataScheme: DataScheme<T>) {}
+
+  createForCollection(name: keyof T): SchemaDefinition {
+    return this.createForScheme(this.dataScheme.models[this.dataScheme.collections[name].name].scheme)
+  }
+
+  createForScheme(scheme: ModelScheme): SchemaDefinition {
+    return {
+      [scheme.identifier.propertyKey]: {
+        index: true,
+        type: TypesTranslator[scheme.identifier.options.type],
+        unique: true
+      },
+      ...this.createDefinitionScheme(scheme)
+    }
+  }
+
+  createDefinitionScheme({ properties, references }: ModelProperties): SchemaDefinition {
+    const map: SchemaDefinition = {}
+
+    for (const property of properties) {
+      map[property.propertyKey] = this.getPropertyDefinition(property)
+    }
+
+    for (const reference of references) {
+      map[reference.propertyKey] = this.getRelationDefinition(reference)
+    }
+
+    return map
+  }
+
+  private getPropertyDefinition({ primitive }: PropertyMetadata): SchemaDefinitionProperty {
+    switch (primitive.type) {
+      case 'embedded': {
+        return {
+          _id: false, //  prevent creating _id (без указания mongodb создавал бы _id для всех вложенных объектов)
+          type: this.createDefinitionScheme(primitive),
+          required: true
+        }
+      }
+      case 'array': {
+        return {
+          type: [TypesTranslator[primitive.itemType]],
+          required: true
+        }
+      }
+      case 'literal': {
+        return {
+          type: Schema.Types.Mixed, // сузить до String и Number
+          enum: primitive.values,
+          required: !primitive.nullable
+        }
+      }
+      case 'enum': {
+        return {
+          type: [String], // может быть и Number
+          enum: primitive.values,
+          required: !primitive.nullable
+        }
+      }
+      default: {
+        return {
+          type: TypesTranslator[primitive.type]
+        }
+      }
+    }
+  }
+
+  private getRelationDefinition(reference: PropertyRelation): SchemaDefinitionProperty {
+    const refModel = this.dataScheme.metadata.getModelSchemaByTarget(reference.referenceModel)
+
+    switch (reference.refType) {
+      case 'reference-to': {
+        return {
+          type: TypesTranslator[refModel.identifier.options.type],
+          required: (reference.options?.onRefDeleting ?? 'restrict') === 'restrict'
+        }
+      }
+      case 'reference-set': {
+        return {
+          type: [TypesTranslator[refModel.identifier.options.type]]
+        }
+      }
+      case 'belongs-to': {
+        return {
+          type: TypesTranslator[refModel.identifier.options.type],
+          required: true
+        }
+      }
+      case 'has-many': {
+        return {
+          type: [TypesTranslator[refModel.identifier.options.type]],
+          required: true
+        }
+      }
+      case 'owner': {
+        return {
+          type: TypesTranslator[refModel.identifier.options.type],
+          required: true
+        }
+      }
+      case 'owner-fallback': {
+        return {
+          type: TypesTranslator[refModel.identifier.options.type],
+          refType: 'owner-fallback'
+        }
+      }
+    }
+  }
+}

package/lib/index.ts

@@ -0,0 +1,3 @@
+export * from './common'
+export * from './drivers/table.driver'
+export * from './driver.module'

package/lib/mongoose-options.interface.ts

@@ -0,0 +1,19 @@
+import { ConnectOptions, Connection, MongooseError } from 'mongoose'
+
+/**
+ * @publicApi
+ */
+export interface MongooseModuleOptions extends ConnectOptions {
+  uri?: string
+  retryAttempts?: number
+  retryDelay?: number
+  connectionName?: string
+  connectionFactory?: (connection: any, name: string) => any
+  connectionErrorFactory?: (error: MongooseError) => MongooseError
+  lazyConnection?: boolean
+  onConnectionCreate?: (connection: Connection) => void
+  /**
+   * If `true`, will show verbose error messages on each connection retry.
+   */
+  verboseRetryLog?: boolean
+}

package/lib/mongoose.module.ts

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

@@ -0,0 +1,37 @@
+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/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@companix/xeo-server",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "echo": "echo \"@companix/xeo-server\"",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "test:unit": "tsc --noEmit && tsx ./tests/unit/definitions.ts",
+    "test:app": "nest start --watch --builder tsc --path tsconfig.test-app.json --sourceRoot tests/app --entryFile main",
+    "test:custom": "nest start --watch --builder tsc --path tsconfig.test-app.json --sourceRoot tests --entryFile integrations/custom.test",
+    "test:cases": "jest --config ./jest.cases.config.cjs --runInBand"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.1.17",
+    "@nestjs/core": "^11.1.17",
+    "@nestjs/platform-express": "^11.1.12",
+    "@types/jest": "^30.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "eslint-config-react-app": "^7.0.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-react": "^7.34.3",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-webpack-plugin": "^4.2.0",
+    "jest": "^30.3.0",
+    "mongoose": "^9.3.3",
+    "rxjs": "^7.8.2",
+    "ts-jest": "^29.4.6",
+    "zod": "^4.3.6"
+  },
+  "dependencies": {
+    "@companix/utils-js": "*",
+    "@companix/xeo-scheme": "*"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "mongoose": "^9.0.0",
+    "rxjs": "^7.0.0"
+  }
+}

package/tests/app/bootstrap.ts

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

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

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

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

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

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

@@ -0,0 +1,67 @@
+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()
+  }
+}