@nocobase/database 0.7.0-alpha.82 → 0.7.1-alpha.4

package/lib/collection-importer.js

@@ -5,10 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ImporterReader = void 0;
 
-function fs() {
-  const data = _interopRequireWildcard(require("fs"));
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
 
-  fs = function fs() {
+  return data;
+}
+
+function _promises() {
+  const data = require("fs/promises");
+
+  _promises = function _promises() {
     return data;
   };
 
@@ -16,7 +26,7 @@ function fs() {
 }
 
 function _lodash() {
-  const data = _interopRequireDefault(require("lodash"));
+  const data = require("lodash");
 
   _lodash = function _lodash() {
     return data;
@@ -25,10 +35,10 @@ function _lodash() {
   return data;
 }
 
-function _path() {
-  const data = _interopRequireDefault(require("path"));
+function _utils() {
+  const data = require("@nocobase/utils");
 
-  _path = function _path() {
+  _utils = function _utils() {
     return data;
   };
 
@@ -37,33 +47,10 @@ function _path() {
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-function requireModule(_x) {
-  return _requireModule.apply(this, arguments);
-}
-
-function _requireModule() {
-  _requireModule = _asyncToGenerator(function* (module) {
-    if (typeof module === 'string') {
-      module = require(module);
-    }
-
-    if (typeof module !== 'object') {
-      return module;
-    }
-
-    return module.__esModule ? module.default : module;
-  });
-  return _requireModule.apply(this, arguments);
-}
-
 class ImporterReader {
   constructor(directory, extensions) {
     this.directory = void 0;
@@ -81,9 +68,10 @@ class ImporterReader {
     var _this = this;
 
     return _asyncToGenerator(function* () {
-      const modules = (yield fs().promises.readdir(_this.directory, {
+      const files = yield (0, _promises().readdir)(_this.directory, {
         encoding: 'utf-8'
-      })).filter(fileName => {
+      });
+      const modules = files.filter(fileName => {
         if (fileName.endsWith('.d.ts')) {
           return false;
         }
@@ -91,16 +79,11 @@ class ImporterReader {
         const ext = _path().default.parse(fileName).ext.replace('.', '');
 
         return _this.extensions.has(ext);
-      }).map( /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* (fileName) {
-          return yield requireModule(_path().default.join(_this.directory, fileName));
-        });
-
-        return function (_x2) {
-          return _ref.apply(this, arguments);
-        };
-      }());
-      return (yield Promise.all(modules)).filter(module => _lodash().default.isPlainObject(module));
+      }).map(fileName => {
+        const mod = (0, _utils().requireModule)(_path().default.join(_this.directory, fileName));
+        return typeof mod === 'function' ? mod() : mod;
+      });
+      return (yield Promise.all(modules)).filter(module => (0, _lodash().isPlainObject)(module));
     })();
   }
 

package/lib/collection.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { ModelCtor, ModelOptions, SyncOptions } from 'sequelize';
+import { ModelCtor, ModelOptions, QueryInterfaceDropTableOptions, SyncOptions, Transactionable } from 'sequelize';
 import { Database } from './database';
 import { Field, FieldOptions } from './fields';
 import { Model } from './model';
@@ -40,6 +40,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     repository: Repository<TModelAttributes, TCreationAttributes>;
     get filterTargetKey(): string;
     get name(): string;
+    get db(): Database;
     constructor(options: CollectionOptions, context?: CollectionContext);
     private sequelizeModelOptions;
     /**
@@ -56,7 +57,10 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     setField(name: string, options: FieldOptions): Field;
     setFields(fields: FieldOptions[], resetFields?: boolean): void;
     resetFields(): void;
-    removeField(name: any): boolean;
+    remove(): void;
+    removeFromDb(options?: QueryInterfaceDropTableOptions): Promise<void>;
+    existsInDb(options?: Transactionable): Promise<boolean>;
+    removeField(name: any): Field;
     /**
      * TODO
      */

package/lib/collection.js

@@ -73,6 +73,10 @@ class Collection extends _events().EventEmitter {
     return this.options.name;
   }
 
+  get db() {
+    return this.context.database;
+  }
+
   constructor(options, context) {
     super();
     this.options = void 0;
@@ -247,6 +251,34 @@ class Collection extends _events().EventEmitter {
     }
   }
 
+  remove() {
+    this.context.database.removeCollection(this.name);
+  }
+
+  removeFromDb(options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (yield _this.existsInDb({
+        transaction: options === null || options === void 0 ? void 0 : options.transaction
+      })) {
+        const queryInterface = _this.db.sequelize.getQueryInterface();
+
+        yield queryInterface.dropTable(_this.model.tableName, options);
+      }
+
+      _this.remove();
+    })();
+  }
+
+  existsInDb(options) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      return _this2.db.collectionExistsInDb(_this2.name, options);
+    })();
+  }
+
   removeField(name) {
     if (!this.fields.has(name)) {
       return;
@@ -259,7 +291,7 @@ class Collection extends _events().EventEmitter {
       this.emit('field.afterRemove', field);
     }
 
-    return bool;
+    return field;
   }
   /**
    * TODO
@@ -325,11 +357,11 @@ class Collection extends _events().EventEmitter {
   }
 
   sync(syncOptions) {
-    var _this = this;
+    var _this3 = this;
 
     return _asyncToGenerator(function* () {
-      const modelNames = [_this.model.name];
-      const associations = _this.model.associations;
+      const modelNames = [_this3.model.name];
+      const associations = _this3.model.associations;
 
       for (const associationKey in associations) {
         const association = associations[associationKey];
@@ -342,7 +374,7 @@ class Collection extends _events().EventEmitter {
 
       const models = []; // @ts-ignore
 
-      _this.context.database.sequelize.modelManager.forEachModel(model => {
+      _this3.context.database.sequelize.modelManager.forEachModel(model => {
         if (modelNames.includes(model.name)) {
           models.push(model);
         }

package/lib/database.d.ts

@@ -2,11 +2,13 @@
 import { AsyncEmitter } from '@nocobase/utils';
 import merge from 'deepmerge';
 import { EventEmitter } from 'events';
-import { ModelCtor, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions } from 'sequelize';
+import { ModelCtor, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
+import { Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImportFileExtension } from './collection-importer';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';
+import { Migrations } from './migration';
 import { Model } from './model';
 import { ModelHook } from './model-hook';
 import { RelationRepository } from './relation-repository/relation-repository';
@@ -22,8 +24,9 @@ interface MapOf<T> {
 }
 export interface IDatabaseOptions extends Options {
     tablePrefix?: string;
+    migrator?: any;
 }
-export declare type DatabaseOptions = IDatabaseOptions | Sequelize;
+export declare type DatabaseOptions = IDatabaseOptions;
 interface RegisterOperatorsContext {
     db?: Database;
     path?: string;
@@ -33,9 +36,17 @@ interface RegisterOperatorsContext {
 export interface CleanOptions extends QueryInterfaceDropAllTablesOptions {
     drop?: boolean;
 }
+export declare type AddMigrationsOptions = {
+    context?: any;
+    namespace?: string;
+    extensions?: string[];
+    directory: string;
+};
 declare type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
 export declare class Database extends EventEmitter implements AsyncEmitter {
     sequelize: Sequelize;
+    migrator: Umzug;
+    migrations: Migrations;
     fieldTypes: Map<any, any>;
     options: IDatabaseOptions;
     models: Map<string, ModelCtor<Model<any, any>>>;
@@ -50,6 +61,10 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         mergeOptions?: any;
     }[]>;
     constructor(options: DatabaseOptions);
+    addMigration(item: any): void;
+    addMigrations(options: AddMigrationsOptions): void;
+    inDialect(...dialect: string[]): boolean;
+    private requireModule;
     /**
      * Add collection to database
      * @param options
@@ -62,7 +77,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
      */
     getCollection(name: string): Collection;
     hasCollection(name: string): boolean;
-    removeCollection(name: string): void;
+    removeCollection(name: string): Collection<any, any>;
     getModel<M extends Model>(name: string): ModelCtor<M>;
     getRepository<R extends Repository>(name: string): R;
     getRepository<R extends RelationRepository>(name: string, relationId: string | number): R;
@@ -76,14 +91,15 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     buildField(options: any, context: FieldContext): any;
     sync(options?: SyncOptions): Promise<Sequelize>;
     clean(options: CleanOptions): Promise<void>;
+    collectionExistsInDb(name: any, options?: Transactionable): Promise<boolean>;
     isSqliteMemory(): boolean;
     auth(options?: QueryOptions & {
-        repeat?: number;
+        retry?: number;
     }): Promise<any>;
     reconnect(): Promise<void>;
     closed(): any;
     close(): Promise<void>;
-    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    on(event: string | symbol, listener: any): this;
     import(options: {
         directory: string;
         extensions?: ImportFileExtension[];

package/lib/database.js

@@ -27,6 +27,16 @@ function _events() {
   return data;
 }
 
+function _glob() {
+  const data = _interopRequireDefault(require("glob"));
+
+  _glob = function _glob() {
+    return data;
+  };
+
+  return data;
+}
+
 function _lodash() {
   const data = _interopRequireDefault(require("lodash"));
 
@@ -57,18 +67,30 @@ function _sequelize() {
   return data;
 }
 
+function _umzug() {
+  const data = require("umzug");
+
+  _umzug = function _umzug() {
+    return data;
+  };
+
+  return data;
+}
+
 var _collection = require("./collection");
 
 var _collectionImporter = require("./collection-importer");
 
 var FieldTypes = _interopRequireWildcard(require("./fields"));
 
+var _migration = require("./migration");
+
 var _modelHook = require("./model-hook");
 
 var _operators = _interopRequireDefault(require("./operators"));
 
 const _excluded = ["drop"],
-      _excluded2 = ["repeat"];
+      _excluded2 = ["retry"];
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -76,8 +98,6 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
 function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
@@ -86,6 +106,8 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -108,6 +130,8 @@ class Database extends _events().EventEmitter {
   constructor(options) {
     super();
     this.sequelize = void 0;
+    this.migrator = void 0;
+    this.migrations = void 0;
     this.fieldTypes = new Map();
     this.options = void 0;
     this.models = new Map();
@@ -119,28 +143,29 @@ class Database extends _events().EventEmitter {
     this.modelHook = void 0;
     this.delayCollectionExtend = new Map();
 
-    if (options instanceof _sequelize().Sequelize) {
-      this.sequelize = options;
-    } else {
-      const opts = _objectSpread({
-        sync: {
-          alter: {
-            drop: false
-          },
-          force: false
-        }
-      }, options);
+    const opts = _objectSpread({
+      sync: {
+        alter: {
+          drop: false
+        },
+        force: false
+      }
+    }, options);
 
-      if (options.storage && options.storage !== ':memory:') {
-        if (!(0, _path().isAbsolute)(options.storage)) {
-          opts.storage = (0, _path().resolve)(process.cwd(), options.storage);
-        }
+    if (options.storage && options.storage !== ':memory:') {
+      if (!(0, _path().isAbsolute)(options.storage)) {
+        opts.storage = (0, _path().resolve)(process.cwd(), options.storage);
       }
+    }
 
-      this.sequelize = new (_sequelize().Sequelize)(opts);
-      this.options = opts;
+    if (options.dialect === 'sqlite') {
+      delete opts.timezone;
+    } else if (!opts.timezone) {
+      opts.timezone = '+00:00';
     }
 
+    this.sequelize = new (_sequelize().Sequelize)(opts);
+    this.options = opts;
     this.collections = new Map();
     this.modelHook = new _modelHook.ModelHook(this);
     this.on('afterDefineCollection', collection => {
@@ -170,6 +195,78 @@ class Database extends _events().EventEmitter {
     }
 
     this.initOperators();
+    const migratorOptions = this.options.migrator || {};
+
+    const context = _objectSpread({
+      db: this,
+      sequelize: this.sequelize,
+      queryInterface: this.sequelize.getQueryInterface()
+    }, migratorOptions.context);
+
+    this.migrations = new _migration.Migrations(context);
+    this.migrator = new (_umzug().Umzug)({
+      logger: migratorOptions.logger || console,
+      migrations: this.migrations.callback(),
+      context,
+      storage: new (_umzug().SequelizeStorage)(_objectSpread(_objectSpread({
+        modelName: `${this.options.tablePrefix || ''}migrations`
+      }, migratorOptions.storage), {}, {
+        sequelize: this.sequelize
+      }))
+    });
+  }
+
+  addMigration(item) {
+    return this.migrations.add(item);
+  }
+
+  addMigrations(options) {
+    const namespace = options.namespace,
+          context = options.context,
+          _options$extensions = options.extensions,
+          extensions = _options$extensions === void 0 ? ['js', 'ts'] : _options$extensions,
+          directory = options.directory;
+    const patten = `${directory}/*.{${extensions.join(',')}}`;
+
+    const files = _glob().default.sync(patten, {
+      ignore: ['**/*.d.ts']
+    });
+
+    var _iterator = _createForOfIteratorHelper(files),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const file = _step.value;
+        let filename = (0, _path().basename)(file);
+        filename = filename.substring(0, filename.lastIndexOf('.')) || filename;
+        this.migrations.add({
+          name: namespace ? `${namespace}/${filename}` : filename,
+          migration: this.requireModule(file),
+          context
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  inDialect(...dialect) {
+    return dialect.includes(this.sequelize.getDialect());
+  }
+
+  requireModule(module) {
+    if (typeof module === 'string') {
+      module = require(module);
+    }
+
+    if (typeof module !== 'object') {
+      return module;
+    }
+
+    return module.__esModule ? module.default : module;
   }
   /**
    * Add collection to database
@@ -209,10 +306,13 @@ class Database extends _events().EventEmitter {
     const collection = this.collections.get(name);
     this.emit('beforeRemoveCollection', collection);
     const result = this.collections.delete(name);
+    this.sequelize.modelManager.removeModel(collection.model);
 
     if (result) {
       this.emit('afterRemoveCollection', collection);
     }
+
+    return collection;
   }
 
   getModel(name) {
@@ -353,16 +453,27 @@ class Database extends _events().EventEmitter {
     })();
   }
 
+  collectionExistsInDb(name, options) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      const tables = yield _this3.sequelize.getQueryInterface().showAllTables({
+        transaction: options === null || options === void 0 ? void 0 : options.transaction
+      });
+      return !!tables.find(table => table === `${_this3.getTablePrefix()}${name}`);
+    })();
+  }
+
   isSqliteMemory() {
     return this.sequelize.getDialect() === 'sqlite' && _lodash().default.get(this.options, 'storage') == ':memory:';
   }
 
   auth(options = {}) {
-    var _this3 = this;
+    var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      const _options$repeat = options.repeat,
-            repeat = _options$repeat === void 0 ? 10 : _options$repeat,
+      const _options$retry = options.retry,
+            retry = _options$retry === void 0 ? 10 : _options$retry,
             others = _objectWithoutProperties(options, _excluded2);
 
       const delay = ms => new Promise(yea => setTimeout(yea, ms));
@@ -372,11 +483,11 @@ class Database extends _events().EventEmitter {
       const authenticate = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator(function* () {
           try {
-            yield _this3.sequelize.authenticate(others);
+            yield _this4.sequelize.authenticate(others);
             console.log('Connection has been established successfully.');
             return true;
           } catch (error) {
-            if (count >= repeat) {
+            if (count >= retry) {
               throw error;
             }
 
@@ -397,21 +508,21 @@ class Database extends _events().EventEmitter {
   }
 
   reconnect() {
-    var _this4 = this;
+    var _this5 = this;
 
     return _asyncToGenerator(function* () {
-      if (_this4.isSqliteMemory()) {
+      if (_this5.isSqliteMemory()) {
         return;
       } // @ts-ignore
 
 
-      const ConnectionManager = _this4.sequelize.dialect.connectionManager.constructor; // @ts-ignore
+      const ConnectionManager = _this5.sequelize.dialect.connectionManager.constructor; // @ts-ignore
 
-      const connectionManager = new ConnectionManager(_this4.sequelize.dialect, _this4.sequelize); // @ts-ignore
+      const connectionManager = new ConnectionManager(_this5.sequelize.dialect, _this5.sequelize); // @ts-ignore
 
-      _this4.sequelize.dialect.connectionManager = connectionManager; // @ts-ignore
+      _this5.sequelize.dialect.connectionManager = connectionManager; // @ts-ignore
 
-      _this4.sequelize.connectionManager = connectionManager;
+      _this5.sequelize.connectionManager = connectionManager;
     })();
   }
 
@@ -421,65 +532,66 @@ class Database extends _events().EventEmitter {
   }
 
   close() {
-    var _this5 = this;
+    var _this6 = this;
 
     return _asyncToGenerator(function* () {
-      if (_this5.isSqliteMemory()) {
+      if (_this6.isSqliteMemory()) {
         return;
       }
 
-      return _this5.sequelize.close();
+      return _this6.sequelize.close();
     })();
   }
 
   on(event, listener) {
-    const modelEventName = this.modelHook.isModelHook(event);
+    // NOTE: to match if event is a sequelize or model type
+    const type = this.modelHook.match(event);
 
-    if (modelEventName && !this.modelHook.hasBindEvent(modelEventName)) {
-      this.sequelize.addHook(modelEventName, this.modelHook.sequelizeHookBuilder(modelEventName));
-      this.modelHook.bindEvent(modelEventName);
+    if (type && !this.modelHook.hasBoundEvent(type)) {
+      this.sequelize.addHook(type, this.modelHook.buildSequelizeHook(type));
+      this.modelHook.bindEvent(type);
     }
 
     return super.on(event, listener);
   }
 
   import(options) {
-    var _this6 = this;
+    var _this7 = this;
 
     return _asyncToGenerator(function* () {
       const reader = new _collectionImporter.ImporterReader(options.directory, options.extensions);
       const modules = yield reader.read();
       const result = new Map();
 
-      var _iterator = _createForOfIteratorHelper(modules),
-          _step;
+      var _iterator2 = _createForOfIteratorHelper(modules),
+          _step2;
 
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          const module = _step.value;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          const module = _step2.value;
 
           if (module.extend) {
             const collectionName = module.collectionOptions.name;
 
-            const existCollection = _this6.getCollection(collectionName);
+            const existCollection = _this7.getCollection(collectionName);
 
             if (existCollection) {
               existCollection.updateOptions(module.collectionOptions, module.mergeOptions);
             } else {
-              const existDelayExtends = _this6.delayCollectionExtend.get(collectionName) || [];
+              const existDelayExtends = _this7.delayCollectionExtend.get(collectionName) || [];
 
-              _this6.delayCollectionExtend.set(collectionName, [...existDelayExtends, module]);
+              _this7.delayCollectionExtend.set(collectionName, [...existDelayExtends, module]);
             }
           } else {
-            const collection = _this6.collection(module);
+            const collection = _this7.collection(module);
 
             result.set(collection.name, collection);
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
 
       return result;