@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.2

package/lib/collection-importer.js

@@ -83,7 +83,7 @@ class ImporterReader {
         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));
+      return (yield Promise.all(modules)).filter(module => (0, _lodash().isPlainObject)(module)).map(module => (0, _lodash().cloneDeep)(module));
     })();
   }
 

package/lib/collection.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { ModelOptions, QueryInterfaceDropTableOptions, SyncOptions, Transactionable, ModelStatic } from 'sequelize';
+import { ModelOptions, ModelStatic, QueryInterfaceDropTableOptions, SyncOptions, Transactionable } from 'sequelize';
 import { Database } from './database';
 import { Field, FieldOptions } from './fields';
 import { Model } from './model';
@@ -41,9 +41,12 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     repository: Repository<TModelAttributes, TCreationAttributes>;
     get filterTargetKey(): string;
     get name(): string;
+    get titleField(): string;
     get db(): Database;
     constructor(options: CollectionOptions, context: CollectionContext);
     private checkOptions;
+    private checkTableName;
+    tableName(): any;
     private sequelizeModelOptions;
     /**
      * TODO
@@ -56,12 +59,13 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     hasField(name: string): boolean;
     getField<F extends Field>(name: string): F;
     addField(name: string, options: FieldOptions): Field;
+    checkFieldType(name: string, options: FieldOptions): void;
     setField(name: string, options: FieldOptions): Field;
     setFields(fields: FieldOptions[], resetFields?: boolean): void;
     resetFields(): void;
     remove(): void;
     removeFromDb(options?: QueryInterfaceDropTableOptions): Promise<void>;
-    existsInDb(options?: Transactionable): Promise<boolean>;
+    existsInDb(options?: Transactionable): any;
     removeField(name: string): void | Field;
     /**
      * TODO
@@ -85,4 +89,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     sync(syncOptions?: SyncOptions): Promise<void>;
     isInherited(): boolean;
     isParent(): boolean;
+    addSchemaTableName(): any;
+    quotedTableName(): any;
+    collectionSchema(): string;
 }

package/lib/collection.js

@@ -64,18 +64,26 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 
 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; }
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+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 _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; }
+
+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 _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; }
+
 class Collection extends _events().EventEmitter {
   get filterTargetKey() {
     return _lodash().default.get(this.options, 'filterTargetKey', this.model.primaryKeyAttribute);
@@ -85,6 +93,10 @@ class Collection extends _events().EventEmitter {
     return this.options.name;
   }
 
+  get titleField() {
+    return this.options.titleField || this.model.primaryKeyAttribute;
+  }
+
   get db() {
     return this.context.database;
   }
@@ -97,9 +109,9 @@ class Collection extends _events().EventEmitter {
     this.fields = new Map();
     this.model = void 0;
     this.repository = void 0;
-    this.checkOptions(options);
     this.context = context;
     this.options = options;
+    this.checkOptions(options);
     this.bindFieldEventListener();
     this.modelInit();
     this.db.modelCollection.set(this.model, this);
@@ -115,16 +127,46 @@ class Collection extends _events().EventEmitter {
 
   checkOptions(options) {
     (0, _utils.checkIdentifier)(options.name);
+    this.checkTableName();
   }
 
-  sequelizeModelOptions() {
+  checkTableName() {
+    const tableName = this.tableName();
+
+    var _iterator = _createForOfIteratorHelper(this.db.collections),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const _step$value = _slicedToArray(_step.value, 2),
+              k = _step$value[0],
+              collection = _step$value[1];
+
+        if (collection.name != this.options.name && tableName === collection.tableName()) {
+          throw new Error(`collection ${collection.name} and ${this.name} have same tableName "${tableName}"`);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  tableName() {
     const _this$options = this.options,
           name = _this$options.name,
           tableName = _this$options.tableName;
+    const tName = tableName || name;
+    return this.db.options.underscored ? (0, _utils.snakeCase)(tName) : tName;
+  }
+
+  sequelizeModelOptions() {
+    const name = this.options.name;
     return _objectSpread(_objectSpread({}, _lodash().default.omit(this.options, ['name', 'fields', 'model', 'targetKey'])), {}, {
       modelName: name,
       sequelize: this.context.database.sequelize,
-      tableName: tableName || name
+      tableName: this.tableName()
     });
   }
   /**
@@ -217,8 +259,36 @@ class Collection extends _events().EventEmitter {
     return this.setField(name, options);
   }
 
+  checkFieldType(name, options) {
+    if (!this.db.options.underscored) {
+      return;
+    }
+
+    const fieldName = options.field || (0, _utils.snakeCase)(name);
+    const field = this.findField(f => {
+      if (f.name === name) {
+        return false;
+      }
+
+      if (f.field) {
+        return f.field === fieldName;
+      }
+
+      return (0, _utils.snakeCase)(f.name) === fieldName;
+    });
+
+    if (!field) {
+      return;
+    }
+
+    if (options.type !== field.type) {
+      throw new Error(`fields with same column must be of the same type ${JSON.stringify(options)}`);
+    }
+  }
+
   setField(name, options) {
     (0, _utils.checkIdentifier)(name);
+    this.checkFieldType(name, options);
     const database = this.context.database;
     const field = database.buildField(_objectSpread({
       name
@@ -240,14 +310,14 @@ class Collection extends _events().EventEmitter {
     this.emit('field.afterAdd', field); // refresh children models
 
     if (this.isParent()) {
-      var _iterator = _createForOfIteratorHelper(this.context.database.inheritanceMap.getChildren(this.name, {
+      var _iterator2 = _createForOfIteratorHelper(this.context.database.inheritanceMap.getChildren(this.name, {
         deep: false
       })),
-          _step;
+          _step2;
 
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          const child = _step.value;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          const child = _step2.value;
           const childCollection = this.db.getCollection(child);
           const existField = childCollection.getField(name);
 
@@ -258,9 +328,9 @@ class Collection extends _events().EventEmitter {
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
     }
 
@@ -276,12 +346,12 @@ class Collection extends _events().EventEmitter {
       this.resetFields();
     }
 
-    var _iterator2 = _createForOfIteratorHelper(fields),
-        _step2;
+    var _iterator3 = _createForOfIteratorHelper(fields),
+        _step3;
 
     try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        const _ref = _step2.value;
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        const _ref = _step3.value;
 
         const name = _ref.name,
               options = _objectWithoutProperties(_ref, _excluded);
@@ -289,27 +359,27 @@ class Collection extends _events().EventEmitter {
         this.addField(name, options);
       }
     } catch (err) {
-      _iterator2.e(err);
+      _iterator3.e(err);
     } finally {
-      _iterator2.f();
+      _iterator3.f();
     }
   }
 
   resetFields() {
     const fieldNames = this.fields.keys();
 
-    var _iterator3 = _createForOfIteratorHelper(fieldNames),
-        _step3;
+    var _iterator4 = _createForOfIteratorHelper(fieldNames),
+        _step4;
 
     try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        const fieldName = _step3.value;
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        const fieldName = _step4.value;
         this.removeField(fieldName);
       }
     } catch (err) {
-      _iterator3.e(err);
+      _iterator4.e(err);
     } finally {
-      _iterator3.f();
+      _iterator4.f();
     }
   }
 
@@ -326,7 +396,7 @@ class Collection extends _events().EventEmitter {
       })) {
         const queryInterface = _this.db.sequelize.getQueryInterface();
 
-        yield queryInterface.dropTable(_this.model.tableName, options);
+        yield queryInterface.dropTable(_this.addSchemaTableName(), options);
       }
 
       _this.remove();
@@ -337,7 +407,7 @@ class Collection extends _events().EventEmitter {
     var _this2 = this;
 
     return _asyncToGenerator(function* () {
-      return _this2.db.collectionExistsInDb(_this2.name, options);
+      return _this2.db.queryInterface.collectionTableExists(_this2, options);
     })();
   }
 
@@ -351,14 +421,14 @@ class Collection extends _events().EventEmitter {
 
     if (bool) {
       if (this.isParent()) {
-        var _iterator4 = _createForOfIteratorHelper(this.db.inheritanceMap.getChildren(this.name, {
+        var _iterator5 = _createForOfIteratorHelper(this.db.inheritanceMap.getChildren(this.name, {
           deep: false
         })),
-            _step4;
+            _step5;
 
         try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            const child = _step4.value;
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            const child = _step5.value;
             const childCollection = this.db.getCollection(child);
             const existField = childCollection.getField(name);
 
@@ -367,9 +437,9 @@ class Collection extends _events().EventEmitter {
             }
           }
         } catch (err) {
-          _iterator4.e(err);
+          _iterator5.e(err);
         } finally {
-          _iterator4.f();
+          _iterator5.f();
         }
       }
 
@@ -388,6 +458,7 @@ class Collection extends _events().EventEmitter {
 
     newOptions = (0, _deepmerge().default)(this.options, newOptions, mergeOptions);
     this.context.database.emit('beforeUpdateCollection', this, newOptions);
+    this.options = newOptions;
     this.setFields(options.fields, false);
     this.setRepository(options.repository);
     this.context.database.emit('afterUpdateCollection', this);
@@ -444,7 +515,8 @@ class Collection extends _events().EventEmitter {
   addIndex(index) {
     if (!index) {
       return;
-    }
+    } // collection defined indexes
+
 
     let indexes = this.model.options.indexes || [];
     let indexName = [];
@@ -475,12 +547,12 @@ class Collection extends _events().EventEmitter {
       return;
     }
 
-    var _iterator5 = _createForOfIteratorHelper(indexes),
-        _step5;
+    var _iterator6 = _createForOfIteratorHelper(indexes),
+        _step6;
 
     try {
-      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-        const item = _step5.value;
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        const item = _step6.value;
 
         if (_lodash().default.isEqual(item.fields, indexName)) {
           return;
@@ -493,9 +565,9 @@ class Collection extends _events().EventEmitter {
         }
       }
     } catch (err) {
-      _iterator5.e(err);
+      _iterator6.e(err);
     } finally {
-      _iterator5.f();
+      _iterator6.f();
     }
 
     if (!indexItem) {
@@ -503,7 +575,6 @@ class Collection extends _events().EventEmitter {
     }
 
     indexes.push(indexItem);
-    this.model.options.indexes = indexes;
     const tableName = this.model.getTableName(); // @ts-ignore
 
     this.model._indexes = this.model.options.indexes // @ts-ignore
@@ -535,26 +606,15 @@ class Collection extends _events().EventEmitter {
     // @ts-ignore
     const indexes = this.model._indexes; // @ts-ignore
 
-    this.model._indexes = indexes.filter(item => {
-      var _iterator6 = _createForOfIteratorHelper(item.fields),
-          _step6;
-
-      try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          const field = _step6.value;
-
-          if (!this.model.rawAttributes[field]) {
-            return false;
-          }
-        }
-      } catch (err) {
-        _iterator6.e(err);
-      } finally {
-        _iterator6.f();
+    this.model._indexes = _lodash().default.uniqBy(indexes.filter(item => {
+      return item.fields.every(field => Object.values(this.model.rawAttributes).find(fieldVal => fieldVal.field === field));
+    }).map(item => {
+      if (this.options.underscored) {
+        item.fields = item.fields.map(field => (0, _utils.snakeCase)(field));
       }
 
-      return true;
-    });
+      return item;
+    }), 'name');
   }
 
   sync(syncOptions) {
@@ -581,8 +641,8 @@ class Collection extends _events().EventEmitter {
         }
       });
 
-      for (var _i = 0, _models = models; _i < _models.length; _i++) {
-        const model = _models[_i];
+      for (var _i2 = 0, _models = models; _i2 < _models.length; _i2++) {
+        const model = _models[_i2];
         yield model.sync(syncOptions);
       }
     })();
@@ -596,6 +656,36 @@ class Collection extends _events().EventEmitter {
     return this.context.database.inheritanceMap.isParentNode(this.name);
   }
 
+  addSchemaTableName() {
+    const tableName = this.model.tableName;
+
+    if (this.collectionSchema()) {
+      return this.db.utils.addSchema(tableName, this.collectionSchema());
+    }
+
+    return tableName;
+  }
+
+  quotedTableName() {
+    return this.db.utils.quoteTable(this.addSchemaTableName());
+  }
+
+  collectionSchema() {
+    if (this.options.schema) {
+      return this.options.schema;
+    }
+
+    if (this.db.options.schema) {
+      return this.db.options.schema;
+    }
+
+    if (this.db.inDialect('postgres')) {
+      return 'public';
+    }
+
+    return undefined;
+  }
+
 }
 
 exports.Collection = Collection;

package/lib/database-utils/index.d.ts

@@ -0,0 +1,8 @@
+import Database from '../database';
+export default class DatabaseUtils {
+    db: Database;
+    constructor(db: Database);
+    addSchema(tableName: any, schema?: any): any;
+    quoteTable(tableName: any): any;
+    schema(): string;
+}

package/lib/database-utils/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class DatabaseUtils {
+  constructor(db) {
+    this.db = void 0;
+    this.db = db;
+  }
+
+  addSchema(tableName, schema) {
+    if (this.db.options.schema && !schema) {
+      schema = this.db.options.schema;
+    }
+
+    if (schema) {
+      // @ts-ignore
+      tableName = this.db.sequelize.getQueryInterface().queryGenerator.addSchema({
+        tableName,
+        _schema: schema
+      });
+    }
+
+    return tableName;
+  }
+
+  quoteTable(tableName) {
+    const queryGenerator = this.db.sequelize.getQueryInterface().queryGenerator; // @ts-ignore
+
+    tableName = queryGenerator.quoteTable(_lodash().default.isPlainObject(tableName) ? tableName : this.addSchema(tableName));
+    return tableName;
+  }
+
+  schema() {
+    if (!this.db.inDialect('postgres')) {
+      return undefined;
+    }
+
+    return this.db.options.schema || 'public';
+  }
+
+}
+
+exports.default = DatabaseUtils;

package/lib/database.d.ts

@@ -17,6 +17,10 @@ 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 DatabaseUtils from './database-utils';
+import { BaseValueParser } from './value-parsers';
+import QueryInterface from './query-interface/query-interface';
+import { Logger } from '@nocobase/logger';
 export interface MergeOptions extends merge.Options {
 }
 export interface PendingOptions {
@@ -30,6 +34,7 @@ export interface IDatabaseOptions extends Options {
     tablePrefix?: string;
     migrator?: any;
     usingBigIntForId?: boolean;
+    underscored?: boolean;
 }
 export declare type DatabaseOptions = IDatabaseOptions;
 interface RegisterOperatorsContext {
@@ -48,6 +53,20 @@ export declare type AddMigrationsOptions = {
     directory: string;
 };
 declare type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
+export declare const DialectVersionAccessors: {
+    sqlite: {
+        sql: string;
+        get: (v: string) => string;
+    };
+    mysql: {
+        sql: string;
+        get: (v: string) => string;
+    };
+    postgres: {
+        sql: string;
+        get: (v: string) => string;
+    };
+};
 declare class DatabaseVersion {
     db: Database;
     constructor(db: Database);
@@ -58,6 +77,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     migrator: Umzug;
     migrations: Migrations;
     fieldTypes: Map<any, any>;
+    fieldValueParsers: Map<any, any>;
     options: IDatabaseOptions;
     models: Map<string, ModelStatic<Model<any, any>>>;
     repositories: Map<string, typeof Repository>;
@@ -66,6 +86,8 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     pendingFields: Map<string, FieldTypes.RelationField[]>;
     modelCollection: Map<ModelStatic<any>, Collection<any, any>>;
     tableNameCollectionMap: Map<string, Collection<any, any>>;
+    queryInterface: QueryInterface;
+    utils: DatabaseUtils;
     referenceMap: ReferencesMap;
     inheritanceMap: InheritanceMap;
     importedFrom: Map<string, string[]>;
@@ -75,17 +97,21 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         collectionOptions: CollectionOptions;
         mergeOptions?: any;
     }[]>;
+    logger: Logger;
     constructor(options: DatabaseOptions);
+    setLogger(logger: Logger): void;
     initListener(): void;
     addMigration(item: MigrationItem): void;
     addMigrations(options: AddMigrationsOptions): void;
     inDialect(...dialect: string[]): boolean;
+    escapeId(identifier: string): string;
     /**
      * Add collection to database
      * @param options
      */
     collection<Attributes = any, CreateAttributes = Attributes>(options: CollectionOptions): Collection<Attributes, CreateAttributes>;
     getTablePrefix(): string;
+    getFieldByPath(path: string): any;
     /**
      * get exists collection by its name
      * @param name
@@ -100,6 +126,8 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     addPendingField(field: RelationField): void;
     removePendingField(field: RelationField): void;
     registerFieldTypes(fieldTypes: MapOf<typeof Field>): void;
+    registerFieldValueParsers(parsers: MapOf<any>): void;
+    buildFieldValueParser<T extends BaseValueParser>(field: Field, ctx: any): T;
     registerModels(models: MapOf<ModelStatic<any>>): void;
     registerRepositories(repositories: MapOf<RepositoryType>): void;
     initOperators(): void;
@@ -107,11 +135,12 @@ 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>;
+    collectionExistsInDb(name: string, options?: Transactionable): Promise<boolean>;
     isSqliteMemory(): boolean;
-    auth(options?: QueryOptions & {
-        retry?: number;
+    auth(options?: Omit<QueryOptions, 'retry'> & {
+        retry?: number | Pick<QueryOptions, 'retry'>;
     }): Promise<any>;
+    prepare(): Promise<void>;
     reconnect(): Promise<void>;
     closed(): any;
     close(): Promise<void>;