@midwayjs/mongoose 3.3.5 → 3.4.0-beta.11

package/dist/configuration.d.ts

@@ -1,5 +1,7 @@
 import { ILifeCycle, IMidwayContainer } from '@midwayjs/core';
+import { MongooseDataSourceManager } from './manager';
 export declare class MongooseConfiguration implements ILifeCycle {
+    mongooseDataSourceManager: MongooseDataSourceManager;
     onReady(container: IMidwayContainer): Promise<void>;
     onStop(container: IMidwayContainer): Promise<void>;
 }

package/dist/configuration.js

@@ -11,11 +11,10 @@ const decorator_1 = require("@midwayjs/decorator");
 const manager_1 = require("./manager");
 let MongooseConfiguration = class MongooseConfiguration {
     async onReady(container) {
-        await container.getAsync(manager_1.MongooseConnectionServiceFactory);
+        this.mongooseDataSourceManager = await container.getAsync(manager_1.MongooseDataSourceManager);
     }
     async onStop(container) {
-        const factory = await container.getAsync(manager_1.MongooseConnectionServiceFactory);
-        await factory.stop();
+        await this.mongooseDataSourceManager.stop();
     }
 };
 MongooseConfiguration = __decorate([

package/dist/manager.d.ts

@@ -1,15 +1,30 @@
-import { ServiceFactory } from '@midwayjs/core';
+import { DataSourceManager } from '@midwayjs/core';
 import * as mongoose from 'mongoose';
-export declare class MongooseConnectionServiceFactory extends ServiceFactory<mongoose.Connection> {
+export declare class MongooseDataSourceManager extends DataSourceManager<mongoose.Connection> {
     config: any;
     logger: any;
+    baseDir: string;
     init(): Promise<void>;
-    protected createClient(config: any, name: string): Promise<mongoose.Connection>;
+    protected createDataSource(config: any, name: string): Promise<any>;
     getName(): string;
-    destroyClient(connection: mongoose.Connection): Promise<void>;
+    destroyDataSource(dataSource: mongoose.Connection): Promise<void>;
+    protected checkConnected(dataSource: mongoose.Connection): Promise<boolean>;
 }
+/**
+ * @deprecated
+ */
+export declare class MongooseConnectionServiceFactory {
+    mongooseDataSourceManager: MongooseDataSourceManager;
+    createInstance(config: any, clientName: any): Promise<void | mongoose.Connection>;
+    get(id: string): mongoose.Connection;
+    getName(): string;
+    has(id: string): boolean;
+}
+/**
+ * @deprecated
+ */
 export declare class MongooseConnectionService implements mongoose.Connection {
-    private serviceFactory;
+    private mongooseDataSourceManager;
     private instance;
     init(): Promise<void>;
 }

package/dist/manager.js

@@ -9,68 +9,117 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongooseConnectionService = exports.MongooseConnectionServiceFactory = void 0;
+exports.MongooseConnectionService = exports.MongooseConnectionServiceFactory = exports.MongooseDataSourceManager = void 0;
 const core_1 = require("@midwayjs/core");
 const decorator_1 = require("@midwayjs/decorator");
 const mongoose = require("mongoose");
-let MongooseConnectionServiceFactory = class MongooseConnectionServiceFactory extends core_1.ServiceFactory {
+let MongooseDataSourceManager = class MongooseDataSourceManager extends core_1.DataSourceManager {
     async init() {
-        await this.initClients(this.config);
+        if (this.config.client) {
+            this.logger.warn('[midway:mongoose] mongoose.client is deprecated, please use new config format.');
+            this.config.dataSource = {
+                default: this.config.client,
+            };
+        }
+        if (this.config.clients) {
+            this.logger.warn('[midway:mongoose] mongoose.clients is deprecated, please use new config format.');
+            this.config.dataSource = this.config.clients;
+        }
+        await this.initDataSource(this.config, this.baseDir);
     }
-    async createClient(config, name) {
-        const connection = await mongoose.createConnection(config.uri, config.options);
+    async createDataSource(config, name) {
+        const connection = (await mongoose.createConnection(config.uri, config.options));
         connection.on('error', err => {
-            err.message = `[mongoose]${err.message}`;
+            err.message = `[midway:mongoose] ${err.message}`;
             this.logger.error(err);
         });
         /* istanbul ignore next */
         connection.on('disconnected', () => {
-            this.logger.info(`[mongoose] ${name} disconnected`);
+            this.logger.info(`[midway:mongoose] ${name} disconnected`);
         });
         connection.on('connected', () => {
-            this.logger.info(`[mongoose] ${name} connected successfully`);
+            this.logger.info(`[midway:mongoose] ${name} connected successfully`);
         });
         /* istanbul ignore next */
         connection.on('reconnected', () => {
-            this.logger.info(`[mongoose] ${name} reconnected successfully`);
+            this.logger.info(`[midway:mongoose] ${name} reconnected successfully`);
         });
+        if (config.entities) {
+            connection.entities = config.entities;
+        }
         return connection;
     }
     getName() {
         return 'mongoose';
     }
-    async destroyClient(connection) {
-        await connection.close();
+    async destroyDataSource(dataSource) {
+        await dataSource.close();
+    }
+    async checkConnected(dataSource) {
+        return dataSource.readyState === mongoose.ConnectionStates.connected;
     }
 };
 __decorate([
     (0, decorator_1.Config)('mongoose'),
     __metadata("design:type", Object)
-], MongooseConnectionServiceFactory.prototype, "config", void 0);
+], MongooseDataSourceManager.prototype, "config", void 0);
 __decorate([
     (0, decorator_1.Logger)('coreLogger'),
     __metadata("design:type", Object)
-], MongooseConnectionServiceFactory.prototype, "logger", void 0);
+], MongooseDataSourceManager.prototype, "logger", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], MongooseDataSourceManager.prototype, "baseDir", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
-], MongooseConnectionServiceFactory.prototype, "init", null);
+], MongooseDataSourceManager.prototype, "init", null);
+MongooseDataSourceManager = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MongooseDataSourceManager);
+exports.MongooseDataSourceManager = MongooseDataSourceManager;
+/**
+ * @deprecated
+ */
+let MongooseConnectionServiceFactory = class MongooseConnectionServiceFactory {
+    createInstance(config, clientName) {
+        return this.mongooseDataSourceManager.createInstance(config, clientName);
+    }
+    get(id) {
+        return this.mongooseDataSourceManager.getDataSource(id);
+    }
+    getName() {
+        return 'mongoose';
+    }
+    has(id) {
+        return this.mongooseDataSourceManager.hasDataSource(id);
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", MongooseDataSourceManager)
+], MongooseConnectionServiceFactory.prototype, "mongooseDataSourceManager", void 0);
 MongooseConnectionServiceFactory = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
 ], MongooseConnectionServiceFactory);
 exports.MongooseConnectionServiceFactory = MongooseConnectionServiceFactory;
+/**
+ * @deprecated
+ */
 let MongooseConnectionService = class MongooseConnectionService {
     async init() {
-        this.instance = this.serviceFactory.get('default');
+        this.instance = this.mongooseDataSourceManager.getDataSource('default');
     }
 };
 __decorate([
     (0, decorator_1.Inject)(),
-    __metadata("design:type", MongooseConnectionServiceFactory)
-], MongooseConnectionService.prototype, "serviceFactory", void 0);
+    __metadata("design:type", MongooseDataSourceManager)
+], MongooseConnectionService.prototype, "mongooseDataSourceManager", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),

package/index.d.ts

@@ -3,7 +3,7 @@ export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    mongoose?: ServiceFactoryConfigOption<{
+    mongoose?: DataSourceManagerConfigOption<{
       uri: string;
       options: ConnectionOptions;
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/mongoose",
-  "version": "3.3.5",
+  "version": "3.4.0-beta.11",
   "description": "Midway Component for mongoose",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -22,13 +22,13 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/core": "^3.3.5",
-    "@midwayjs/decorator": "^3.3.4",
-    "@midwayjs/mock": "^3.3.5",
-    "mongoose": "6.2.10"
+    "@midwayjs/core": "^3.4.0-beta.11",
+    "@midwayjs/decorator": "^3.4.0-beta.11",
+    "@midwayjs/mock": "^3.4.0-beta.11",
+    "mongoose": "6.4.4"
   },
   "peerDependencies": {
     "mongoose": "*"
   },
-  "gitHead": "5a835008aaa26e1b3c7d99c525f4a9fdaa3e41d1"
+  "gitHead": "b1c7a439b0df37d3e381cd182ea3b9e74323107b"
 }