@companix/xeo-server 0.0.2 → 0.0.3

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@companix/xeo-server",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "echo": "echo \"@companix/xeo-server\"",
     "build": "rm -rf dist && tsc -p tsconfig.build.json",

package/.eslintrc

@@ -1,54 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "browser": true,
-    "es6": true
-  },
-  "extends": [
-    "plugin:react/recommended",
-    "plugin:react-hooks/recommended",
-    "react-app"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["react"],
-  "parserOptions": {
-    "sourceType": "module",
-    "requireConfigFile": false,
-    "ecmaFeatures": {
-      "jsx": true
-    }
-  },
-  "settings": {
-    "react": {
-      "version": "detect"
-    }
-  },
-  "rules": {
-    "no-var": "error",
-    "typescript-eslint/typescript-estree": "off",
-    "react-hooks/exhaustive-deps": "off",
-    "react/react-in-jsx-scope": "off",
-    "react/no-children-prop": "off",
-    "react/display-name": "off",
-    "jsx-a11y/aria-role": "off",
-    "react/prop-types": "off",
-    "react/jsx-no-target-blank": "off",
-    "import/no-anonymous-default-export": "off",
-    "import/no-extraneous-dependencies": [
-      "error",
-      {
-        "devDependencies": true,
-        "peerDependencies": false
-      }
-    ],
-    "no-throw-literal": "off",
-    "react/no-multi-comp": [2, { "ignoreStateless": true }],
-    "no-restricted-syntax": [
-      "error",
-      {
-        "selector": "CallExpression[arguments.length=1][callee.property.name='reduce']",
-        "message": "Provide initialValue to .reduce()."
-      }
-    ]
-  }
-}

package/jest.cases.config.cjs

@@ -1,14 +0,0 @@
-module.exports = {
-  testEnvironment: 'node',
-  roots: ['<rootDir>/tests/integrations'],
-  testMatch: ['**/cases.test.ts'],
-  moduleFileExtensions: ['ts', 'js', 'json'],
-  transform: {
-    '^.+\\.ts$': [
-      'ts-jest',
-      {
-        tsconfig: '<rootDir>/tsconfig.test-app.json'
-      }
-    ]
-  }
-}

package/lib/common/decorators.ts

@@ -1,17 +0,0 @@
-import { Inject } from '@nestjs/common'
-import { getConnectionToken, getDataSourceToken } from './tokens'
-import { CollectionScheme, DataScheme } from '@companix/xeo-scheme'
-
-/**
- * @publicApi
- */
-export const InjectDataSource = (dataSource: DataScheme<CollectionScheme>) => {
-  return Inject(getDataSourceToken(dataSource))
-}
-
-/**
- * @publicApi
- */
-export const InjectConnection = () => {
-  return Inject(getConnectionToken())
-}

package/lib/common/index.ts

@@ -1,3 +0,0 @@
-export * from './decorators'
-export * from './tokens'
-export * from './utils'

package/lib/common/tokens.ts

@@ -1,17 +0,0 @@
-import { DEFAULT_DB_CONNECTION } from '../constants'
-import { CollectionScheme, DataScheme } from '@companix/xeo-scheme'
-import { DataSourceStorage } from '../storages/data-source'
-
-/**
- * @publicApi
- */
-export const getConnectionToken = (name?: string) => {
-  return name && name !== DEFAULT_DB_CONNECTION ? `${name}Connection` : DEFAULT_DB_CONNECTION
-}
-
-/**
- * @publicApi
- */
-export const getDataSourceToken = (dataScheme: DataScheme<CollectionScheme>) => {
-  return DataSourceStorage.getProviderToken(dataScheme)
-}

package/lib/common/utils.ts

@@ -1,29 +0,0 @@
-import { Logger } from '@nestjs/common'
-import { Observable } from 'rxjs'
-import { delay, retryWhen, scan } from 'rxjs/operators'
-
-export const handleRetry = (retryAttempts = 9, retryDelay = 3000, verboseRetryLog = false) => {
-  const logger = new Logger('MongooseModule')
-
-  return <T>(source: Observable<T>) =>
-    source.pipe(
-      retryWhen((e) =>
-        e.pipe(
-          scan((errorCount, error) => {
-            const verboseMessage = verboseRetryLog ? ` Message: ${error.message}.` : ''
-            const retryMessage = retryAttempts > 0 ? ` Retrying (${errorCount + 1})...` : ''
-
-            logger.error(
-              ['Unable to connect to the database.', verboseMessage, retryMessage].join(''),
-              error.stack
-            )
-            if (errorCount + 1 >= retryAttempts) {
-              throw error
-            }
-            return errorCount + 1
-          }, 0),
-          delay(retryDelay)
-        )
-      )
-    )
-}

package/lib/constants.ts

@@ -1,4 +0,0 @@
-export const DEFAULT_DB_CONNECTION = 'XeoDatabaseConnection'
-export const MONGOOSE_MODULE_OPTIONS = 'XeoMongooseModuleOptions'
-export const MONGOOSE_CONNECTION_NAME = 'XeoMongooseConnectionName'
-export const DATA_SOURCE_TOKEN = `XEO_DATA_SOURCE`

package/lib/driver.module.ts

@@ -1,37 +0,0 @@
-import { Provider } from '@nestjs/common'
-import { DynamicModule, Module } from '@nestjs/common'
-import { getConnectionToken, getDataSourceToken } from './common/tokens'
-import { Connection } from 'mongoose'
-import { CollectionScheme, DataScheme, DataSource } from '@companix/xeo-scheme'
-import { MongooseCoreModule } from './mongoose.module'
-import { MongooseModuleOptions } from './mongoose-options.interface'
-import { DataSourceStorage } from './storages/data-source'
-
-/**
- * @publicApi
- */
-@Module({})
-export class MongooseDriverModule {
-  static forRoot(uri: string, options: MongooseModuleOptions = {}): DynamicModule {
-    return {
-      module: MongooseDriverModule,
-      imports: [MongooseCoreModule.forRoot(uri, options)]
-    }
-  }
-
-  static forFeature(dataSource: DataScheme<CollectionScheme>, connectionName?: string): DynamicModule {
-    const provider: Provider = {
-      provide: getDataSourceToken(dataSource),
-      useFactory: (connection: Connection): DataSource<CollectionScheme> => {
-        return DataSourceStorage.getSource(dataSource, connection)
-      },
-      inject: [getConnectionToken(connectionName)]
-    }
-
-    return {
-      module: MongooseDriverModule,
-      providers: [provider],
-      exports: [provider]
-    }
-  }
-}

package/lib/drivers/collection.driver.ts

@@ -1,157 +0,0 @@
-import {
-  CollectionDriver,
-  CollectionDriverParams,
-  CollectionScheme,
-  DataScheme
-} from '@companix/xeo-scheme'
-import { MongoRelationsTable } from './table.driver'
-import { Connection, Model, Schema } from 'mongoose'
-import { DefinitionsFactory } from '../factories/definitions.factory'
-import { Logger } from '@nestjs/common'
-
-interface DiscriminatedModels {
-  [model: string]: {
-    discriminatorKey: string
-    models: {
-      [value: string]: Model<any>
-    }
-  }
-}
-
-export class MongoCollectionDriver<T extends CollectionScheme> implements CollectionDriver {
-  private collections: { [model: string]: Model<any> } = {}
-  private discriminatedModels: DiscriminatedModels = {}
-
-  public tables: MongoRelationsTable<T>
-
-  constructor(private dataScheme: DataScheme<T>, private connection: Connection) {
-    Logger.log('Driver bootstrap', 'MongoDriver')
-
-    this.tables = new MongoRelationsTable(dataScheme, connection)
-
-    const factory = new DefinitionsFactory(dataScheme)
-
-    for (const name in dataScheme.collections) {
-      const model = dataScheme.collections[name].name
-      const scheme = dataScheme.models[model].scheme
-
-      const baseDefinition = factory.createForScheme(scheme)
-
-      if (scheme.type === 'base') {
-        this.collections[model] = this.useModel(model, new Schema(baseDefinition))
-      }
-
-      if (scheme.type === 'discriminated') {
-        this.collections[model] = this.useModel(
-          model,
-          new Schema(baseDefinition, {
-            discriminatorKey: scheme.discriminatorKey
-          })
-        )
-
-        this.discriminatedModels[model] = {
-          discriminatorKey: scheme.discriminatorKey,
-          models: {}
-        }
-
-        for (const discriminator of scheme.discriminators) {
-          const discriminatedModel = this.collections[model].discriminator(
-            discriminator.name,
-            new Schema(factory.createDefinitionScheme(discriminator)),
-            discriminator.value
-          )
-
-          this.discriminatedModels[model].models[discriminator.value] = discriminatedModel
-        }
-      }
-    }
-  }
-
-  async getAll({ model }: CollectionDriverParams.Model) {
-    return this.collections[model].find().lean().exec()
-  }
-
-  async get({ model, id }: CollectionDriverParams.Record) {
-    return this.collections[model].findOne({ [this.getIdentifierKey(model)]: id }).lean()
-  }
-
-  async create({ model, data }: CollectionDriverParams.Create) {
-    await new this.collections[model](data).save()
-  }
-
-  async remove({ model, id }: CollectionDriverParams.Record) {
-    await this.collections[model].deleteOne({ [this.getIdentifierKey(model)]: id }).exec()
-  }
-
-  // при update для discriminated collection нельзя всегда использовать только this.collections[model]
-  // нужно сначала получить документ по id, узнать его discriminatorKey (type), и если это дискриминатор, выполнять updateOne() через соответствующую discriminator model
-  async update({ model, id, patches }: CollectionDriverParams.Update) {
-    const identifierKey = this.getIdentifierKey(model)
-    const collection = await this.getCollection({ model, id })
-
-    const responses = await Promise.all(
-      patches.map(async (patch) => {
-        switch (patch.type) {
-          case 'set': {
-            return collection.updateOne(
-              { [identifierKey]: id },
-              { $set: { [patch.address]: patch.value } }
-            )
-          }
-          case 'push': {
-            return collection.updateOne(
-              { [identifierKey]: id },
-              { $push: { [patch.address]: { $each: patch.items } } }
-            )
-          }
-          case 'pull': {
-            return collection.updateOne(
-              { [identifierKey]: id },
-              { $pull: { [patch.address]: { $in: patch.items } } }
-            )
-          }
-        }
-      })
-    )
-
-    // check transaction
-    for (const response of responses) {
-      if (!response.acknowledged) {
-        console.log('MongoDB Write Warning', { model, id, patches }, responses)
-      }
-    }
-  }
-
-  private async getCollection({ model, id }: CollectionDriverParams.Record) {
-    if (this.discriminatedModels[model]) {
-      const target = await this.get({ model, id })
-      const discriminatorValue = target[this.discriminatedModels[model].discriminatorKey] as string
-
-      return this.discriminatedModels[model].models[discriminatorValue]
-    }
-
-    return this.collections[model]
-  }
-
-  async exists({ model, id }: CollectionDriverParams.Record) {
-    const result = await this.collections[model].exists({
-      [this.getIdentifierKey(model)]: id
-    })
-
-    return result !== null
-  }
-
-  private getIdentifierKey(model: string) {
-    return this.dataScheme.models[model].scheme.identifier.propertyKey
-  }
-
-  private useModel<T>(model: string, schema: Schema): Model<T> {
-    return this.connection.models[model] ?? this.connection.model(model, schema)
-  }
-}
-
-export const createMongoDriver = (connection: Connection) => {
-  return <T extends CollectionScheme>(dataScheme: DataScheme<T>) => {
-    return new MongoCollectionDriver(dataScheme, connection)
-  }
-}

package/lib/drivers/table.driver.ts

@@ -1,109 +0,0 @@
-import {
-  CollectionScheme,
-  DataScheme,
-  IType,
-  RelationRecord,
-  RelationsTableInfo,
-  TableDriver,
-  TableRow,
-  TableRelationSlice
-} from '@companix/xeo-scheme'
-import { Connection, Model, Schema, SchemaDefinition } from 'mongoose'
-
-class MongoTableStore {
-  private modelKey: { [model: string]: 'm1' | 'm2' } = {}
-  private keyMirror = { m1: 'm2' as 'm2', m2: 'm1' as 'm1' }
-
-  private model: Model<TableRow>
-
-  constructor({ rules, tableName }: RelationsTableInfo, private connection: Connection) {
-    this.modelKey[rules.m1] = 'm1'
-    this.modelKey[rules.m2] = 'm2'
-    this.model = this.useModel<TableRow>(tableName, new Schema(this.getSchemeDefinition()))
-  }
-
-  private getSchemeDefinition(): SchemaDefinition {
-    return {
-      m1: { type: Schema.Types.Mixed, index: true, required: true },
-      m2: { type: Schema.Types.Mixed, index: true, required: true }
-    }
-  }
-
-  private getRow({ modelId, modelSide, oppositeId }: RelationRecord) {
-    const key = this.modelKey[modelSide]
-    const row = { [key]: modelId, [this.keyMirror[key]]: oppositeId } as unknown as TableRow
-
-    return row
-  }
-
-  async addRow(row: RelationRecord) {
-    await this.model.create(this.getRow(row))
-  }
-
-  async removeRow(row: RelationRecord) {
-    await this.model.deleteOne(this.getRow(row)).exec()
-  }
-
-  async removeModel(model: string, modelId: IType) {
-    await this.model.deleteMany({ [this.modelKey[model]]: modelId }).exec()
-  }
-
-  async getRelations(model: string, modelId: IType) {
-    const key = this.modelKey[model]
-    const oppositeKey = this.keyMirror[key]
-
-    const rows = await this.model
-      .find({ [key]: modelId })
-      .select({ [oppositeKey]: 1, _id: 0 })
-      .lean()
-      .exec()
-
-    return rows.map((row) => row[oppositeKey] as IType)
-  }
-
-  private useModel<T>(model: string, schema: Schema): Model<T> {
-    return this.connection.models[model] ?? this.connection.model(model, schema)
-  }
-
-  getStore() {
-    return this.model.find().lean().exec()
-  }
-}
-
-export class MongoRelationsTable<T extends CollectionScheme> implements TableDriver {
-  private readonly tables: { [tableName: string]: MongoTableStore } = {}
-
-  constructor(dataScheme: DataScheme<T>, connection: Connection) {
-    for (const table of dataScheme.tables) {
-      this.tables[table.tableName] = new MongoTableStore(table, connection)
-    }
-  }
-
-  async createRecord(row: RelationRecord) {
-    await this.tables[row.tableName].addRow(row)
-  }
-
-  async removeRecord(row: RelationRecord) {
-    await this.tables[row.tableName].removeRow(row)
-  }
-
-  async removeRecordsByModel(row: TableRelationSlice) {
-    await this.tables[row.tableName].removeModel(row.modelSide, row.modelId)
-  }
-
-  async getRecords({ tableName, modelSide, modelId }: TableRelationSlice) {
-    return this.tables[tableName].getRelations(modelSide, modelId)
-  }
-
-  // development
-
-  async getTables() {
-    const state: { [name: string]: TableRow[] } = {}
-
-    for (const tableName in this.tables) {
-      state[tableName] = await this.tables[tableName].getStore()
-    }
-
-    return state
-  }
-}

package/lib/factories/definitions.factory.ts

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

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

package/lib/mongoose-options.interface.ts

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