@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.0

package/lib/database.js

@@ -1,498 +1,304 @@
 "use strict";
-
-function _react() {
-  const data = _interopRequireDefault(require("react"));
-
-  _react = function _react() {
-    return data;
-  };
-
-  return data;
-}
-
-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 _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."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-  }
-
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
 };
-
-var __rest = void 0 && (void 0).__rest || function (s, e) {
-  var t = {};
-
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
 };
-
-var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : {
-    "default": mod
-  };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.extend = exports.Extend = void 0;
-
-const sequelize_1 = require("sequelize");
-
-const glob_1 = __importDefault(require("glob"));
-
-const table_1 = __importDefault(require("./table"));
-
-const utils_1 = require("./utils");
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendCollection = exports.defineCollection = exports.extend = exports.Database = void 0;
+const utils_1 = require("@nocobase/utils");
 const events_1 = require("events");
-
-class Extend {
-  constructor(tableOptions, mergeOptions) {
-    this.tableOptions = tableOptions;
-    this.mergeOptions = mergeOptions;
-  }
-
-}
-
-exports.Extend = Extend;
-
-function extend(tableOptions, mergeOptions = {}) {
-  return new Extend(tableOptions, mergeOptions);
-}
-
-exports.extend = extend;
-
+const lodash_1 = __importDefault(require("lodash"));
+const sequelize_1 = require("sequelize");
+const collection_1 = require("./collection");
+const collection_importer_1 = require("./collection-importer");
+const FieldTypes = __importStar(require("./fields"));
+const model_hook_1 = require("./model-hook");
+const operators_1 = __importDefault(require("./operators"));
 class Database extends events_1.EventEmitter {
-  constructor(options) {
-    super();
-    this.associating = new Set();
-    this.throughTables = new Map();
-    this.tables = new Map();
-    this.hooks = {};
-    this.extTableOptions = new Map();
-    this.hookTypes = new Map(Object.entries({
-      beforeValidate: 1,
-      afterValidate: 1,
-      beforeCreate: 1,
-      afterCreate: 1,
-      beforeDestroy: 1,
-      afterDestroy: 1,
-      beforeRestore: 1,
-      afterRestore: 1,
-      beforeUpdate: 1,
-      afterUpdate: 1,
-      beforeSave: 1,
-      afterSave: 1,
-      beforeBulkCreate: 2,
-      afterBulkCreate: 2,
-      beforeBulkDestroy: 3,
-      afterBulkDestroy: 3,
-      beforeBulkRestore: 3,
-      afterBulkRestore: 3,
-      beforeBulkUpdate: 3,
-      afterBulkUpdate: 3,
-      beforeSync: 4,
-      afterSync: 4,
-      beforeBulkSync: 4,
-      afterBulkSync: 4,
-      beforeDefine: 0,
-      afterDefine: 0,
-      beforeInit: 0,
-      afterInit: 0,
-      beforeConnect: 0,
-      afterConnect: 0,
-      beforeDisconnect: 0,
-      afterDisconnect: 0
-    }));
-    this.options = options;
-    this.sequelize = new sequelize_1.Sequelize(options);
-  }
-
-  _getHookType(event) {
-    if (typeof event === 'string') {
-      event = event.split('.');
+    constructor(options) {
+        super();
+        this.fieldTypes = new Map();
+        this.models = new Map();
+        this.repositories = new Map();
+        this.operators = new Map();
+        this.collections = new Map();
+        this.pendingFields = new Map();
+        this.modelCollection = new Map();
+        this.delayCollectionExtend = new Map();
+        if (options instanceof sequelize_1.Sequelize) {
+            this.sequelize = options;
+        }
+        else {
+            this.sequelize = new sequelize_1.Sequelize(options);
+            this.options = options;
+        }
+        this.collections = new Map();
+        this.modelHook = new model_hook_1.ModelHook(this);
+        this.on('afterDefineCollection', (collection) => {
+            var _a, _b;
+            // after collection defined, call bind method on pending fields
+            (_a = this.pendingFields.get(collection.name)) === null || _a === void 0 ? void 0 : _a.forEach((field) => field.bind());
+            (_b = this.delayCollectionExtend.get(collection.name)) === null || _b === void 0 ? void 0 : _b.forEach((collectionExtend) => {
+                collection.updateOptions(collectionExtend.collectionOptions, collectionExtend.mergeOptions);
+            });
+        });
+        // register database field types
+        for (const [name, field] of Object.entries(FieldTypes)) {
+            if (['Field', 'RelationField'].includes(name)) {
+                continue;
+            }
+            let key = name.replace(/Field$/g, '');
+            key = key.substring(0, 1).toLowerCase() + key.substring(1);
+            this.registerFieldTypes({
+                [key]: field,
+            });
+        }
+        this.initOperators();
+    }
+    /**
+     * Add collection to database
+     * @param options
+     */
+    collection(options) {
+        this.emit('beforeDefineCollection', options);
+        const collection = new collection_1.Collection(options, {
+            database: this,
+        });
+        this.collections.set(collection.name, collection);
+        this.modelCollection.set(collection.model, collection);
+        this.emit('afterDefineCollection', collection);
+        return collection;
     }
-
-    if (!Array.isArray(event)) {
-      return;
+    getTablePrefix() {
+        return this.options.tablePrefix || '';
     }
-
-    const hookType = [...event].pop();
-
-    if (!this.hookTypes.has(hookType)) {
-      return;
+    /**
+     * get exists collection by its name
+     * @param name
+     */
+    getCollection(name) {
+        return this.collections.get(name);
     }
-
-    return hookType;
-  }
-
-  on(event, listener) {
-    const hookType = this._getHookType(event);
-
-    if (hookType) {
-      const state = this.hookTypes.get(hookType);
-      this.sequelize.addHook(hookType, (...args) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
-
-        let modelName;
-
-        switch (state) {
-          case 1:
-            modelName = (_b = (_a = args === null || args === void 0 ? void 0 : args[0]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
-            break;
-
-          case 2:
-            modelName = (_d = (_c = args === null || args === void 0 ? void 0 : args[1]) === null || _c === void 0 ? void 0 : _c.model) === null || _d === void 0 ? void 0 : _d.name;
-            break;
-
-          case 3:
-            modelName = (_f = (_e = args === null || args === void 0 ? void 0 : args[0]) === null || _e === void 0 ? void 0 : _e.model) === null || _f === void 0 ? void 0 : _f.name;
-            break;
+    hasCollection(name) {
+        return this.collections.has(name);
+    }
+    removeCollection(name) {
+        const collection = this.collections.get(name);
+        this.emit('beforeRemoveCollection', collection);
+        const result = this.collections.delete(name);
+        if (result) {
+            this.emit('afterRemoveCollection', collection);
         }
-
-        if (modelName) {
-          yield this.emitAsync(`${modelName}.${hookType}`, ...args);
+    }
+    getModel(name) {
+        return this.getCollection(name).model;
+    }
+    getRepository(name, relationId) {
+        var _a, _b, _c;
+        if (relationId) {
+            const [collection, relation] = name.split('.');
+            return (_b = (_a = this.getRepository(collection)) === null || _a === void 0 ? void 0 : _a.relation(relation)) === null || _b === void 0 ? void 0 : _b.of(relationId);
         }
-
-        yield this.emitAsync(hookType, ...args);
-      }));
-      this.hookTypes.delete(hookType);
+        return (_c = this.getCollection(name)) === null || _c === void 0 ? void 0 : _c.repository;
     }
-
-    return super.on(event, listener);
-  }
-
-  emitAsync(event, ...args) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const events = this._events;
-      let callbacks = events === null || events === void 0 ? void 0 : events[event];
-
-      if (!callbacks) {
-        return false;
-      }
-
-      const run = cb => {
-        switch (args.length) {
-          case 0:
-            cb = cb.call(this);
-            break;
-
-          case 1:
-            cb = cb.call(this, args[0]);
-            break;
-
-          case 2:
-            cb = cb.call(this, args[0], args[1]);
-            break;
-
-          case 3:
-            cb = cb.call(this, args[0], args[1], args[2]);
-            break;
-
-          default:
-            cb = cb.apply(this, args);
+    addPendingField(field) {
+        const associating = this.pendingFields;
+        const items = this.pendingFields.get(field.target) || [];
+        items.push(field);
+        associating.set(field.target, items);
+    }
+    removePendingField(field) {
+        const items = this.pendingFields.get(field.target) || [];
+        const index = items.indexOf(field);
+        if (index !== -1) {
+            delete items[index];
+            this.pendingFields.set(field.target, items);
         }
-
-        if (cb && (cb instanceof Promise || typeof cb.then === 'function')) {
-          return cb;
+    }
+    registerFieldTypes(fieldTypes) {
+        for (const [type, fieldType] of Object.entries(fieldTypes)) {
+            this.fieldTypes.set(type, fieldType);
         }
-
-        return Promise.resolve(true);
-      };
-
-      if (typeof callbacks === 'function') {
-        yield run(callbacks);
-      } else if (typeof callbacks === 'object') {
-        callbacks = callbacks.slice().filter(Boolean);
-        yield callbacks.reduce((prev, next) => {
-          return prev.then(res => {
-            return run(next).then(result => Promise.resolve(res.concat(result)));
-          });
-        }, Promise.resolve([]));
-      }
-
-      return true;
-    });
-  }
-
-  import(options) {
-    const _options$extensions = options.extensions,
-          extensions = _options$extensions === void 0 ? ['js', 'ts', 'json'] : _options$extensions,
-          directory = options.directory;
-    const patten = `${directory}/*.{${extensions.join(',')}}`;
-    const files = glob_1.default.sync(patten, {
-      ignore: ['**/*.d.ts']
-    });
-    const tables = new Map();
-    files.forEach(file => {
-      const result = (0, utils_1.requireModule)(file);
-
-      if (result instanceof Extend) {
-        if (!this.tables.has(result.tableOptions.name)) {
-          this.extTableOptions.set(result.tableOptions.name, result);
-        } else {
-          const table = this.extend(result.tableOptions, result.mergeOptions);
-          tables.set(table.getName(), table);
+    }
+    registerModels(models) {
+        for (const [type, schemaType] of Object.entries(models)) {
+            this.models.set(type, schemaType);
         }
-      } else {
-        let table = this.extend(typeof result === 'function' ? result(this) : result);
-
-        if (this.extTableOptions.has(table.getName())) {
-          const result = this.extTableOptions.get(table.getName());
-          table = this.extend(result.tableOptions, result.mergeOptions);
-          this.extTableOptions.delete(table.getName());
+    }
+    registerRepositories(repositories) {
+        for (const [type, schemaType] of Object.entries(repositories)) {
+            this.repositories.set(type, schemaType);
         }
-
-        tables.set(table.getName(), table);
-      }
-    });
-    return tables;
-  }
-
-  table(options) {
-    const name = options.name;
-    const table = new table_1.default(options, {
-      database: this
-    });
-    this.tables.set(name, table);
-
-    if (this.throughTables.has(name)) {
-      const _this$getTables = this.getTables(this.throughTables.get(name)),
-            _this$getTables2 = _slicedToArray(_this$getTables, 2),
-            sourceTable = _this$getTables2[0],
-            targetTable = _this$getTables2[1];
-
-      sourceTable && sourceTable.modelInit(true);
-      targetTable && targetTable.modelInit(true);
     }
-
-    return table;
-  }
-
-  extend(options, mergeOptions) {
-    const name = options.name;
-    let table;
-
-    if (this.tables.has(name)) {
-      table = this.tables.get(name);
-      table.extend(options, mergeOptions);
-    } else {
-      table = this.table(options);
-      this.tables.set(name, table);
+    initOperators() {
+        const operators = new Map();
+        // Sequelize 内置
+        for (const key in sequelize_1.Op) {
+            operators.set('$' + key, sequelize_1.Op[key]);
+            const val = sequelize_1.Utils.underscoredIf(key, true);
+            operators.set('$' + val, sequelize_1.Op[key]);
+            operators.set('$' + val.replace(/_/g, ''), sequelize_1.Op[key]);
+        }
+        this.operators = operators;
+        this.registerOperators(Object.assign({}, operators_1.default));
     }
-
-    return table;
-  }
-
-  isDefined(name) {
-    return this.sequelize.isDefined(name);
-  }
-
-  getModel(name) {
-    return this.isDefined(name) ? this.sequelize.model(name) : undefined;
-  }
-
-  getModels(names = []) {
-    if (names.length === 0) {
-      return this.sequelize.models;
+    registerOperators(operators) {
+        for (const [key, operator] of Object.entries(operators)) {
+            this.operators.set(key, operator);
+        }
     }
-
-    return names.map(name => this.getModel(name));
-  }
-
-  getTable(name) {
-    return this.tables.has(name) ? this.tables.get(name) : undefined;
-  }
-
-  getTables(names = []) {
-    if (names.length === 0) {
-      return [...this.tables.values()];
+    buildField(options, context) {
+        const { type } = options;
+        const Field = this.fieldTypes.get(type);
+        if (!Field) {
+            throw Error(`unsupported field type ${type}`);
+        }
+        return new Field(options, context);
     }
-
-    return names.map(name => this.getTable(name));
-  }
-
-  associate() {
-    var _iterator = _createForOfIteratorHelper(this.associating),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        const name = _step.value;
-        const Model = this.getModel(name);
-        Model.associate && Model.associate(this.sequelize.models);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+    sync(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isMySQL = this.sequelize.getDialect() === 'mysql';
+            if (isMySQL) {
+                yield this.sequelize.query('SET FOREIGN_KEY_CHECKS = 0', null);
+            }
+            const result = yield this.sequelize.sync(options);
+            if (isMySQL) {
+                yield this.sequelize.query('SET FOREIGN_KEY_CHECKS = 1', null);
+            }
+            return result;
+        });
     }
-  }
-
-  plugin(plugin, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      yield plugin(this, options);
-    });
-  }
-
-  sync(options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const _options$tables = options.tables,
-            tables = _options$tables === void 0 ? [] : _options$tables,
-            restOptions = __rest(options, ["tables"]);
-
-      let items;
-
-      if (tables instanceof Map) {
-        items = Array.from(tables.values());
-      } else {
-        items = tables;
-      }
-
-      if (items.length > 0) {
-        const sequelize = new sequelize_1.Sequelize(this.options);
-        const names = new Set();
-
-        for (const key in items) {
-          let table = items[key];
-
-          if (typeof table === 'string') {
-            table = this.getTable(table);
-          }
-
-          if (table instanceof table_1.default) {
-            var _iterator2 = _createForOfIteratorHelper(table.getRelatedTableNames()),
-                _step2;
-
-            try {
-              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                const name = _step2.value;
-                names.add(name);
-              }
-            } catch (err) {
-              _iterator2.e(err);
-            } finally {
-              _iterator2.f();
+    clean(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { drop } = options, others = __rest(options, ["drop"]);
+            if (drop) {
+                yield this.sequelize.getQueryInterface().dropAllTables(others);
             }
-          }
-        }
-
-        var _iterator3 = _createForOfIteratorHelper(names),
-            _step3;
-
-        try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            const name = _step3.value;
-            const model = this.getModel(name);
-
-            if (model) {
-              sequelize.modelManager.addModel(model);
+        });
+    }
+    isSqliteMemory() {
+        return this.sequelize.getDialect() === 'sqlite' && lodash_1.default.get(this.options, 'storage') == ':memory:';
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSqliteMemory()) {
+                return;
             }
-          }
-        } catch (err) {
-          _iterator3.e(err);
-        } finally {
-          _iterator3.f();
-        }
-
-        yield sequelize.sync(restOptions);
-        yield sequelize.close();
-      } else {
-        yield this.sequelize.sync(restOptions);
-      }
-    });
-  }
-
-  close() {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.removeAllListeners();
-      return this.sequelize.close();
-    });
-  }
-
-  addHook(hookType, fn) {
-    const hooks = this.hooks[hookType] || [];
-    hooks.push(fn);
-    this.hooks[hookType] = hooks;
-  }
-
-  runHooks(hookType, ...args) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const hooks = this.hooks[hookType] || [];
-
-      var _iterator4 = _createForOfIteratorHelper(hooks),
-          _step4;
-
-      try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          const hook = _step4.value;
-
-          if (typeof hook === 'function') {
-            yield hook(...args);
-          }
+            // @ts-ignore
+            const ConnectionManager = this.sequelize.dialect.connectionManager.constructor;
+            // @ts-ignore
+            const connectionManager = new ConnectionManager(this.sequelize.dialect, this.sequelize);
+            // @ts-ignore
+            this.sequelize.dialect.connectionManager = connectionManager;
+            // @ts-ignore
+            this.sequelize.connectionManager = connectionManager;
+        });
+    }
+    closed() {
+        // @ts-ignore
+        return this.sequelize.connectionManager.pool._draining;
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSqliteMemory()) {
+                return;
+            }
+            return this.sequelize.close();
+        });
+    }
+    on(event, listener) {
+        const modelEventName = this.modelHook.isModelHook(event);
+        if (modelEventName && !this.modelHook.hasBindEvent(modelEventName)) {
+            this.sequelize.addHook(modelEventName, this.modelHook.sequelizeHookBuilder(modelEventName));
+            this.modelHook.bindEvent(modelEventName);
         }
-      } catch (err) {
-        _iterator4.e(err);
-      } finally {
-        _iterator4.f();
-      }
-    });
-  }
-
-  getFieldByPath(fieldPath) {
-    const _fieldPath$split = fieldPath.split('.'),
-          _fieldPath$split2 = _slicedToArray(_fieldPath$split, 2),
-          tableName = _fieldPath$split2[0],
-          fieldName = _fieldPath$split2[1];
-
-    return this.getTable(tableName).getField(fieldName);
-  }
-
+        return super.on(event, listener);
+    }
+    import(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reader = new collection_importer_1.ImporterReader(options.directory, options.extensions);
+            const modules = yield reader.read();
+            const result = new Map();
+            for (const module of modules) {
+                if (module.extend) {
+                    const collectionName = module.collectionOptions.name;
+                    const existCollection = this.getCollection(collectionName);
+                    if (existCollection) {
+                        existCollection.updateOptions(module.collectionOptions, module.mergeOptions);
+                    }
+                    else {
+                        const existDelayExtends = this.delayCollectionExtend.get(collectionName) || [];
+                        this.delayCollectionExtend.set(collectionName, [...existDelayExtends, module]);
+                    }
+                }
+                else {
+                    const collection = this.collection(module);
+                    result.set(collection.name, collection);
+                }
+            }
+            return result;
+        });
+    }
+}
+exports.Database = Database;
+function extend(collectionOptions, mergeOptions) {
+    return {
+        collectionOptions,
+        mergeOptions,
+        extend: true,
+    };
 }
-
+exports.extend = extend;
+const defineCollection = (collectionOptions) => {
+    return collectionOptions;
+};
+exports.defineCollection = defineCollection;
+const extendCollection = (collectionOptions, mergeOptions) => {
+    return {
+        collectionOptions,
+        mergeOptions,
+        extend: true,
+    };
+};
+exports.extendCollection = extendCollection;
+(0, utils_1.applyMixins)(Database, [utils_1.AsyncEmitter]);
 exports.default = Database;
-//# sourceMappingURL=database.js.map
+//# sourceMappingURL=database.js.map