@companix/xeo-server 0.0.2

package/dist/mongoose-options.interface.d.ts

@@ -0,0 +1,12 @@
+import { ConnectOptions, Connection, MongooseError } from 'mongoose';
+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;
+    verboseRetryLog?: boolean;
+}

package/dist/mongoose-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=mongoose-options.interface.js.map

package/dist/mongoose-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose-options.interface.js","sourceRoot":"","sources":["../lib/mongoose-options.interface.ts"],"names":[],"mappings":""}

package/dist/mongoose.module.d.ts

@@ -0,0 +1,11 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { MongooseModuleOptions } from './mongoose-options.interface';
+export declare class MongooseCoreModule implements OnApplicationShutdown {
+    private readonly connectionName;
+    private readonly moduleRef;
+    constructor(connectionName: string, moduleRef: ModuleRef);
+    static forRoot(uri: string, options?: MongooseModuleOptions): DynamicModule;
+    private static createMongooseConnection;
+    onApplicationShutdown(): Promise<void>;
+}

package/dist/mongoose.module.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MongooseCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongooseCoreModule = void 0;
+const mongoose = __importStar(require("mongoose"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const constants_1 = require("./constants");
+const common_2 = require("./common");
+let MongooseCoreModule = MongooseCoreModule_1 = class MongooseCoreModule {
+    constructor(connectionName, moduleRef) {
+        this.connectionName = connectionName;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(uri, options = {}) {
+        const { retryAttempts, retryDelay, connectionName, connectionFactory, connectionErrorFactory, lazyConnection, onConnectionCreate, verboseRetryLog, ...mongooseOptions } = options;
+        const mongooseConnectionFactory = connectionFactory || ((connection) => connection);
+        const mongooseConnectionError = connectionErrorFactory || ((error) => error);
+        const mongooseConnectionName = (0, common_2.getConnectionToken)(connectionName);
+        const mongooseConnectionNameProvider = {
+            provide: constants_1.MONGOOSE_CONNECTION_NAME,
+            useValue: mongooseConnectionName
+        };
+        const connectionProvider = {
+            provide: mongooseConnectionName,
+            useFactory: async () => await (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(async () => mongooseConnectionFactory(await this.createMongooseConnection(uri, mongooseOptions, {
+                lazyConnection,
+                onConnectionCreate
+            }), mongooseConnectionName)).pipe((0, common_2.handleRetry)(retryAttempts, retryDelay, verboseRetryLog), (0, operators_1.catchError)((error) => {
+                throw mongooseConnectionError(error);
+            })))
+        };
+        return {
+            module: MongooseCoreModule_1,
+            providers: [connectionProvider, mongooseConnectionNameProvider],
+            exports: [connectionProvider]
+        };
+    }
+    static async createMongooseConnection(uri, mongooseOptions, factoryOptions) {
+        const connection = mongoose.createConnection(uri, mongooseOptions);
+        if (factoryOptions?.lazyConnection) {
+            return connection;
+        }
+        factoryOptions?.onConnectionCreate?.(connection);
+        return connection.asPromise();
+    }
+    async onApplicationShutdown() {
+        const connection = this.moduleRef.get(this.connectionName);
+        if (connection) {
+            await connection.close();
+        }
+    }
+};
+exports.MongooseCoreModule = MongooseCoreModule;
+exports.MongooseCoreModule = MongooseCoreModule = MongooseCoreModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(constants_1.MONGOOSE_CONNECTION_NAME)),
+    __metadata("design:paramtypes", [String, core_1.ModuleRef])
+], MongooseCoreModule);
+//# sourceMappingURL=mongoose.module.js.map

package/dist/mongoose.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.module.js","sourceRoot":"","sources":["../lib/mongoose.module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDAAoC;AACpC,2CAA6F;AAC7F,uCAAwC;AAExC,+BAA2C;AAC3C,8CAA2C;AAC3C,2CAAsD;AACtD,qCAA0D;AAKnD,IAAM,kBAAkB,0BAAxB,MAAM,kBAAkB;IAC7B,YACqD,cAAsB,EACxD,SAAoB;QADc,mBAAc,GAAd,cAAc,CAAQ;QACxD,cAAS,GAAT,SAAS,CAAW;IACpC,CAAC;IAEJ,MAAM,CAAC,OAAO,CAAC,GAAW,EAAE,UAAiC,EAAE;QAC7D,MAAM,EACJ,aAAa,EACb,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,GAAG,eAAe,EACnB,GAAG,OAAO,CAAA;QAEX,MAAM,yBAAyB,GAAG,iBAAiB,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,CAAA;QAEnF,MAAM,uBAAuB,GAAG,sBAAsB,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAA;QAE5E,MAAM,sBAAsB,GAAG,IAAA,2BAAkB,EAAC,cAAc,CAAC,CAAA;QAEjE,MAAM,8BAA8B,GAAG;YACrC,OAAO,EAAE,oCAAwB;YACjC,QAAQ,EAAE,sBAAsB;SACjC,CAAA;QAED,MAAM,kBAAkB,GAAG;YACzB,OAAO,EAAE,sBAAsB;YAC/B,UAAU,EAAE,KAAK,IAAkB,EAAE,CACnC,MAAM,IAAA,oBAAa,EACjB,IAAA,YAAK,EAAC,KAAK,IAAI,EAAE,CACf,yBAAyB,CACvB,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,eAAe,EAAE;gBACxD,cAAc;gBACd,kBAAkB;aACnB,CAAC,EACF,sBAAsB,CACvB,CACF,CAAC,IAAI,CACJ,IAAA,oBAAW,EAAC,aAAa,EAAE,UAAU,EAAE,eAAe,CAAC,EACvD,IAAA,sBAAU,EAAC,CAAC,KAAK,EAAE,EAAE;gBACnB,MAAM,uBAAuB,CAAC,KAAK,CAAC,CAAA;YACtC,CAAC,CAAC,CACH,CACF;SACJ,CAAA;QACD,OAAO;YACL,MAAM,EAAE,oBAAkB;YAC1B,SAAS,EAAE,CAAC,kBAAkB,EAAE,8BAA8B,CAAC;YAC/D,OAAO,EAAE,CAAC,kBAAkB,CAAC;SAC9B,CAAA;IACH,CAAC;IAEO,MAAM,CAAC,KAAK,CAAC,wBAAwB,CAC3C,GAAW,EACX,eAA+B,EAC/B,cAGC;QAED,MAAM,UAAU,GAAG,QAAQ,CAAC,gBAAgB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAA;QAElE,IAAI,cAAc,EAAE,cAAc,EAAE,CAAC;YACnC,OAAO,UAAU,CAAA;QACnB,CAAC;QAED,cAAc,EAAE,kBAAkB,EAAE,CAAC,UAAU,CAAC,CAAA;QAEhD,OAAO,UAAU,CAAC,SAAS,EAAE,CAAA;IAC/B,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAM,IAAI,CAAC,cAAc,CAAC,CAAA;QAC/D,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,UAAU,CAAC,KAAK,EAAE,CAAA;QAC1B,CAAC;IACH,CAAC;CACF,CAAA;AAlFY,gDAAkB;6BAAlB,kBAAkB;IAF9B,IAAA,eAAM,GAAE;IACR,IAAA,eAAM,EAAC,EAAE,CAAC;IAGN,WAAA,IAAA,eAAM,EAAC,oCAAwB,CAAC,CAAA;6CACL,gBAAS;GAH5B,kBAAkB,CAkF9B"}

package/dist/storages/data-source.d.ts

@@ -0,0 +1,10 @@
+import { CollectionScheme, DataScheme, DataSource } from '@companix/xeo-scheme';
+import { Connection } from 'mongoose';
+declare class DataSourceStorageService {
+    private dataSource;
+    private dataScheme;
+    getProviderToken(dataScheme: DataScheme<CollectionScheme>): string;
+    getSource(dataScheme: DataScheme<CollectionScheme>, connection: Connection): DataSource<CollectionScheme, import("@companix/xeo-scheme").CollectionDriver>;
+}
+export declare const DataSourceStorage: DataSourceStorageService;
+export {};

package/dist/storages/data-source.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceStorage = void 0;
+const xeo_scheme_1 = require("@companix/xeo-scheme");
+const collection_driver_1 = require("../drivers/collection.driver");
+const constants_1 = require("../constants");
+class DataSourceStorageService {
+    constructor() {
+        this.dataSource = null;
+        this.dataScheme = null;
+    }
+    getProviderToken(dataScheme) {
+        if (this.dataScheme === null) {
+            this.dataScheme = dataScheme;
+        }
+        if (this.dataScheme !== dataScheme) {
+            throw new Error(`[MongoDriver] driver cannot work with several dataSchemes`);
+        }
+        return constants_1.DATA_SOURCE_TOKEN;
+    }
+    getSource(dataScheme, connection) {
+        if (this.dataScheme !== dataScheme) {
+            throw new Error(`[MongoDriver] driver cannot work with several dataSchemes`);
+        }
+        if (!this.dataSource) {
+            this.dataSource = new xeo_scheme_1.DataSource(dataScheme, {
+                createDriver: (0, collection_driver_1.createMongoDriver)(connection)
+            });
+        }
+        return this.dataSource;
+    }
+}
+exports.DataSourceStorage = new DataSourceStorageService();
+//# sourceMappingURL=data-source.js.map

package/dist/storages/data-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-source.js","sourceRoot":"","sources":["../../lib/storages/data-source.ts"],"names":[],"mappings":";;;AAAA,qDAA+E;AAE/E,oEAAgE;AAChE,4CAAgD;AAEhD,MAAM,wBAAwB;IAA9B;QACU,eAAU,GAAwC,IAAI,CAAA;QACtD,eAAU,GAAwC,IAAI,CAAA;IA2BhE,CAAC;IAzBC,gBAAgB,CAAC,UAAwC;QACvD,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC9B,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAA;QAC9E,CAAC;QAED,OAAO,6BAAiB,CAAA;IAC1B,CAAC;IAED,SAAS,CAAC,UAAwC,EAAE,UAAsB;QACxE,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAA;QAC9E,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,UAAU,GAAG,IAAI,uBAAU,CAAC,UAAU,EAAE;gBAC3C,YAAY,EAAE,IAAA,qCAAiB,EAAC,UAAU,CAAC;aAC5C,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,CAAA;IACxB,CAAC;CACF;AAEY,QAAA,iBAAiB,GAAG,IAAI,wBAAwB,EAAE,CAAA"}

package/jest.cases.config.cjs

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

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

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

package/lib/common/tokens.ts

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

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

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

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

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

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