@midwayjs/sequelize 3.3.5 → 3.4.0-beta.2

package/README.md

@@ -1,74 +1,9 @@
 # midway sequelize component
 
-## How to use
+this is a sub package for midway.
 
-in Configuration.ts file
+Document: [https://midwayjs.org](https://midwayjs.org)
 
-```ts
-@Configuration({
-  imports: [
-    '@midwayjs/sequelize',
-  ],
-  importConfigs: [
-    './config'
-  ]
-})
-export class ContainerConfiguration {
-}
+## License
 
-```
-
-## Configuration
-
-in config files
-
-
-```ts
-export const sequelize = {
-  options: {
-    database: 'test4',
-    username: 'root',
-    password: '123456',
-    host: '127.0.0.1',
-    port: 3306,
-    encrypt: false,
-    logging: console.log
-  },
-  sync: false
-}
-```
-
-## Define EntityModel
-
-```ts
-import { Column, Model } from "sequelize-typescript";
-import { BaseTable } from "@midwayjs/sequelize";
-
-@BaseTable
-export default class UserModel extends Model{
-  @Column({
-    comment: '名字'
-  })
-  name: string;
-}
-
-```
-
-
-## Use Model
-
-in code files
-
-```ts
-import { UserModel } from './model/user';
-
-@Provide()
-export class IndexHandler {
-
-  @Func('index.handler')
-  async handler() {
-    const users = await this.UserModel.findAll();
-    return users;
-  }
-}
-```
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -1,7 +1,11 @@
-import { Sequelize } from 'sequelize-typescript';
+import { SequelizeDataSourceManager } from './dataSourceManager';
+import { IMidwayContainer, MidwayDecoratorService } from '@midwayjs/core';
 export declare class SequelizeConfiguration {
-    instance: Sequelize;
     sequelizeConfig: any;
-    onReady(): Promise<void>;
+    decoratorService: MidwayDecoratorService;
+    dataSourceManager: SequelizeDataSourceManager;
+    init(): Promise<void>;
+    onReady(container: IMidwayContainer): Promise<void>;
+    onStop(): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -11,17 +11,23 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeConfiguration = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const sequelize_typescript_1 = require("sequelize-typescript");
-const DefaultConfig = require("./config/config.default");
+const dataSourceManager_1 = require("./dataSourceManager");
+const core_1 = require("@midwayjs/core");
+const decorator_2 = require("./decorator");
 let SequelizeConfiguration = class SequelizeConfiguration {
-    async onReady() {
-        const options = this.sequelizeConfig.options;
-        this.instance = new sequelize_typescript_1.Sequelize(options);
-        const entities = (0, decorator_1.listModule)('sequelize:core');
-        this.instance.addModels(entities);
-        await this.instance.authenticate();
-        if (this.sequelizeConfig.sync) {
-            await this.instance.sync();
+    async init() {
+        this.decoratorService.registerPropertyHandler(decorator_2.ENTITY_MODEL_KEY, (propertyName, meta) => {
+            return this.dataSourceManager
+                .getDataSource(meta.connectionName)
+                .getRepository(meta.modelKey);
+        });
+    }
+    async onReady(container) {
+        this.dataSourceManager = await container.getAsync(dataSourceManager_1.SequelizeDataSourceManager);
+    }
+    async onStop() {
+        if (this.dataSourceManager) {
+            await this.dataSourceManager.stop();
         }
     }
 };
@@ -29,12 +35,24 @@ __decorate([
     (0, decorator_1.Config)('sequelize'),
     __metadata("design:type", Object)
 ], SequelizeConfiguration.prototype, "sequelizeConfig", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], SequelizeConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SequelizeConfiguration.prototype, "init", null);
 SequelizeConfiguration = __decorate([
     (0, decorator_1.Configuration)({
         namespace: 'sequelize',
         importConfigs: [
             {
-                default: DefaultConfig,
+                default: {
+                    sequelize: {},
+                },
             },
         ],
     })

package/dist/dataSourceManager.d.ts

@@ -0,0 +1,12 @@
+import { DataSourceManager, ILogger } from '@midwayjs/core';
+import { Sequelize } from 'sequelize-typescript';
+export declare class SequelizeDataSourceManager extends DataSourceManager<Sequelize> {
+    sequelizeConfig: any;
+    coreLogger: ILogger;
+    init(): Promise<void>;
+    getName(): string;
+    protected createDataSource(config: any, dataSourceName: string): Promise<Sequelize>;
+    protected checkConnected(dataSource: Sequelize): Promise<boolean>;
+    protected destroyDataSource(dataSource: Sequelize): Promise<void>;
+}
+//# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/dataSourceManager.js

@@ -0,0 +1,83 @@
+"use strict";
+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 __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.SequelizeDataSourceManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const core_1 = require("@midwayjs/core");
+const sequelize_typescript_1 = require("sequelize-typescript");
+let SequelizeDataSourceManager = class SequelizeDataSourceManager extends core_1.DataSourceManager {
+    async init() {
+        if (this.sequelizeConfig.options) {
+            this.coreLogger.warn('[midway:sequelize] sequelize.options is deprecated, please use new config format.');
+            this.sequelizeConfig.options.sync = this.sequelizeConfig.sync || false;
+            // legacy config
+            this.sequelizeConfig.dataSource = {
+                default: this.sequelizeConfig.options,
+            };
+        }
+        await this.initDataSource(this.sequelizeConfig);
+    }
+    getName() {
+        return 'sequelize';
+    }
+    async createDataSource(config, dataSourceName) {
+        const client = new sequelize_typescript_1.Sequelize(config);
+        const entities = config['entities'];
+        if (entities && entities.length > 0) {
+            client.addModels(entities);
+        }
+        else {
+            const entities = (0, decorator_1.listModule)('sequelize:core');
+            client.addModels(entities);
+        }
+        await client.authenticate();
+        if (config.sync) {
+            await client.sync();
+        }
+        this.coreLogger.info('[midway:sequelize] connecting and start');
+        return client;
+    }
+    async checkConnected(dataSource) {
+        try {
+            await dataSource.authenticate();
+            return true;
+        }
+        catch (err) {
+            this.coreLogger.error(err);
+            return false;
+        }
+    }
+    async destroyDataSource(dataSource) {
+        if (await this.checkConnected(dataSource)) {
+            await dataSource.close();
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Config)('sequelize'),
+    __metadata("design:type", Object)
+], SequelizeDataSourceManager.prototype, "sequelizeConfig", void 0);
+__decorate([
+    (0, decorator_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], SequelizeDataSourceManager.prototype, "coreLogger", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SequelizeDataSourceManager.prototype, "init", null);
+SequelizeDataSourceManager = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], SequelizeDataSourceManager);
+exports.SequelizeDataSourceManager = SequelizeDataSourceManager;
+//# sourceMappingURL=dataSourceManager.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,11 @@
+import { Model, TableOptions } from 'sequelize-typescript';
+/**
+ * @deprecated
+ * @param options
+ * @constructor
+ */
+export declare function BaseTable<M extends Model = Model>(options: TableOptions<M>): any;
+export declare function BaseTable(target: any): void;
+export declare const ENTITY_MODEL_KEY = "sequelize:entity_model_key";
+export declare function InjectRepository(modelKey: any, connectionName?: string): PropertyDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/{core/baseTable.js → decorator.js}

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTable = void 0;
-const sequelize_typescript_1 = require("sequelize-typescript");
+exports.InjectRepository = exports.ENTITY_MODEL_KEY = exports.BaseTable = void 0;
 const decorator_1 = require("@midwayjs/decorator");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const decorator_2 = require("@midwayjs/decorator");
 function BaseTable(arg) {
     if (typeof arg === 'function') {
-        (0, decorator_1.saveModule)('sequelize:core', arg);
+        (0, decorator_2.saveModule)('sequelize:core', arg);
         annotate(arg);
     }
     else {
         const options = Object.assign({}, arg);
         return target => {
-            (0, decorator_1.saveModule)('sequelize:core', target);
+            (0, decorator_2.saveModule)('sequelize:core', target);
             annotate(target, options);
         };
     }
@@ -21,4 +22,12 @@ function annotate(target, options = {}) {
     (0, sequelize_typescript_1.setModelName)(target.prototype, options.modelName || target.name);
     (0, sequelize_typescript_1.addOptions)(target.prototype, options);
 }
-//# sourceMappingURL=baseTable.js.map
+exports.ENTITY_MODEL_KEY = 'sequelize:entity_model_key';
+function InjectRepository(modelKey, connectionName = 'default') {
+    return (0, decorator_1.createCustomPropertyDecorator)(exports.ENTITY_MODEL_KEY, {
+        modelKey,
+        connectionName,
+    });
+}
+exports.InjectRepository = InjectRepository;
+//# sourceMappingURL=decorator.js.map

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { SequelizeConfiguration as Configuration } from './configuration';
-export { BaseTable } from './core/baseTable';
+export { BaseTable, InjectRepository } from './decorator';
+export * from './interface';
+export * from './dataSourceManager';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,25 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTable = exports.Configuration = void 0;
+exports.InjectRepository = exports.BaseTable = exports.Configuration = void 0;
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.SequelizeConfiguration; } });
-var baseTable_1 = require("./core/baseTable");
-Object.defineProperty(exports, "BaseTable", { enumerable: true, get: function () { return baseTable_1.BaseTable; } });
+var decorator_1 = require("./decorator");
+Object.defineProperty(exports, "BaseTable", { enumerable: true, get: function () { return decorator_1.BaseTable; } });
+Object.defineProperty(exports, "InjectRepository", { enumerable: true, get: function () { return decorator_1.InjectRepository; } });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./dataSourceManager"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,6 @@
+import { DataSourceManagerConfigOption } from '@midwayjs/core';
+import { SequelizeOptions } from 'sequelize-typescript';
+export declare type SequelizeConfigOptions = DataSourceManagerConfigOption<SequelizeOptions & {
+    sync?: boolean;
+}>;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

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

package/index.d.ts

@@ -1,12 +1,9 @@
-import { SequelizeOptions } from 'sequelize-typescript';
+import { SequelizeConfigOptions } from './dist';
 
 export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    sequelize?: {
-      options?: SequelizeOptions;
-      sync?: boolean;
-    };
+    sequelize?: PowerPartial<SequelizeConfigOptions>;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/sequelize",
-  "version": "3.3.5",
+  "version": "3.4.0-beta.2",
   "main": "dist/index",
   "typings": "index.d.ts",
   "files": [
@@ -9,13 +9,14 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "@midwayjs/decorator": "^3.3.4",
-    "@midwayjs/koa": "^3.3.5",
-    "@midwayjs/mock": "^3.3.5",
-    "sqlite3": "5.0.5"
+    "@midwayjs/core": "^3.4.0-beta.2",
+    "@midwayjs/decorator": "^3.4.0-beta.2",
+    "@midwayjs/koa": "^3.4.0-beta.2",
+    "@midwayjs/mock": "^3.4.0-beta.2",
+    "sqlite3": "5.0.8"
   },
   "dependencies": {
-    "sequelize": "~6.17.0",
+    "sequelize": "6.21.0",
     "sequelize-typescript": "^2.1.0"
   },
   "keywords": [
@@ -40,5 +41,5 @@
     "type": "git",
     "url": "http://github.com/midwayjs/midway.git"
   },
-  "gitHead": "5a835008aaa26e1b3c7d99c525f4a9fdaa3e41d1"
+  "gitHead": "a61721d3946b30fd4cac183265edcd99b31ac72b"
 }

package/dist/config/config.default.d.ts

@@ -1,8 +0,0 @@
-export declare const sequelize: {
-    options: {
-        dialect: string;
-        storage: string;
-    };
-    sync: boolean;
-};
-//# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sequelize = void 0;
-const path = require("path");
-exports.sequelize = {
-    options: {
-        dialect: 'sqlite',
-        storage: path.join(__dirname, '../../test', 'database.sqlite'),
-    },
-    sync: false,
-};
-//# sourceMappingURL=config.default.js.map

package/dist/core/baseTable.d.ts

@@ -1,4 +0,0 @@
-import { Model, TableOptions } from 'sequelize-typescript';
-export declare function BaseTable<M extends Model = Model>(options: TableOptions<M>): any;
-export declare function BaseTable(target: any): void;
-//# sourceMappingURL=baseTable.d.ts.map