@nocobase/database 0.7.6-alpha.2 → 0.8.0-alpha.4

package/lib/collection.d.ts

@@ -41,7 +41,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     get filterTargetKey(): string;
     get name(): string;
     get db(): Database;
-    constructor(options: CollectionOptions, context?: CollectionContext);
+    constructor(options: CollectionOptions, context: CollectionContext);
     private checkOptions;
     private sequelizeModelOptions;
     /**

package/lib/collection.js

@@ -102,6 +102,7 @@ class Collection extends _events().EventEmitter {
     this.options = options;
     this.bindFieldEventListener();
     this.modelInit();
+    this.db.modelCollection.set(this.model, this);
     this.setFields(options.fields);
     this.setRepository(options.repository);
     this.setSortable(options.sortable);

package/lib/database.d.ts

@@ -13,6 +13,8 @@ import { Model } from './model';
 import { ModelHook } from './model-hook';
 import { RelationRepository } from './relation-repository/relation-repository';
 import { Repository } from './repository';
+import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
+import ReferencesMap from './features/ReferencesMap';
 export interface MergeOptions extends merge.Options {
 }
 export interface PendingOptions {
@@ -60,6 +62,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     collections: Map<string, Collection<any, any>>;
     pendingFields: Map<string, FieldTypes.RelationField[]>;
     modelCollection: Map<ModelCtor<any>, Collection<any, any>>;
+    referenceMap: ReferencesMap;
     modelHook: ModelHook;
     version: DatabaseVersion;
     delayCollectionExtend: Map<string, {
@@ -67,10 +70,10 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         mergeOptions?: any;
     }[]>;
     constructor(options: DatabaseOptions);
+    initListener(): void;
     addMigration(item: MigrationItem): void;
     addMigrations(options: AddMigrationsOptions): void;
     inDialect(...dialect: string[]): boolean;
-    private requireModule;
     /**
      * Add collection to database
      * @param options
@@ -105,7 +108,19 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     reconnect(): Promise<void>;
     closed(): any;
     close(): Promise<void>;
-    on(event: string | symbol, listener: any): this;
+    on(event: EventType, listener: any): this;
+    on(event: ModelValidateEventTypes, listener: SyncListener): this;
+    on(event: ModelValidateEventTypes, listener: ValidateListener): this;
+    on(event: ModelCreateEventTypes, listener: CreateListener): this;
+    on(event: ModelUpdateEventTypes, listener: UpdateListener): this;
+    on(event: ModelSaveEventTypes, listener: SaveListener): this;
+    on(event: ModelDestroyEventTypes, listener: DestroyListener): this;
+    on(event: ModelCreateWithAssociationsEventTypes, listener: CreateWithAssociationsListener): this;
+    on(event: ModelUpdateWithAssociationsEventTypes, listener: UpdateWithAssociationsListener): this;
+    on(event: ModelSaveWithAssociationsEventTypes, listener: SaveWithAssociationsListener): this;
+    on(event: DatabaseBeforeDefineCollectionEventType, listener: BeforeDefineCollectionListener): this;
+    on(event: DatabaseAfterDefineCollectionEventType, listener: AfterDefineCollectionListener): this;
+    on(event: DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType, listener: RemoveCollectionListener): this;
     extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): void;
     import(options: {
         directory: string;

package/lib/database.js

@@ -98,6 +98,10 @@ var _modelHook = require("./model-hook");
 
 var _operators = _interopRequireDefault(require("./operators"));
 
+var _referentialIntegrityCheck = require("./features/referential-integrity-check");
+
+var _ReferencesMap = _interopRequireDefault(require("./features/ReferencesMap"));
+
 const _excluded = ["drop"],
       _excluded2 = ["retry"];
 
@@ -192,7 +196,8 @@ class DatabaseVersion {
 
 class Database extends _events().EventEmitter {
   constructor(options) {
-    super();
+    super(); // this.setMaxListeners(100);
+
     this.sequelize = void 0;
     this.migrator = void 0;
     this.migrations = void 0;
@@ -204,6 +209,7 @@ class Database extends _events().EventEmitter {
     this.collections = new Map();
     this.pendingFields = new Map();
     this.modelCollection = new Map();
+    this.referenceMap = new _ReferencesMap.default();
     this.modelHook = void 0;
     this.version = void 0;
     this.delayCollectionExtend = new Map();
@@ -285,6 +291,12 @@ class Database extends _events().EventEmitter {
         opts.tableName = `${this.options.tablePrefix}${opts.tableName || opts.modelName || opts.name.plural}`;
       }
     });
+    this.initListener();
+  }
+
+  initListener() {
+    var _this2 = this;
+
     this.on('afterCreate', /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (instance) {
         var _instance$toChangedWi;
@@ -307,6 +319,19 @@ class Database extends _events().EventEmitter {
         return _ref2.apply(this, arguments);
       };
     }());
+    this.on('beforeDestroy', /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(function* (instance, options) {
+        yield (0, _referentialIntegrityCheck.referentialIntegrityCheck)({
+          db: _this2,
+          referencedInstance: instance,
+          transaction: options.transaction
+        });
+      });
+
+      return function (_x3, _x4) {
+        return _ref3.apply(this, arguments);
+      };
+    }());
   }
 
   addMigration(item) {
@@ -335,7 +360,7 @@ class Database extends _events().EventEmitter {
         filename = filename.substring(0, filename.lastIndexOf('.')) || filename;
         this.migrations.add({
           name: namespace ? `${namespace}/${filename}` : filename,
-          migration: this.requireModule(file),
+          migration: (0, _utils().requireModule)(file),
           context
         });
       }
@@ -349,18 +374,6 @@ class Database extends _events().EventEmitter {
   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
    * @param options
@@ -373,7 +386,6 @@ class Database extends _events().EventEmitter {
       database: this
     });
     this.collections.set(collection.name, collection);
-    this.modelCollection.set(collection.model, collection);
     this.emit('afterDefineCollection', collection);
     return collection;
   }
@@ -514,19 +526,19 @@ class Database extends _events().EventEmitter {
   }
 
   sync(options) {
-    var _this2 = this;
+    var _this3 = this;
 
     return _asyncToGenerator(function* () {
-      const isMySQL = _this2.sequelize.getDialect() === 'mysql';
+      const isMySQL = _this3.sequelize.getDialect() === 'mysql';
 
       if (isMySQL) {
-        yield _this2.sequelize.query('SET FOREIGN_KEY_CHECKS = 0', null);
+        yield _this3.sequelize.query('SET FOREIGN_KEY_CHECKS = 0', null);
       }
 
-      const result = yield _this2.sequelize.sync(options);
+      const result = yield _this3.sequelize.sync(options);
 
       if (isMySQL) {
-        yield _this2.sequelize.query('SET FOREIGN_KEY_CHECKS = 1', null);
+        yield _this3.sequelize.query('SET FOREIGN_KEY_CHECKS = 1', null);
       }
 
       return result;
@@ -534,26 +546,26 @@ class Database extends _events().EventEmitter {
   }
 
   clean(options) {
-    var _this3 = this;
+    var _this4 = this;
 
     return _asyncToGenerator(function* () {
       const drop = options.drop,
             others = _objectWithoutProperties(options, _excluded);
 
       if (drop) {
-        yield _this3.sequelize.getQueryInterface().dropAllTables(others);
+        yield _this4.sequelize.getQueryInterface().dropAllTables(others);
       }
     })();
   }
 
   collectionExistsInDb(name, options) {
-    var _this4 = this;
+    var _this5 = this;
 
     return _asyncToGenerator(function* () {
-      const tables = yield _this4.sequelize.getQueryInterface().showAllTables({
+      const tables = yield _this5.sequelize.getQueryInterface().showAllTables({
         transaction: options === null || options === void 0 ? void 0 : options.transaction
       });
-      return !!tables.find(table => table === `${_this4.getTablePrefix()}${name}`);
+      return !!tables.find(table => table === `${_this5.getTablePrefix()}${name}`);
     })();
   }
 
@@ -562,7 +574,7 @@ class Database extends _events().EventEmitter {
   }
 
   auth(options = {}) {
-    var _this5 = this;
+    var _this6 = this;
 
     return _asyncToGenerator(function* () {
       const _options$retry = options.retry,
@@ -574,9 +586,9 @@ class Database extends _events().EventEmitter {
       let count = 1;
 
       const authenticate = /*#__PURE__*/function () {
-        var _ref3 = _asyncToGenerator(function* () {
+        var _ref4 = _asyncToGenerator(function* () {
           try {
-            yield _this5.sequelize.authenticate(others);
+            yield _this6.sequelize.authenticate(others);
             console.log('Connection has been established successfully.');
             return true;
           } catch (error) {
@@ -592,7 +604,7 @@ class Database extends _events().EventEmitter {
         });
 
         return function authenticate() {
-          return _ref3.apply(this, arguments);
+          return _ref4.apply(this, arguments);
         };
       }();
 
@@ -601,21 +613,21 @@ class Database extends _events().EventEmitter {
   }
 
   reconnect() {
-    var _this6 = this;
+    var _this7 = this;
 
     return _asyncToGenerator(function* () {
-      if (_this6.isSqliteMemory()) {
+      if (_this7.isSqliteMemory()) {
         return;
       } // @ts-ignore
 
 
-      const ConnectionManager = _this6.sequelize.dialect.connectionManager.constructor; // @ts-ignore
+      const ConnectionManager = _this7.sequelize.dialect.connectionManager.constructor; // @ts-ignore
 
-      const connectionManager = new ConnectionManager(_this6.sequelize.dialect, _this6.sequelize); // @ts-ignore
+      const connectionManager = new ConnectionManager(_this7.sequelize.dialect, _this7.sequelize); // @ts-ignore
 
-      _this6.sequelize.dialect.connectionManager = connectionManager; // @ts-ignore
+      _this7.sequelize.dialect.connectionManager = connectionManager; // @ts-ignore
 
-      _this6.sequelize.connectionManager = connectionManager;
+      _this7.sequelize.connectionManager = connectionManager;
     })();
   }
 
@@ -625,14 +637,14 @@ class Database extends _events().EventEmitter {
   }
 
   close() {
-    var _this7 = this;
+    var _this8 = this;
 
     return _asyncToGenerator(function* () {
-      if (_this7.isSqliteMemory()) {
+      if (_this8.isSqliteMemory()) {
         return;
       }
 
-      return _this7.sequelize.close();
+      return _this8.sequelize.close();
     })();
   }
 
@@ -664,7 +676,7 @@ class Database extends _events().EventEmitter {
   }
 
   import(options) {
-    var _this8 = this;
+    var _this9 = this;
 
     return _asyncToGenerator(function* () {
       const reader = new _collectionImporter.ImporterReader(options.directory, options.extensions);
@@ -679,9 +691,9 @@ class Database extends _events().EventEmitter {
           const module = _step2.value;
 
           if (module.extend) {
-            _this8.extendCollection(module.collectionOptions, module.mergeOptions);
+            _this9.extendCollection(module.collectionOptions, module.mergeOptions);
           } else {
-            const collection = _this8.collection(module);
+            const collection = _this9.collection(module);
 
             result.set(collection.name, collection);
           }

package/lib/features/ReferencesMap.d.ts

@@ -0,0 +1,15 @@
+export interface Reference {
+    sourceCollectionName: string;
+    sourceField: string;
+    targetField: string;
+    targetCollectionName: string;
+    onDelete: string;
+}
+declare class ReferencesMap {
+    protected map: Map<string, Reference[]>;
+    addReference(reference: Reference): void;
+    getReferences(collectionName: any): Reference[];
+    existReference(reference: Reference): Reference;
+    removeReference(reference: Reference): void;
+}
+export default ReferencesMap;

package/lib/features/ReferencesMap.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class ReferencesMap {
+  constructor() {
+    this.map = new Map();
+  }
+
+  addReference(reference) {
+    const existReference = this.existReference(reference);
+
+    if (existReference) {
+      if (reference.onDelete && existReference.onDelete !== reference.onDelete) {
+        throw new Error(`On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(reference)}`);
+      }
+
+      return;
+    }
+
+    if (!reference.onDelete) {
+      reference.onDelete = 'SET NULL';
+    }
+
+    this.map.set(reference.targetCollectionName, [...(this.map.get(reference.targetCollectionName) || []), reference]);
+  }
+
+  getReferences(collectionName) {
+    return this.map.get(collectionName);
+  }
+
+  existReference(reference) {
+    const references = this.map.get(reference.targetCollectionName);
+
+    if (!references) {
+      return null;
+    }
+
+    const keys = Object.keys(reference).filter(k => k !== 'onDelete');
+    return references.find(ref => keys.every(key => ref[key] === reference[key]));
+  }
+
+  removeReference(reference) {
+    const references = this.map.get(reference.targetCollectionName);
+
+    if (!references) {
+      return;
+    }
+
+    const keys = Object.keys(reference);
+    this.map.set(reference.targetCollectionName, references.filter(ref => !keys.every(key => ref[key] === reference[key])));
+  }
+
+}
+
+var _default = ReferencesMap;
+exports.default = _default;

package/lib/features/referential-integrity-check.d.ts

@@ -0,0 +1,8 @@
+import Database from '../database';
+import { Model, Transactionable } from 'sequelize';
+interface ReferentialIntegrityCheckOptions extends Transactionable {
+    db: Database;
+    referencedInstance: Model;
+}
+export declare function referentialIntegrityCheck(options: ReferentialIntegrityCheckOptions): Promise<void>;
+export {};

package/lib/features/referential-integrity-check.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.referentialIntegrityCheck = referentialIntegrityCheck;
+
+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(_e) { throw _e; }, 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(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+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 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 referentialIntegrityCheck(_x) {
+  return _referentialIntegrityCheck.apply(this, arguments);
+}
+
+function _referentialIntegrityCheck() {
+  _referentialIntegrityCheck = _asyncToGenerator(function* (options) {
+    const referencedInstance = options.referencedInstance,
+          db = options.db,
+          transaction = options.transaction; // @ts-ignore
+
+    const collection = db.modelCollection.get(referencedInstance.constructor);
+    const collectionName = collection.name;
+    const references = db.referenceMap.getReferences(collectionName);
+
+    if (!references) {
+      return;
+    }
+
+    var _iterator = _createForOfIteratorHelper(references),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const reference = _step.value;
+        const sourceCollectionName = reference.sourceCollectionName,
+              sourceField = reference.sourceField,
+              targetField = reference.targetField,
+              onDelete = reference.onDelete;
+        const sourceCollection = db.collections.get(sourceCollectionName);
+        const sourceRepository = sourceCollection.repository;
+        const filter = {
+          [sourceField]: referencedInstance[targetField]
+        };
+        const referencingExists = yield sourceRepository.count({
+          filter,
+          transaction
+        });
+
+        if (!referencingExists) {
+          continue;
+        }
+
+        if (onDelete === 'RESTRICT') {
+          throw new Error('RESTRICT');
+        }
+
+        if (onDelete === 'CASCADE') {
+          yield sourceRepository.destroy({
+            filter: filter,
+            transaction
+          });
+        }
+
+        if (onDelete === 'SET NULL') {
+          yield sourceRepository.update({
+            filter,
+            values: {
+              [sourceField]: null
+            },
+            hooks: false,
+            transaction
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  });
+  return _referentialIntegrityCheck.apply(this, arguments);
+}

package/lib/fields/belongs-to-field.d.ts

@@ -1,8 +1,10 @@
 import { BelongsToOptions as SequelizeBelongsToOptions } from 'sequelize';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 export declare class BelongsToField extends RelationField {
     static type: string;
     get target(): any;
+    reference(association: any): Reference;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/belongs-to-field.js

@@ -43,6 +43,17 @@ class BelongsToField extends _relationField.RelationField {
     return target || _sequelize().Utils.pluralize(name);
   }
 
+  reference(association) {
+    const targetKey = association.targetKey;
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.source).name,
+      sourceField: association.foreignKey,
+      targetField: targetKey,
+      targetCollectionName: this.database.modelCollection.get(association.target).name,
+      onDelete: this.options.onDelete
+    };
+  }
+
   bind() {
     const _this$context = this.context,
           database = _this$context.database,
@@ -63,7 +74,7 @@ class BelongsToField extends _relationField.RelationField {
     const association = collection.model.belongsTo(Target, _objectSpread({
       as: this.name,
       constraints: false
-    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target']))); // inverse relation
+    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target', 'onDelete']))); // inverse relation
     // this.TargetModel.hasMany(collection.model);
     // 建立关系之后从 pending 列表中删除
 
@@ -86,6 +97,7 @@ class BelongsToField extends _relationField.RelationField {
     }
 
     this.collection.addIndex([this.options.foreignKey]);
+    this.database.referenceMap.addReference(this.reference(association));
     return true;
   }
 
@@ -105,8 +117,10 @@ class BelongsToField extends _relationField.RelationField {
 
     if (!field1 && !field2) {
       collection.model.removeAttribute(foreignKey);
-    } // 删掉 model 的关联字段
+    }
 
+    const association = collection.model.associations[this.name];
+    this.database.referenceMap.removeReference(this.reference(association)); // 删掉 model 的关联字段
 
     delete collection.model.associations[this.name]; // @ts-ignore
 

package/lib/fields/belongs-to-many-field.d.ts

@@ -2,6 +2,7 @@ import { BelongsToManyOptions as SequelizeBelongsToManyOptions } from 'sequelize
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 export declare class BelongsToManyField extends RelationField {
     get through(): any;
+    get otherKey(): any;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/belongs-to-many-field.js

@@ -40,6 +40,10 @@ class BelongsToManyField extends _relationField.RelationField {
     return this.options.through || _sequelize().Utils.camelize([this.context.collection.model.name, this.target].map(name => name.toLowerCase()).sort().join('_'));
   }
 
+  get otherKey() {
+    return this.options.otherKey;
+  }
+
   bind() {
     const _this$context = this.context,
           database = _this$context.database,
@@ -58,7 +62,8 @@ class BelongsToManyField extends _relationField.RelationField {
       Through = database.getCollection(through);
     } else {
       Through = database.collection({
-        name: through
+        name: through // timestamps: false,
+
       });
       Object.defineProperty(Through.model, 'isThrough', {
         value: true
@@ -106,7 +111,8 @@ class BelongsToManyField extends _relationField.RelationField {
   unbind() {
     const _this$context2 = this.context,
           database = _this$context2.database,
-          collection = _this$context2.collection; // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+          collection = _this$context2.collection;
+    const Through = database.getCollection(this.through); // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
 
     database.removePendingField(this); // 删掉 model 的关联字段
 

package/lib/fields/context-field.d.ts

@@ -1,7 +1,8 @@
+import { Model } from '../model';
 import { BaseColumnFieldOptions, Field } from './field';
 export declare class ContextField extends Field {
     get dataType(): any;
-    init(): void;
+    listener: (model: Model, options: any) => Promise<void>;
     bind(): void;
     unbind(): void;
 }

package/lib/fields/context-field.js

@@ -34,18 +34,17 @@ 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); }); }; }
 
 class ContextField extends _field.Field {
-  get dataType() {
-    const type = this.options.dataType || 'string';
-    return _sequelize().DataTypes[type.toUpperCase()] || _sequelize().DataTypes.STRING;
-  }
+  constructor(...args) {
+    var _this;
 
-  init() {
-    const _this$options = this.options,
-          name = _this$options.name,
-          dataIndex = _this$options.dataIndex;
+    super(...args);
+    _this = this;
 
     this.listener = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (model, options) {
+        const _this$options = _this.options,
+              name = _this$options.name,
+              dataIndex = _this$options.dataIndex;
         const context = options.context;
         model.set(name, _lodash().default.get(context, dataIndex));
         model.changed(name, true);
@@ -57,6 +56,11 @@ class ContextField extends _field.Field {
     }();
   }
 
+  get dataType() {
+    const type = this.options.dataType || 'string';
+    return _sequelize().DataTypes[type.toUpperCase()] || _sequelize().DataTypes.STRING;
+  }
+
   bind() {
     super.bind();
     const createOnly = this.options.createOnly;

package/lib/fields/field.d.ts

@@ -1,6 +1,7 @@
 import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, QueryInterfaceOptions, SyncOptions, Transactionable } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
+import { ModelEventTypes } from '../types';
 export interface FieldContext {
     database: Database;
     collection: Collection;
@@ -26,7 +27,7 @@ export declare abstract class Field {
     constructor(options?: any, context?: FieldContext);
     sync(syncOptions: SyncOptions): Promise<void>;
     init(): void;
-    on(eventName: string, listener: (...args: any[]) => void): this;
+    on(eventName: ModelEventTypes, listener: (...args: any[]) => void): this;
     off(eventName: string, listener: (...args: any[]) => void): this;
     get(name: string): any;
     remove(): void | Field;

package/lib/fields/field.js

@@ -95,6 +95,7 @@ class Field {
   }
 
   remove() {
+    this.collection.removeIndex([this.name]);
     return this.collection.removeField(this.name);
   }