leoric 1.13.5 → 1.14.3

package/History.md

@@ -1,3 +1,67 @@
+1.14.3 / 2021-11-12
+===================
+
+## What's Changed
+* fix: logger.logQuery should be guarded in case of error by @SmartOrange in https://github.com/cyjake/leoric/pull/222
+* fix: findOne without result should return null by @JimmyDaddy in https://github.com/cyjake/leoric/pull/225
+* fix: Literal should support bigint type by @fengmk2 in https://github.com/cyjake/leoric/pull/226
+* fix: select((name: string) => boolean) by @cyjake in https://github.com/cyjake/leoric/pull/227
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.14.2...v1.14.3
+
+1.14.2 / 2021-11-01
+===================
+
+## What's Changed
+* fix: accept timestamps in snake case by @cyjake in https://github.com/cyjake/leoric/pull/221
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.14.1...v1.14.2
+
+1.14.1 / 2021-11-01
+===================
+
+## What's Changed
+* docs: export { Collection } by @cyjake in https://github.com/cyjake/leoric/pull/220
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.14.0...v1.14.1
+
+1.14.0 / 2021-11-01
+===================
+
+Two options regarding `Model.init()` were added in this release:
+
+```js
+class User extends Bone {}
+User.init({ name: STRING }, {
+  timestamps: true,  // which is the default
+  paranoid: true,    // which default to `false`
+});
+assert.deepEqual(Object.keys(User.attributes), [
+  'id',
+  'name',
+  'createdAt',
+  'updatedAt',
+  'deletedAt',
+]);
+```
+
+## What's Changed
+* docs: update 'primayKey' typos by @freshgum-bubbles in https://github.com/cyjake/leoric/pull/211
+* docs: DataTypes definitions in d.ts by @cyjake in https://github.com/cyjake/leoric/pull/210
+* fix: fix#209 sequelize mode should update all changed fields in instance update method by @JimmyDaddy in https://github.com/cyjake/leoric/pull/212
+* fix: fix #213 findAndCountAll should ignore attributes by @JimmyDaddy in https://github.com/cyjake/leoric/pull/214
+* fix: opts.connectTimeout by @cyjake in https://github.com/cyjake/leoric/pull/216
+* fix: reload instance with sharding key should not throw by @cyjake in https://github.com/cyjake/leoric/pull/217
+* feat: timestamps should be defined by default by @cyjake in https://github.com/cyjake/leoric/pull/218
+* fix: instance.reload() should not rely on `static findOne()` by @cyjake in https://github.com/cyjake/leoric/pull/219
+
+## New Contributors
+* @freshgum-bubbles made their first contribution in https://github.com/cyjake/leoric/pull/211
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.13.5...v1.14.0
+
 1.13.5 / 2021-10-26
 ===================
 

package/Readme.md

@@ -48,7 +48,7 @@ If table structures were intended to be maintained in the models, Leoric can be
 const { BIGINT, STRING } = Bone.DataTypes;
 class Post extends Bone {
   static attributes = {
-    id: { type: BIGINT, primayKey: true },
+    id: { type: BIGINT, primaryKey: true },
     email: { type: STRING, allowNull: false },
     nickname: { type: STRING, allowNull: false },
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "1.13.5",
+  "version": "1.14.3",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",

package/src/adapters/sequelize.js

@@ -331,6 +331,7 @@ module.exports = Bone => {
       let spell = this._find({}, filterOptions(options));
       translateOptions(spell, options);
       let spellCount = this._find({}, filterOptions(options));
+      delete options.attributes;
       translateOptions(spellCount, options);
       delete spellCount.rowCount;
       delete spellCount.skip;
@@ -378,7 +379,7 @@ module.exports = Bone => {
         // findAll maybe override by developer, that will make it return a non-Spell object
         spell = this._find({}, filterOptions(options));
         translateOptions(spell, { ...options, limit: 1 });
-        spell = spell.later(result => result[0]);
+        spell = spell.later(result => result[0] != null? result[0]: null);
       }
       if (options && options.paranoid === false) return spell.unparanoid;
       return spell;
@@ -496,29 +497,46 @@ module.exports = Bone => {
     async update(values = {}, options = {}) {
       const { fields } = options;
       const changeValues = {};
+      const originalValues = Object.assign({}, this.getRaw());
+      for (const name in values) {
+        if (values[name] !== undefined && this.hasAttribute(name)) {
+          // exec custom setters in case it exist
+          this[name] = values[name];
+          changeValues[name] = this.attribute(name);
+        }
+      }
+
       const changedKeys = this.changed();
       if (changedKeys) {
         for (const name of changedKeys) {
           // custom getter should be executed in case there is a custom setter
-          changeValues[name] = this[name];
+          if (!(name in changeValues)) changeValues[name] = this[name];
         }
       }
 
       let changes = {};
       if (fields && fields.length) {
         fields.map(key => {
-          if (values[key] !== undefined) changes[key] = values[key];
-          else changes[key] = changeValues[key] || this.attribute(key);
+          if (changeValues[key] !== undefined) changes[key] = changeValues[key];
+          else if (values[key] !== undefined) changes[key] = values[key];
+          else changes[key] = this.attribute(key);
         });
       } else {
         changes = {
-          ...changeValues,
           ...values,
+          ...changeValues,
         };
       }
-      const spell = super._update(changes, options);
       // instance update don't need to be paranoid
-      return spell.unparanoid;
+      options.paranoid = false;
+      try {
+        const res = await super._update(changes, options);
+        return res;
+      } catch (err) {
+        // revert value in case update failed
+        this._setRaw(originalValues);
+        throw err;
+      }
     }
 
     // EXISTS

package/src/bone.js

@@ -15,12 +15,6 @@ const { capitalize, camelCase, snakeCase } = require('./utils/string');
 const { hookNames, setupSingleHook } = require('./setup_hooks');
 const { logger } = require('./utils/index');
 
-const LEGACY_TIMESTAMP_MAP = {
-  gmtCreate: 'createdAt',
-  gmtModified: 'updatedAt',
-  gmtDeleted: 'deletedAt',
-};
-
 function looseReadonly(props) {
   return Object.keys(props).reduce((result, name) => {
     result[name] = {
@@ -243,8 +237,13 @@ class Bone {
   }
 
   // protected
-  _setRaw(key, value) {
-    this.#raw[key] = value;
+  _setRaw(...args) {
+    const [ name, value ] = args;
+    if (args.length > 1) {
+      this.#raw[name] = value;
+    } else if (args.length === 1 && name !== undefined && typeof name === 'object') {
+      this.#raw = name;
+    }
   }
 
   // protected
@@ -626,13 +625,31 @@ class Bone {
   /**
    * Persist changes on current instance back to database with `UPDATE`.
    * @public
-   * @param {Object} changes
+   * @param {Object} values
    * @param {Object?} options
    * @returns {number} affected rows
    * @memberof Bone
    */
-  update(changes, options = {}) {
-    return this._update(changes, options);
+  async update(values, options = {}) {
+    const changes = {};
+    const originalValues = Object.assign({}, this.#raw);
+    if (typeof values === 'object') {
+      for (const name in values) {
+        if (values[name] !== undefined && this.hasAttribute(name)) {
+          // exec custom setters in case it exist
+          this[name] = values[name];
+          changes[name] = this.attribute(name);
+        }
+      }
+    }
+    try {
+      const res = await this._update(Object.keys(changes).length? changes : values, options);
+      return res;
+    } catch (error) {
+      // revert value in case update failed
+      this._setRaw(originalValues);
+      throw error;
+    }
   }
 
   /**
@@ -640,23 +657,19 @@ class Bone {
    * @private
    * @return {number}
    */
-  _update(values, options = {}) {
-    const changes = {};
+  async _update(values, options = {}) {
     const Model = this.constructor;
     const { attributes, primaryKey, shardingKey } = Model;
-
+    let changes = {};
     if (values == null) {
       for (const name in attributes) {
         if (this.changed(name)) changes[name] = this.attribute(name);
       }
-    } else if (typeof values === 'object') {
-      for (const name in values) {
-        const originValue = this.attribute(name);
-        // exec custom setters in case it exist
-        this[name] = values[name];
-        changes[name] = this.attribute(name);
-        // revert value in case update failed
-        this.attribute(name, originValue);
+    } else {
+      for (const key in values) {
+        if (values[key] !== undefined && this.hasAttribute(key)) {
+          changes[key] = values[key];
+        }
       }
     }
 
@@ -676,7 +689,7 @@ class Bone {
       this._validateAttributes(changes);
     }
     const spell = new Spell(Model, options).$where(where).$update(changes);
-    return spell.later(result => {
+    return await spell.later(result => {
       // sync changes (changes has been formatted by custom setters, use this.attribute(name, value) directly)
       for (const key in changes) {
         this.attribute(key, changes[key]);
@@ -737,11 +750,13 @@ class Bone {
   }
 
   async reload() {
-    const { primaryKey } = this.constructor;
-    const instance = await this.constructor.findOne(this[primaryKey]).unscoped;
-    if (instance) {
-      this._clone(instance);
-    }
+    const { primaryKey, shardingKey } = this.constructor;
+    const conditions = { [primaryKey]: this[primaryKey] };
+    if (shardingKey) conditions[shardingKey] = this[shardingKey];
+    const spell = this.constructor._find(conditions).$get(0);
+    spell.scopes = [];
+    const instance = await spell;
+    if (instance) this._clone(instance);
     return instance;
   }
 
@@ -894,27 +909,6 @@ class Bone {
     Object.assign(attribute, { jsType });
   }
 
-  static normalize(attributes) {
-    for (const name in LEGACY_TIMESTAMP_MAP) {
-      const newName = LEGACY_TIMESTAMP_MAP[name];
-      if (attributes.hasOwnProperty(name) && !attributes.hasOwnProperty(newName)) {
-        attributes[newName] = attributes[name];
-        delete attributes[name];
-      }
-    }
-
-    // if there is no primaryKey added, add it to attributes automatically
-    if (Object.values(attributes).every(attribute => !attribute.primaryKey)) {
-      attributes[this.primaryKey] = {
-        type: new DataTypes.BIGINT(),
-        allowNull: false,
-        autoIncrement: true,
-        primaryKey: true,
-        columnName: snakeCase(this.primaryKey),
-      };
-    }
-  }
-
   /**
    * Generate attributes from column definitions.
    * @private
@@ -927,7 +921,18 @@ class Bone {
     const table = this.table || snakeCase(pluralize(this.name));
     const tableAlias = camelCase(pluralize(this.name || table));
 
-    this.normalize(attributes);
+    // if there is no primaryKey added, add it to attributes automatically
+    if (Object.values(attributes).every(attribute => !attribute.primaryKey)) {
+      attributes[this.primaryKey] = {
+        type: new DataTypes.BIGINT(),
+        allowNull: false,
+        autoIncrement: true,
+        columnName: snakeCase(this.primaryKey),
+        ...attributes[this.primaryKey],
+        primaryKey: true,
+      };
+    }
+
     for (const name of Object.keys(attributes)) {
       const attribute = new Attribute(name, attributes[name], options.define);
       attributeMap[attribute.columnName] = attribute;
@@ -936,13 +941,15 @@ class Bone {
 
     const primaryKey = Object.keys(attributes).find(key => attributes[key].primaryKey);
     const timestamps = {};
-    for (const name of [ 'createdAt', 'updatedAt', 'deletedAt' ]) {
-      if (attributes.hasOwnProperty(name)) timestamps[name] = name;
-      if (attributes.hasOwnProperty(snakeCase(name))) {
-        timestamps[name] = snakeCase(name);
+    for (const key of [ 'createdAt', 'updatedAt', 'deletedAt' ]) {
+      const name = attributes.hasOwnProperty(key) ? key : snakeCase(key);
+      const attribute = attributes[name];
+
+      if (!attribute) continue;
+      if (columns.some(column => column.columnName === attribute.columnName)) {
+        timestamps[key] = name;
       }
     }
-
     for (const name in attributes) this.loadAttribute(name);
 
     Object.defineProperties(this, looseReadonly({
@@ -1498,14 +1505,25 @@ class Bone {
   }
 
   static init(attributes = {}, opts = {}, overrides = {}) {
-    const { hooks, tableName: table } = {
+    const { hooks, paranoid, tableName: table, timestamps } = {
       underscored: true,
+      timestamps: true,
       tableName: this.table,
       hooks: {},
       ...(this.options && this.options.define),
       ...opts,
     };
 
+    if (timestamps) {
+      const names = [ 'createdAt', 'updatedAt' ];
+      if (paranoid) names.push('deletedAt');
+      for (const name of names) {
+        if (!attributes[name] && !attributes[snakeCase(name)]) {
+          attributes[name] = DataTypes.DATE;
+        }
+      }
+    }
+
     const customDescriptors = Object.getOwnPropertyDescriptors(overrides);
     Object.defineProperties(this.prototype, customDescriptors);
 
@@ -1514,6 +1532,7 @@ class Bone {
       if (typeof method === 'function') result[key] = method;
       return result;
     }, {});
+
     Object.defineProperties(this, looseReadonly({ ...hookMethods, attributes, table }));
   }
 

package/src/drivers/abstract/attribute.js

@@ -105,17 +105,17 @@ class Attribute {
     });
   }
 
-  equals(targetAttribute) {
-    if (!targetAttribute) return false;
-    const props = [ 'dataType', 'allowNull', 'primaryKey' ];
+  equals(columnInfo) {
+    if (!columnInfo) return false;
+    const props = [ 'allowNull', 'dataType', 'primaryKey' ];
     for (const prop of props) {
       // SQLite has default value as string even if data type is integer
-      if (this[prop] != targetAttribute[prop]) {
+      if (this[prop] != columnInfo[prop]) {
         debug('[attribute] [%s] %s not equal (defined: %s, actual: %s)',
           this.columnName,
           prop,
           this[prop],
-          targetAttribute[prop]);
+          columnInfo[prop]);
         return false;
       }
     }

package/src/drivers/abstract/logger.js

@@ -24,6 +24,14 @@ class Logger {
     return SqlString.format(query.sql || query, values);
   }
 
+  tryLogQuery() {
+    try {
+      this.logQuery(...arguments);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
   logQuery(sql, duration, opts) {
     debug('[query] [%s] %s', duration, sql);
   }

package/src/drivers/mysql/index.js

@@ -18,6 +18,8 @@ class MysqlDriver extends AbstractDriver {
    * @param {string} opts.appName         - In some RDMS, appName is used as the actual name of the database
    * @param {string} opts.database
    * @param {string} opts.connectionLimit
+   * @param {number} opts.connectTimeout  - The milliseconds before a timeout occurs during the initial connection to the MySQL server. (Default: `10000`)
+   * @param {string} opts.charset
    * @param {boolean} opts.stringifyObjects  - stringify object value in dataValues
    */
   constructor(opts = {}) {
@@ -37,7 +39,7 @@ class MysqlDriver extends AbstractDriver {
     const client = opts.client || 'mysql';
     const {
       host, port, user, password,
-      connectionLimit, charset, stringifyObjects = false,
+      connectTimeout, connectionLimit, charset, stringifyObjects = true,
     } = opts;
 
     if (client !== 'mysql' && client !== 'mysql2') {
@@ -46,6 +48,7 @@ class MysqlDriver extends AbstractDriver {
 
     return require(client).createPool({
       connectionLimit,
+      connectTimeout,
       host,
       port,
       user,
@@ -93,7 +96,7 @@ class MysqlDriver extends AbstractDriver {
       if (!opts.connection) connection.release();
     }
 
-    logger.logQuery(sql, Date.now() - start, opts);
+    logger.tryLogQuery(sql, Date.now() - start, opts);
     const [ results, fields ] = result;
     if (fields) return { rows: results, fields };
     return results;

package/src/drivers/postgres/attribute.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const debug = require('debug')('leoric');
+
 const Attribute = require('../abstract/attribute');
 const DataTypes = require('./data_types');
 const { escape, escapeId } = require('./sqlstring');
@@ -32,6 +34,30 @@ class PostgresAttribute extends Attribute {
     }
     return chunks.join(' ');
   }
+
+
+  equals(columnInfo) {
+    if (!columnInfo) return false;
+    if (this.type.toSqlString() !== columnInfo.columnType.toUpperCase()) {
+      debug('[attribute] [%s] columnType not equal (defined: %s, actual: %s)',
+        this.columnName,
+        this.type.toSqlString(),
+        columnInfo.columnType.toUpperCase());
+      return false;
+    }
+    const props = [ 'allowNull', 'defaultValue', 'primaryKey' ];
+    for (const prop of props) {
+      if (this[prop] != columnInfo[prop]) {
+        debug('[attribute] [%s] %s not equal (defined: %s, actual: %s)',
+          this.columnName,
+          prop,
+          this[prop],
+          columnInfo[prop]);
+        return false;
+      }
+    }
+    return true;
+  }
 }
 
 module.exports = PostgresAttribute;

package/src/drivers/postgres/index.js

@@ -141,7 +141,7 @@ class PostgresDriver extends AbstractDriver {
         if (!spell.connection) connection.release();
       }
 
-      logger.logQuery(formatted, Date.now() - start, spell);
+      logger.tryLogQuery(formatted, Date.now() - start, spell);
       return result;
     }
 

package/src/drivers/postgres/schema.js

@@ -53,7 +53,7 @@ module.exports = {
     for (const row of rows) {
       const tableName = row.table_name;
       const columns = schemaInfo[tableName] || (schemaInfo[tableName] = []);
-      let { data_type: dataType, character_octet_length: length } = row;
+      let { data_type: dataType, character_maximum_length: length } = row;
 
       if (dataType === 'character varying') dataType = 'varchar';
       if (dataType === 'timestamp without time zone') dataType = 'timestamp';

package/src/drivers/sqlite/index.js

@@ -52,7 +52,7 @@ class SqliteDriver extends AbstractDriver {
       if (!opts.connection) connection.release();
     }
 
-    logger.logQuery(sql, Date.now() - start, opts);
+    logger.tryLogQuery(sql, Date.now() - start, opts);
     return result;
   }
 

package/src/expr_formatter.js

@@ -11,7 +11,7 @@ const { precedes, walkExpr } = require('./expr');
  * @param {Spell} spell
  * @param {string[]} qualifiers
  */
- function findModel(spell, qualifiers) {
+function findModel(spell, qualifiers) {
   const qualifier = qualifiers && qualifiers[0];
   const Model = qualifier && qualifier != spell.Model.tableAlias
     ? (spell.joins.hasOwnProperty(qualifier) ? spell.joins[qualifier].Model : null)

package/src/realm.js

@@ -38,6 +38,17 @@ async function findModels(dir) {
   return models;
 }
 
+const LEGACY_TIMESTAMP_MAP = {
+  gmtCreate: 'createdAt',
+  gmtModified: 'updatedAt',
+  gmtDeleted: 'deletedAt',
+};
+
+/**
+ * construct model attributes entirely from column definitions
+ * @param {Bone} model
+ * @param {Array<string, Object>} columns column definitions
+ */
 function initAttributes(model, columns) {
   const attributes = {};
 
@@ -52,7 +63,15 @@ function initAttributes(model, columns) {
     };
   }
 
-  model.init(attributes);
+  for (const name in LEGACY_TIMESTAMP_MAP) {
+    const newName = LEGACY_TIMESTAMP_MAP[name];
+    if (attributes.hasOwnProperty(name) && !attributes.hasOwnProperty(newName)) {
+      attributes[newName] = attributes[name];
+      delete attributes[name];
+    }
+  }
+
+  model.init(attributes, { timestamps: false });
 }
 
 async function loadModels(Spine, models, opts) {

package/types/data_types.d.ts

@@ -0,0 +1,88 @@
+type LENGTH_VARIANTS = 'tiny' | '' | 'medium' | 'long';
+
+interface INVOKABLE<T> {
+  (length: LENGTH_VARIANTS): T;
+  (length: number): T;
+}
+
+export default class DataType {
+  toSqlString(): string;
+
+  static STRING: typeof STRING & INVOKABLE<STRING>;
+  static INTEGER: typeof INTEGER & INVOKABLE<INTEGER>;
+  static BIGINT: typeof BIGINT & INVOKABLE<BIGINT>;
+  static TEXT: typeof TEXT & INVOKABLE<TEXT>;
+  static BLOB: typeof BLOB & INVOKABLE<BLOB>;
+  static JSON: typeof JSON & INVOKABLE<JSON>;
+  static JSONB: typeof JSONB & INVOKABLE<JSONB>;
+  static BINARY: typeof BINARY & INVOKABLE<BINARY>;
+  static VARBINARY: typeof VARBINARY & INVOKABLE<VARBINARY>;
+  static DATE: typeof DATE & INVOKABLE<DATE>;
+  static DATEONLY: typeof DATEONLY & INVOKABLE<DATEONLY>;
+  static BOOLEAN: typeof BOOLEAN & INVOKABLE<BOOLEAN>;
+}
+
+declare class STRING extends DataType {
+  dataType: 'varchar';
+  length: number;
+  constructor(length: number);
+}
+
+declare class INTEGER extends DataType {
+  dataType: 'integer' | 'bigint';
+  length: number;
+  constructor(length: number);
+  get UNSIGNED(): this;
+  get ZEROFILL(): this;
+}
+
+declare class BIGINT extends INTEGER {
+  dataType: 'bigint';
+}
+
+declare class TEXT extends DataType {
+  dataType: 'text';
+  length: LENGTH_VARIANTS;
+  constructor(length: LENGTH_VARIANTS);
+}
+
+declare class BLOB extends DataType {
+  dataType: 'blob';
+  length: LENGTH_VARIANTS;
+  constructor(length: LENGTH_VARIANTS)
+}
+
+declare class JSON extends DataType {
+  dataType: 'text' | 'json';
+}
+
+declare class JSONB extends JSON {
+  dataType: 'json';
+}
+
+declare class BINARY extends DataType {
+  dataType: 'binary';
+  length: number;
+  constructor(length: number);
+}
+
+declare class VARBINARY extends DataType {
+  dataType: 'varbinary';
+  length: number;
+  constructor(length: number);
+}
+
+declare class DATE extends DataType {
+  dataType: 'date';
+  precision: number;
+  timezone: boolean;
+  constructor(precision: number, timezone?: boolean)
+}
+
+declare class DATEONLY extends DataType {
+  dataType: 'dateonly';
+}
+
+declare class BOOLEAN extends DataType {
+  dataType: 'boolean'
+}

package/types/index.d.ts

@@ -1,3 +1,11 @@
+import DataType from './data_types';
+
+export { DataType as DataTypes };
+
+type DataTypes<T> = {
+  [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property]
+}
+
 interface ExprIdentifier {
   type: 'id';
   value: string;
@@ -52,10 +60,10 @@ type WithOptions = {
   [qualifier: string]: { select: string | string[], throughRelation?: string }
 }
 
-declare class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<InstanceType<T>> | ResultSet | number | null> extends Promise<U> {
+export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<InstanceType<T>> | ResultSet | number | null> extends Promise<U> {
   constructor(Model: T, opts: SpellOptions);
 
-  select(...names: Array<string | RawSql>): Spell<T, U>;
+  select(...names: Array<string | RawSql> | Array<(name: string) => boolean>): Spell<T, U>;
   insert(opts: SetOptions): Spell<T, number>;
   update(opts: SetOptions): Spell<T, number>;
   upsert(opts: SetOptions): Spell<T, number>;
@@ -103,7 +111,7 @@ declare class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Inst
   toString(): string;
 }
 
-type Literal = null | undefined | boolean | number | string | Date | object | ArrayBuffer;
+type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
 
 type OperatorCondition = {
   [key in '$eq' | '$ne']?: Literal;
@@ -129,21 +137,15 @@ type InstanceValues<T> = {
   [Property in keyof Extract<T, Literal>]?: Extract<T, Literal>[Property]
 }
 
-declare class DataType {}
-
-export const DataTypes: {
-  [key in 'STRING' | 'INTEGER' | 'BIGINT' | 'DATE' | 'BOOLEAN' | 'TEXT' | 'BLOB' | 'JSON' | 'JSONB' | 'BINARY' | 'VARBINARY' ]: DataType;
-};
-
 interface AttributeMeta {
-  column: string;
-  columnType: string;
-  allowNull: boolean;
-  defaultValue: Literal;
-  primaryKey: boolean;
-  dataType: string;
-  jsType: Literal;
-  type: DataType;
+  column?: string;
+  columnType?: string;
+  allowNull?: boolean;
+  defaultValue?: Literal;
+  primaryKey?: boolean;
+  dataType?: string;
+  jsType?: Literal;
+  type: DataTypes<DataType>;
 }
 
 interface RelateOptions {
@@ -205,15 +207,17 @@ type ResultSet = {
   [key: string]: Literal
 };
 
-declare class Collection<T extends Bone> extends Array<T> {
+export class Collection<T extends Bone> extends Array<T> {
   save(): Promise<void>;
   toJSON(): Object[];
   toObject(): Object[];
 }
 
 export class Bone {
+  static DataTypes: DataType;
+
   /**
-   * The connection pool of the specified client, with few `Leoric_` prefixed methods extended to eliminate client differences.
+   * get the connection pool of the driver
    */
   static pool: Pool;
 
@@ -250,7 +254,7 @@ export class Bone {
   /**
    * The attribute definitions of the model.
    */
-  static attributes: { [key: string]: DataType | AttributeMeta };
+  static attributes: { [key: string]: DataTypes<DataType> | AttributeMeta };
 
   /**
    * The schema info of current model.
@@ -617,7 +621,7 @@ interface RawQueryOptions {
 }
 
 export default class Realm {
-  Bone: Bone;
+  Bone: typeof Bone;
   driver: Driver;
   models: Record<string, Bone>;