@biorate/mongodb 0.28.3 → 0.29.1

package/src/index.ts

@@ -1,152 +0,0 @@
-import { init, injectable } from '@biorate/inversion';
-import { events } from '@biorate/tools';
-import { Connector } from '@biorate/connector';
-import { createConnection } from 'mongoose';
-import { getModelForClass } from '@typegoose/typegoose';
-import { MongoDBCantConnectError } from './errors';
-import { IMongoDBConfig, IMongoDBConnection } from './interfaces';
-
-export * from './errors';
-export * from './interfaces';
-
-/**
- * @description Mongodb ORM connector based on mongoose and typegoose
- *
- * ### Features:
- * - connector manager for mongodb
- *
- * @example
- * ```
- * import { inject, container, Types, Core } from '@biorate/inversion';
- * import { IConfig, Config } from '@biorate/config';
- * import {
- *   Severity,
- *   modelOptions,
- *   Prop,
- *   MongoDBConnector,
- *   IMongoDBConnector,
- *   model,
- *   ReturnModelType,
- * } from '@biorate/mongodb';
- *
- * // Define models
- * @modelOptions({
- *   options: {
- *     allowMixed: Severity.ALLOW,
- *   },
- *   schemaOptions: { collection: 'test', versionKey: false },
- * })
- * export class TestModel {
- *   @Prop()
- *   firstName: string;
- *
- *   @Prop()
- *   lastName: string;
- *
- *   @Prop()
- *   age: number;
- * }
- *
- * // Define root
- * export class Root extends Core() {
- *   @inject(MongoDBConnector) public connector: IMongoDBConnector;
- *   @model(TestModel) public test: ReturnModelType<typeof TestModel>;
- * }
- *
- * // Bind dependencies
- * container.bind<IConfig>(Types.Config).to(Config).inSingletonScope();
- * container.bind<IMongoDBConnector>(MongoDBConnector).toSelf().inSingletonScope();
- * container.bind<Root>(Root).toSelf().inSingletonScope();
- *
- * // Configure
- * container.get<IConfig>(Types.Config).merge({
- *   MongoDB: [
- *     {
- *       name: 'connection',
- *       host: 'mongodb://localhost:27017/',
- *       options: {
- *         useNewUrlParser: true,
- *         useUnifiedTopology: true,
- *         dbName: 'test',
- *       },
- *     },
- *   ],
- * });
- *
- * (async () => {
- *   const root = container.get<Root>(Root);
- *   await root.$run();
- *   await root.connector.connection().dropDatabase();
- *
- *   const connection = root.connector.connection('connection'); // Get connection instance
- *   console.log(connection);
- *
- *   await new root.test({
- *     firstName: 'Vasya',
- *     lastName: 'Pupkin',
- *     age: 36,
- *   }).save(); // insert data into test collection
- *
- *   // Get data from database
- *   const data = await root.test.find({ firstName: 'Vasya' }, { _id: 0 });
- *   console.log(data); // {
- *                      //   firstName: 'Vasya',
- *                      //   lastName: 'Pupkin',
- *                      //   age: 36,
- *                      // }
- * })();
- * ```
- */
-@injectable()
-export class MongoDBConnector extends Connector<IMongoDBConfig, IMongoDBConnection> {
-  /**
-   * @description Namespace path for fetching configuration
-   */
-  protected readonly namespace = 'MongoDB';
-  /**
-   * @description Create connection
-   */
-  protected async connect(config: IMongoDBConfig) {
-    let connection: IMongoDBConnection;
-    try {
-      connection = createConnection(config.host, config.options);
-      await events.once(connection, 'open');
-    } catch (e) {
-      throw new MongoDBCantConnectError(e);
-    }
-    return connection;
-  }
-  /**
-   * @description Initialize method
-   */
-  @init() protected async initialize() {
-    connections = this.connections;
-    await super.initialize();
-  }
-}
-/**
- * @description Private connections link
- */
-let connections: Map<string, IMongoDBConnection> = null;
-/**
- * @description Model injection decorator
- */
-export const model = <T = unknown>(
-  Model: new (...args: any) => T,
-  connection?: string,
-  options: Record<string, unknown> = {},
-) => {
-  return (proto?: any, key?: string) => {
-    Object.defineProperty(proto, key, {
-      get() {
-        return getModelForClass(Model, {
-          existingConnection: connection
-            ? connections.get(connection)
-            : [...connections][0][1],
-          options,
-        });
-      },
-      configurable: false,
-    });
-  };
-};

package/src/interfaces.ts

@@ -1,11 +0,0 @@
-import { IConnectorConfig, IConnector } from '@biorate/connector';
-import { ConnectOptions, Connection } from 'mongoose';
-
-export type IMongoDBConnection = Connection;
-
-export interface IMongoDBConfig extends IConnectorConfig {
-  host: string;
-  options: ConnectOptions;
-}
-
-export type IMongoDBConnector = IConnector<IMongoDBConfig, IMongoDBConnection>;

package/tests/__mocks__/index.ts

@@ -1,36 +0,0 @@
-import { use } from 'chai';
-import { jestSnapshotPlugin } from 'mocha-chai-jest-snapshot';
-import { inject, container, Types, Core } from '@biorate/inversion';
-import { IConfig, Config } from '@biorate/config';
-import { MongoDBConnector, IMongoDBConnector, model } from '../../src';
-import { ReturnModelType } from '@typegoose/typegoose';
-import { TestModel } from './models';
-
-export * from './models';
-
-use(jestSnapshotPlugin());
-
-export const dbName = 'test';
-
-export class Root extends Core() {
-  @inject(MongoDBConnector) public connector: IMongoDBConnector;
-  @model(TestModel) public test: ReturnModelType<typeof TestModel>;
-}
-
-container.bind<IConfig>(Types.Config).to(Config).inSingletonScope();
-container.bind<IMongoDBConnector>(MongoDBConnector).toSelf().inSingletonScope();
-container.bind<Root>(Root).toSelf().inSingletonScope();
-
-container.get<IConfig>(Types.Config).merge({
-  MongoDB: [
-    {
-      name: 'connection',
-      host: 'mongodb://localhost:27017/',
-      options: {
-        useNewUrlParser: true,
-        useUnifiedTopology: true,
-        dbName,
-      },
-    },
-  ],
-});

package/tests/__mocks__/models/index.ts

@@ -1 +0,0 @@
-export * from './test';