leoric 1.15.0 → 2.0.2

package/History.md

@@ -1,3 +1,56 @@
+2.0.2 / 2021-02-10
+==================
+
+## What's Changed
+* fix: order by alias should not throw by @cyjake in https://github.com/cyjake/leoric/pull/255
+* fix: fix #257 DataType.uncast should skip Raw type at type checking by @JimmyDaddy in https://github.com/cyjake/leoric/pull/258
+* docs: async function in transaction by @cyjake in https://github.com/cyjake/leoric/pull/259
+* fix: fixed #256 static create instance should check all default attri… by @JimmyDaddy in https://github.com/cyjake/leoric/pull/262
+* fix: fix #260 UPDATE with LIMIT and ORDER should be formatted(mysql only) by @JimmyDaddy in https://github.com/cyjake/leoric/pull/261
+* refactor: keep the UPDATE ... ORDER BY ... LIMIT to mysql driver by @cyjake in https://github.com/cyjake/leoric/pull/264
+* fix: fix #263 upsert attributes should use defaultValue while there i… by @JimmyDaddy in https://github.com/cyjake/leoric/pull/265
+* fix: fix restore Error `Undefined attribute "deletedAt"` by @JimmyDaddy in https://github.com/cyjake/leoric/pull/267
+* fix: type checking adaption by @JimmyDaddy in https://github.com/cyjake/leoric/pull/266
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.0.1...v2.0.2
+
+2.0.1 / 2022-01-05
+==================
+
+## What's Changed
+* fix: format numeric result by @JimmyDaddy in https://github.com/cyjake/leoric/pull/253
+* fix: should still return number if value is '0.000' by @cyjake in https://github.com/cyjake/leoric/pull/254
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.15.1...v2.0.1
+
+2.0.0 / 2021-12-28
+==================
+
+## What's Changed
+* breaking: model.sync add force/alter option by @SmartOrange in https://github.com/cyjake/leoric/pull/224
+* breaking: logQueryError(err, sql, duration, options) by @cyjake in https://github.com/cyjake/leoric/pull/237
+* test: add utf8mb4 test cases by @fengmk2 in https://github.com/cyjake/leoric/pull/239
+* Merge 1.x changes by @cyjake in https://github.com/cyjake/leoric/pull/249
+
+## New Contributors
+* @SmartOrange made their first contribution in https://github.com/cyjake/leoric/pull/222
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.15.1...v2.0.0
+
+1.15.1 / 2021-12-28
+===================
+
+## What's Changed
+* fix: fix #242 date string format by @JimmyDaddy in https://github.com/cyjake/leoric/pull/243
+* fix: update with empty conditions by @JimmyDaddy in https://github.com/cyjake/leoric/pull/241
+* fix: silent option's priority should be lower than valueSet by @JimmyDaddy in https://github.com/cyjake/leoric/pull/244
+* fix: information_schema.columns.datetime_precision by @cyjake in https://github.com/cyjake/leoric/pull/246
+* fix: should not hoist subquery if query is ordered by external columns by @cyjake in https://github.com/cyjake/leoric/pull/247
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.15.0...v1.15.1
+
 1.15.0 / 2021-11-22
 ===================
 

package/package.json

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

package/src/adapters/sequelize.js

@@ -238,9 +238,6 @@ module.exports = Bone => {
     }
 
     static build(values, options = {}) {
-      if (options.validate !== false) {
-        this._validateAttributes(values);
-      }
       const { raw } = Object.assign({ raw: false, isNewRecord: true }, options);
       const { attributes } = this;
 
@@ -256,6 +253,7 @@ module.exports = Bone => {
       } else {
         instance = new this(values, options);
       }
+
       return instance;
     }
 
@@ -469,6 +467,7 @@ module.exports = Bone => {
       const { where, paranoid, individualHooks } = options;
       if (individualHooks) {
         let findSpell = this._find(where, options);
+        translateOptions(findSpell, options);
         if (paranoid === false) findSpell = findSpell.unparanoid;
         const instances = await findSpell;
         if (instances.length) {
@@ -484,6 +483,7 @@ module.exports = Bone => {
       const { where, paranoid = false, validate } = options;
       const whereConditions = where || {};
       const spell = super.update(whereConditions, values, { validate, hooks: false, ...options });
+      translateOptions(spell, options);
       if (!paranoid) return spell.unparanoid;
       return spell;
     }

package/src/bone.js

@@ -11,9 +11,11 @@ const { executeValidator, LeoricValidateError } = require('./validator');
 const DataTypes = require('./data_types');
 const Collection = require('./collection');
 const Spell = require('./spell');
+const Raw = require('./raw');
 const { capitalize, camelCase, snakeCase } = require('./utils/string');
 const { hookNames, setupSingleHook } = require('./setup_hooks');
 const { logger } = require('./utils/index');
+const { TIMESTAMP_NAMES, LEGACY_TIMESTAMP_COLUMN_MAP } = require('./constants');
 
 function looseReadonly(props) {
   return Object.keys(props).reduce((result, name) => {
@@ -27,12 +29,8 @@ function looseReadonly(props) {
   }, {});
 }
 
-function compare(attributes, columns) {
+function compare(attributes, columnMap) {
   const diff = {};
-  const columnMap = columns.reduce((result, entry) => {
-    result[entry.columnName] = entry;
-    return result;
-  }, {});
 
   for (const name in attributes) {
     const attribute = attributes[name];
@@ -71,7 +69,7 @@ function copyValues(values) {
     for (const key in values) {
       if (Object.hasOwnProperty.call(values, key)) {
         const v = values[key];
-        if (v && (v.__raw || v.__expr || (v instanceof Spell))) continue;
+        if (v && ((v instanceof Raw) || v.__expr || (v instanceof Spell))) continue;
         copyValue[key] = v;
       }
     }
@@ -79,6 +77,23 @@ function copyValues(values) {
   return copyValue;
 }
 
+function valuesValidate(values, attributes, ctx) {
+  for (const valueKey in values) {
+    const attribute = attributes[valueKey];
+    if (!attribute) continue;
+    const { validate = {}, name, allowNull, defaultValue } = attribute;
+    const value = values[valueKey];
+    if (value == null && defaultValue == null) {
+      if (allowNull === false) throw new LeoricValidateError('notNull', name);
+      if ((allowNull === true || allowNull === undefined) && validate.notNull === undefined ) continue;
+    }
+    if (!validate) continue;
+    for (const key in validate) {
+      if (validate.hasOwnProperty(key)) executeValidator(ctx, key, attribute, value);
+    }
+  }
+}
+
 /**
  * The base class that provides Object-relational mapping. This class is never intended to be used directly. We need to create models that extends from Bone. Most of the query features of Bone is implemented by {@link Spell} such as {@link Spell#$group} and {@link Spell#$join}. With Bone, you can create models like this:
  *
@@ -162,14 +177,15 @@ class Bone {
   attribute(...args) {
     const [ name, value ] = args;
     const { attributes } = this.constructor;
+    const attribute = attributes[name];
 
-    if (!attributes.hasOwnProperty(name)) {
+    if (!attribute) {
       throw new Error(`${this.constructor.name} has no attribute "${name}"`);
     }
 
     if (args.length > 1) {
       // execute validators
-      this.#raw[name] = value;
+      this.#raw[name] = value instanceof Raw ? value : attribute.cast(value);
       this.#rawUnset.delete(name);
       return this;
     }
@@ -282,21 +298,7 @@ class Bone {
 
     // merge all changed values
     changedValues = Object.assign(changedValues, values);
-
-    for (const valueKey in changedValues) {
-      const attribute = attributes[valueKey];
-      if (!attribute) continue;
-      const { validate = {}, name, allowNull, defaultValue } = attribute;
-      const value = changedValues[valueKey];
-      if (value == null && defaultValue == null) {
-        if (allowNull === false) throw new LeoricValidateError('notNull', name);
-        if ((allowNull === true || allowNull === undefined) && validate.notNull === undefined ) return;
-      }
-      if (!validate) return;
-      for (const key in validate) {
-        if (validate.hasOwnProperty(key)) executeValidator(this, key, attribute, value);
-      }
-    }
+    valuesValidate(changedValues, attributes, this);
   }
 
   /**
@@ -308,22 +310,7 @@ class Bone {
    */
   static _validateAttributes(values = {}) {
     const { attributes } = this;
-    for (const valueKey in values) {
-      const attribute = attributes[valueKey];
-      // If valueKey is not an attribute of the Model, go to the next loop instead of throw 'No Such Attribute' Error,
-      // in case it is a custom property of the Model which defined by custom setters/getters.
-      if (!attribute) return;
-      const { validate = {}, name, allowNull, defaultValue } = attribute;
-      const value = values[valueKey];
-      if (value == null && defaultValue == null) {
-        if (allowNull === false) throw new LeoricValidateError('notNull', name);
-        if ((allowNull === true || allowNull === undefined) && validate.notNull === undefined) return;
-      }
-      if (!validate) return;
-      for (const key in validate) {
-        if (validate.hasOwnProperty(key)) executeValidator(this, key, attribute, value);
-      }
-    }
+    valuesValidate(values, attributes, this);
   }
 
   /**
@@ -682,7 +669,7 @@ class Bone {
     if (shardingKey) where[shardingKey] = this[shardingKey];
 
     const { updatedAt, deletedAt } = Model.timestamps;
-    if (attributes[updatedAt] && !changes[updatedAt] && !changes[deletedAt]) {
+    if (attributes[updatedAt] && !changes[updatedAt] && !changes[deletedAt] && !options.silent) {
       changes[updatedAt] = new Date();
     }
     if (options.validate !== false ) {
@@ -727,6 +714,7 @@ class Bone {
       this[updatedAt] = this[createdAt];
     }
 
+    const validateValues = {};
     for (const name in attributes) {
       const value = this.attribute(name);
       const { defaultValue } = attributes[name];
@@ -735,10 +723,12 @@ class Bone {
       } else if (value === undefined && defaultValue != null) {
         data[name] = defaultValue;
       }
+      if (attributes[name].primaryKey) continue;
+      validateValues[name] = data[name];
     }
 
     if (opts.validate !== false) {
-      this._validateAttributes();
+      this._validateAttributes(validateValues);
     }
 
     const spell = new Spell(Model, opts).$insert(data);
@@ -824,10 +814,10 @@ class Bone {
 
     const conditions = {
       [primaryKey]: this[primaryKey],
-      deletedAt: { $ne: null },
+      [deletedAt]: { $ne: null },
     };
     if (shardingKey) conditions[shardingKey] = this[shardingKey];
-    await this.update({ deletedAt: null }, { ...opts, paranoid: false });
+    await this.update({ [deletedAt]: null }, { ...opts, paranoid: false });
     return this;
   }
 
@@ -842,7 +832,7 @@ class Bone {
     if (deletedAt == null) {
       throw new Error('Model is not paranoid');
     }
-    return Bone.update.call(this, conditions, { deletedAt: null }, { ...opts, paranoid: false });
+    return Bone.update.call(this, conditions, { [deletedAt]: null }, { ...opts, paranoid: false });
   }
 
   /**
@@ -857,9 +847,13 @@ class Bone {
     const data = {};
     const Model = this;
     const { attributes } = Model;
-    for (const name in values) {
-      if (this.hasAttribute(name)) {
-        data[name] = values[name];
+    for (const key in attributes) {
+      const attribute = attributes[key];
+      if (attribute.primaryKey) continue;
+      if (values[key] == null && attribute.defaultValue != null) {
+        data[key] = attribute.defaultValue;
+      } else if (values[key] !== undefined){
+        data[key] = values[key];
       }
     }
 
@@ -933,20 +927,38 @@ class Bone {
       };
     }
 
+    const columnMap = columns.reduce((result, entry) => {
+      result[entry.columnName] = entry;
+      return result;
+    }, {});
+
     for (const name of Object.keys(attributes)) {
       const attribute = new Attribute(name, attributes[name], options.define);
       attributeMap[attribute.columnName] = attribute;
       attributes[name] = attribute;
+      if (TIMESTAMP_NAMES.includes(name)) {
+        const { columnName } = attribute;
+        const legacyColumnName = LEGACY_TIMESTAMP_COLUMN_MAP[columnName];
+        if (!columnMap[columnName] && legacyColumnName && columnMap[legacyColumnName]) {
+          // correct columname
+          attribute.columnName = legacyColumnName;
+          attributeMap[attribute.columnName] = attribute;
+        }
+      }
+      const columnInfo = columnMap[attribute.columnName];
+      // if datetime or timestamp precision not defined, default to column info
+      if (columnInfo && attribute.type instanceof DataTypes.DATE && attribute.type.precision == null) {
+        attribute.type.precision = columnInfo.datetimePrecision;
+      }
     }
 
     const primaryKey = Object.keys(attributes).find(key => attributes[key].primaryKey);
     const timestamps = {};
-    for (const key of [ 'createdAt', 'updatedAt', 'deletedAt' ]) {
+    for (const key of TIMESTAMP_NAMES) {
       const name = attributes.hasOwnProperty(key) ? key : snakeCase(key);
       const attribute = attributes[name];
 
-      if (!attribute) continue;
-      if (columns.some(column => column.columnName === attribute.columnName)) {
+      if (attribute && columnMap[attribute.columnName]) {
         timestamps[key] = name;
       }
     }
@@ -960,7 +972,7 @@ class Bone {
       attributeMap,
       associations,
       tableAlias,
-      synchronized: Object.keys(compare(attributes, columns)).length === 0,
+      synchronized: Object.keys(compare(attributes, columnMap)).length === 0,
     }));
 
     for (const hookName of hookNames) {
@@ -1311,13 +1323,9 @@ class Bone {
   static create(values, opts = {}) {
     const data = Object.assign({}, values);
     const instance = new this(data);
-    if (opts.validate !== false) {
-      instance._validateAttributes(data); // call instance._validateAttributes manually to validate the raw value
-    }
     // static create proxy to instance.create
     return instance.create({
       ...opts,
-      validate: false, // should not validate again
     });
   }
 
@@ -1416,7 +1424,7 @@ class Bone {
     // values should be immutable
     const data = Object.assign({}, values);
     const { updatedAt, deletedAt } = this.timestamps;
-    if (attributes[updatedAt] && !data[updatedAt] && !data[deletedAt]) {
+    if (attributes[updatedAt] && !data[updatedAt] && !data[deletedAt] && !options.silent) {
       data[updatedAt] = new Date();
     }
 
@@ -1537,7 +1545,7 @@ class Bone {
     Object.defineProperties(this, looseReadonly({ ...hookMethods, attributes, table }));
   }
 
-  static async sync() {
+  static async sync({ force = false, alter = false } = {}) {
     const { driver, physicTable: table } = this;
     const { database } = this.options;
 
@@ -1554,11 +1562,22 @@ class Bone {
     }
 
     const { attributes, columns } = this;
+    const columnMap = columns.reduce((result, entry) => {
+      result[entry.columnName] = entry;
+      return result;
+    }, {});
 
     if (columns.length === 0) {
       await driver.createTable(table, attributes);
     } else {
-      await driver.alterTable(table, compare(attributes, columns));
+      if (force) {
+        await driver.dropTable(table);
+        await driver.createTable(table, attributes);
+      } else if (alter){
+        await driver.alterTable(table, compare(attributes, columnMap));
+      } else {
+        console.warn('[synchronize_fail] %s couldn\'t be synchronized, please use force or alter to specify execution', this.name);
+      }
     }
 
     const schemaInfo = await driver.querySchemaInfo(database, table);

package/src/collection.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const { AGGREGATOR_MAP } = require('./constants');
+
+const AGGREGATORS = Object.values(AGGREGATOR_MAP);
 /**
  * An extended Array to represent collections of models.
  */
@@ -87,8 +90,14 @@ function dispatch(spell, rows, fields) {
     const { type, value, args } = columns[0];
     if (type === 'alias' && args && args[0].type === 'func') {
       const row = rows[0];
-      const result = row && (row[''] || row[table]);
-      return result && result[value] || 0;
+      const record = row && (row[''] || row[table]);
+      const result = record && record[value];
+      // see https://www.w3schools.com/mysql/mysql_ref_functions.asp
+      if (AGGREGATORS.includes(args[0].name)) {
+        const num = Number(result);
+        return isNaN(num) ? result : num;
+      }
+      return result;
     }
   }
 

package/src/constants.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const AGGREGATOR_MAP = {
+  count: 'count',
+  average: 'avg',
+  minimum: 'min',
+  maximum: 'max',
+  sum: 'sum'
+};
+
+const LEGACY_TIMESTAMP_MAP = {
+  gmtCreate: 'createdAt',
+  gmtModified: 'updatedAt',
+  gmtDeleted: 'deletedAt',
+};
+
+const LEGACY_TIMESTAMP_COLUMN_MAP = {
+  created_at: 'gmt_create',
+  updated_at: 'gmt_modified',
+  deleted_at: 'gmt_deleted',
+};
+
+const TIMESTAMP_NAMES = [ 'createdAt', 'updatedAt', 'deletedAt' ];
+
+module.exports = {
+  AGGREGATOR_MAP,
+  LEGACY_TIMESTAMP_MAP,
+  TIMESTAMP_NAMES,
+  LEGACY_TIMESTAMP_COLUMN_MAP
+};

package/src/data_types.js

@@ -2,6 +2,7 @@
 
 const util = require('util');
 const invokable = require('./utils/invokable');
+const Raw = require('./raw');
 
 /**
  * @example
@@ -114,7 +115,7 @@ class STRING extends DataType {
   }
 
   uncast(value) {
-    if (value == null) return value;
+    if (value == null || value instanceof Raw) return value;
     return '' + value;
   }
 }
@@ -186,15 +187,18 @@ class INTEGER extends DataType {
   }
 
   cast(value) {
-    if (value == null) return value;
+    if (value == null || isNaN(value)) return value;
     return Number(value);
   }
 
-  uncast(value) {
+  uncast(value, strict = true) {
     const originValue = value;
-    if (value == null) return value;
+    if (value == null || value instanceof Raw) return value;
     if (typeof value === 'string') value = parseInt(value, 10);
-    if (isNaN(value)) throw new Error(util.format('invalid integer: %s', originValue));
+    if (isNaN(value)) {
+      if (strict) throw new Error(util.format('invalid integer: %s', originValue));
+      return originValue;
+    }
     return value;
   }
 }
@@ -214,7 +218,7 @@ class BIGINT extends INTEGER {
   }
 }
 
-const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6})?$/;
+const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6})$/;
 
 class DATE extends DataType {
   constructor(precision, timezone = true) {
@@ -229,20 +233,31 @@ class DATE extends DataType {
   toSqlString() {
     const { precision } = this;
     const dataType = this.dataType.toUpperCase();
-    if (precision > 0) return `${dataType}(${precision})`;
+    if (precision != null && precision >= 0) return `${dataType}(${precision})`;
     return dataType;
   }
 
+  _round(value) {
+    const { precision } = this;
+    if (precision != null && precision < 3 && value instanceof Date) {
+      const divider = 10 ** (3 - precision);
+      return new Date(Math.round(value.getTime() / divider) * divider);
+    }
+    return value;
+  }
+
   cast(value) {
+    const original = value;
     if (value == null) return value;
-    if (value instanceof Date) return value;
-    return new Date(value);
+    if (!(value instanceof Date)) value = new Date(value);
+    if (isNaN(value.getTime())) return original;
+    return this._round(value);
   }
 
   uncast(value) {
     const originValue = value;
 
-    if (value == null) return value;
+    if (value == null || value instanceof Raw) return value;
     if (typeof value.toDate === 'function') {
       value = value.toDate();
     }
@@ -258,13 +273,7 @@ class DATE extends DataType {
     if (!(value instanceof Date)) value = new Date(value);
     if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));
 
-    const { precision } = this;
-    if (precision < 3) {
-      const result = new Date(value);
-      result.setMilliseconds(result.getMilliseconds() % (10 ** precision));
-      return result;
-    }
-    return value;
+    return this._round(value);
   }
 }
 
@@ -278,16 +287,25 @@ class DATEONLY extends DataType {
     return this.dataType.toUpperCase();
   }
 
+  _round(value) {
+    if (value instanceof Date) {
+      return new Date(value.getFullYear(), value.getMonth(), value.getDate());
+    }
+    return value;
+  }
+
   cast(value) {
+    const original = value;
     if (value == null) return value;
-    if (value instanceof Date) return value;
-    return new Date(value);
+    if (!(value instanceof Date)) value = new Date(value);
+    if (isNaN(value.getTime())) return original;
+    return this._round(value);
   }
 
   uncast(value) {
     const originValue = value;
 
-    if (value == null) return value;
+    if (value == null || value instanceof Raw) return value;
     if (typeof value.toDate === 'function') {
       value = value.toDate();
     }
@@ -299,9 +317,9 @@ class DATEONLY extends DataType {
     }
 
     if (!(value instanceof Date)) value = new Date(value);
-    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));;
+    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));
 
-    return new Date(value.getFullYear(), value.getMonth(), value.getDate());
+    return this._round(value);
   }
 }
 
@@ -374,11 +392,16 @@ class JSON extends DataType {
     if (!value) return value;
     // type === JSONB
     if (typeof value === 'object') return value;
-    return global.JSON.parse(value);
+    try {
+      return global.JSON.parse(value);
+    } catch (err) {
+      console.error(new Error(`unable to cast ${value} to JSON`));
+      return value;
+    }
   }
 
   uncast(value) {
-    if (value == null) return value;
+    if (value == null || value instanceof Raw) return value;
     return global.JSON.stringify(value);
   }
 }

package/src/drivers/abstract/attribute.js

@@ -126,11 +126,11 @@ class Attribute {
     return this.type.cast(value);
   }
 
-  uncast(value) {
+  uncast(value, strict = true) {
     if (Array.isArray(value) && this.jsType !== JSON) {
-      return value.map(entry => this.type.uncast(entry));
+      return value.map(entry => this.type.uncast(entry, strict));
     }
-    return this.type.uncast(value);
+    return this.type.uncast(value, strict);
   }
 }
 

package/src/drivers/abstract/spellbook.js

@@ -4,6 +4,7 @@ const SqlString = require('sqlstring');
 
 const { copyExpr, findExpr, walkExpr } = require('../../expr');
 const { formatExpr, formatConditions, collectLiteral } = require('../../expr_formatter');
+const Raw = require('../../raw');
 
 /**
  * Format orders into ORDER BY clause in SQL
@@ -128,7 +129,7 @@ function createSubspell(spell) {
   subspell.orders = [];
   for (const order of orders) {
     const [token, direction] = order;
-    const { type, qualifiers, value } = token;
+    const { type, qualifiers = [], value } = token;
     if (type == 'id' && qualifiers[0] == baseName) {
       subspell.orders.push([{ type, value }, direction]);
     }
@@ -219,13 +220,13 @@ function formatSelectWithJoin(spell) {
 
   let hoistable = skip > 0 || rowCount > 0;
   if (hoistable) {
-    for (const condition of whereConditions) {
-      walkExpr(condition, ({ type, qualifiers }) => {
-        if (type === 'id' && qualifiers.length> 0 && !qualifiers.includes(baseName)) {
-          hoistable = false;
-        }
-      });
+    function checkQualifier({ type, qualifiers = [] }) {
+      if (type === 'id' && qualifiers.length> 0 && !qualifiers.includes(baseName)) {
+        hoistable = false;
+      }
     }
+    for (const condition of whereConditions) walkExpr(condition, checkQualifier);
+    for (const orderExpr of orders) walkExpr(orderExpr[0], checkQualifier);
   }
 
   if (hoistable) {
@@ -386,7 +387,7 @@ function formatInsert(spell) {
       const value = sets[name];
       // upsert should not update createdAt
       columns.push(Model.unalias(name));
-      if (value && value.__raw) {
+      if (value instanceof Raw) {
         values.push(SqlString.raw(value.value));
       } else {
         values.push(value);
@@ -449,7 +450,7 @@ function formatUpdate(spell) {
     if (value && value.__expr) {
       assigns.push(`${escapeId(Model.unalias(name))} = ${formatExpr(spell, value)}`);
       collectLiteral(spell, value, values);
-    } else if (value && value.__raw) {
+    } else if (value instanceof Raw) {
       assigns.push(`${escapeId(Model.unalias(name))} = ${value.value}`);
     } else {
       assigns.push(`${escapeId(Model.unalias(name))} = ?`);
@@ -457,7 +458,6 @@ function formatUpdate(spell) {
     }
   }
 
-  for (const condition of whereConditions) collectLiteral(spell, condition, values);
   // see https://dev.mysql.com/doc/refman/8.0/en/optimizer-hints.html
   const hintStr = this.formatOptimizerHints(spell);
   // see https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
@@ -472,7 +472,11 @@ function formatUpdate(spell) {
   }
 
   chunks.push(`SET ${assigns.join(', ')}`);
-  chunks.push(`WHERE ${formatConditions(spell, whereConditions)}`);
+  if (whereConditions.length > 0) {
+    for (const condition of whereConditions) collectLiteral(spell, condition, values);
+    chunks.push(`WHERE ${formatConditions(spell, whereConditions)}`);
+  }
+
   return {
     sql: chunks.join(' '),
     values,
@@ -603,4 +607,5 @@ module.exports = {
   formatSelectWithoutJoin,
   formatUpdateOnDuplicate,
   formatReturning,
+  formatOrders
 };

package/src/drivers/mysql/index.js

@@ -93,7 +93,7 @@ class MysqlDriver extends AbstractDriver {
     try {
       result = await promise;
     } catch (err) {
-      logger.logQueryError(sql, err, calculateDuration(start), opts);
+      logger.logQueryError(err, sql, calculateDuration(start), opts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();

package/src/drivers/mysql/schema.js

@@ -17,7 +17,8 @@ module.exports = {
     tables = [].concat(tables);
     const sql = heresql(`
       SELECT table_name, column_name, column_type, data_type, is_nullable,
-             column_default, column_key, column_comment
+             column_default, column_key, column_comment,
+             datetime_precision
         FROM information_schema.columns
        WHERE table_schema = ? AND table_name in (?)
        ORDER BY table_name, column_name
@@ -43,6 +44,7 @@ module.exports = {
         allowNull: row.is_nullable === 'YES',
         primaryKey: row.column_key == 'PRI',
         unique: row.column_key == 'PRI' || row.column_key == 'UNI',
+        datetimePrecision: row.datetime_precision,
       });
     }
 

package/src/drivers/mysql/spellbook.js

@@ -58,4 +58,21 @@ module.exports = {
   formatReturning() {
     return '';
   },
+
+  /**
+   * UPDATE ... ORDER BY ... LIMIT ${rowCount}
+   * - https://dev.mysql.com/doc/refman/8.0/en/update.html
+   * @param {Spell} spell
+   */
+  formatUpdate(spell) {
+    const result = spellbook.formatUpdate.call(this, spell);
+    const { rowCount, orders } = spell;
+    const chunks = [];
+
+    if (orders.length > 0) chunks.push(`ORDER BY ${this.formatOrders(spell, orders).join(', ')}`);
+    if (rowCount > 0) chunks.push(`LIMIT ${rowCount}`);
+    if (chunks.length > 0) result.sql += ` ${chunks.join(' ')}`;
+
+    return result;
+  },
 };

package/src/drivers/postgres/attribute.js

@@ -35,7 +35,6 @@ class PostgresAttribute extends Attribute {
     return chunks.join(' ');
   }
 
-
   equals(columnInfo) {
     if (!columnInfo) return false;
     if (this.type.toSqlString() !== columnInfo.columnType.toUpperCase()) {

package/src/drivers/postgres/data_types.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const DataTypes = require('../../data_types');
+const util = require('util');
+const Raw = require('../../raw');
+
 
 class Postgres_DATE extends DataTypes.DATE {
   constructor(precision, timezone = true) {
@@ -37,12 +40,35 @@ class Postgres_BINARY extends DataTypes {
   }
 }
 
+class Postgres_INTEGER extends DataTypes.INTEGER {
+  constructor(length) {
+    super(length);
+  }
+
+  uncast(value) {
+    const originValue = value;
+    if (value == null || value instanceof Raw) return value;
+    if (typeof value === 'string') value = parseInt(value, 10);
+    if (isNaN(value)) throw new Error(util.format('invalid integer: %s', originValue));
+    return value;
+  }
+}
+
+class Postgres_BIGINT extends Postgres_INTEGER {
+  constructor() {
+    super();
+    this.dataType = 'bigint';
+  }
+}
+
 class Postgres_DataTypes extends DataTypes {
   static DATE = Postgres_DATE;
   static JSONB = Postgres_JSONB;
   static BINARY = Postgres_BINARY;
   static VARBINARY = Postgres_BINARY;
   static BLOB = Postgres_BINARY;
+  static INTEGER = Postgres_INTEGER;
+  static BIGINT =  Postgres_BIGINT;
 }
 
 module.exports = Postgres_DataTypes;

package/src/drivers/postgres/index.js

@@ -137,7 +137,7 @@ class PostgresDriver extends AbstractDriver {
       try {
         result = await connection.query(...args);
       } catch (err) {
-        logger.logQueryError(formatted, err, calculateDuration(start), spell);
+        logger.logQueryError(err, formatted, calculateDuration(start), spell);
         throw err;
       } finally {
         if (!spell.connection) connection.release();

package/src/drivers/postgres/schema.js

@@ -58,6 +58,8 @@ module.exports = {
       if (dataType === 'character varying') dataType = 'varchar';
       if (dataType === 'timestamp without time zone') dataType = 'timestamp';
       const primaryKey = row.constraint_type === 'PRIMARY KEY';
+      const precision = row.datetime_precision;
+
       columns.push({
         columnName: row.column_name,
         columnType: length > 0 ? `${dataType}(${length})` : dataType,
@@ -67,6 +69,7 @@ module.exports = {
         // https://www.postgresql.org/docs/9.5/infoschema-table-constraints.html
         primaryKey,
         unique: row.constraint_type === 'UNIQUE',
+        datetimePrecision: precision === 6 ? null : precision,
       });
     }
 

package/src/drivers/sqlite/data_types.js

@@ -3,16 +3,46 @@
 const DataTypes = require('../../data_types');
 
 class Sqlite_DATE extends DataTypes.DATE {
-  constructor(precision) {
-    super(precision);
+  constructor(precision, timezone) {
+    super(precision, timezone);
     this.dataType = 'datetime';
   }
 
-  toSqlString() {
-    return this.dataType.toUpperCase();
+  uncast(value) {
+    try {
+      return super.uncast(value);
+    } catch (error) {
+      console.error(new Error(`unable to cast ${value} to DATE`));
+      return value;
+    }
+  }
+}
+
+class Sqlite_DATEONLY extends DataTypes.DATEONLY {
+  constructor() {
+    super();
+  }
+
+  uncast(value) {
+    try {
+      return super.uncast(value);
+    } catch (error) {
+      console.error(new Error(`unable to cast ${value} to DATEONLY`));
+      return value;
+    }
   }
 }
 
+class Sqlite_INTEGER extends DataTypes.INTEGER {
+  constructor(length) {
+    super(length);
+  }
+
+  uncast(value) {
+    return super.uncast(value, false);
+  }
+
+}
 class Sqlite_BIGINT extends DataTypes.BIGINT {
   constructor() {
     super();
@@ -62,6 +92,14 @@ class Sqlite_DataTypes extends DataTypes {
   static get VARBINARY() {
     return Sqlite_VARBINARY;
   }
+
+  static get DATEONLY() {
+    return Sqlite_DATEONLY;
+  }
+
+  static get INTEGER() {
+    return Sqlite_INTEGER;
+  }
 }
 
 module.exports = Sqlite_DataTypes;

package/src/drivers/sqlite/index.js

@@ -48,7 +48,7 @@ class SqliteDriver extends AbstractDriver {
     try {
       result = await connection.query(query, values, opts);
     } catch (err) {
-      logger.logQueryError(sql, err, calculateDuration(start), opts);
+      logger.logQueryError(err, sql, calculateDuration(start), opts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();

package/src/drivers/sqlite/schema.js

@@ -101,19 +101,24 @@ module.exports = {
     });
     const results = await Promise.all(queries);
     const schemaInfo = {};
+    const rColumnType = /^(\w+)(?:\(([^)]+)\))?/i;
+    const rDateType = /(?:date|datetime|timestamp)/i;
+
     for (let i = 0; i < tables.length; i++) {
       const table = tables[i];
       const { rows } = results[i];
       const columns = rows.map(({ name, type, notnull, dflt_value, pk }) => {
         const columnType = type.toLowerCase();
+        const [, dataType, precision ] = columnType.match(rColumnType);
         const primaryKey = pk === 1;
         const result = {
           columnName: name,
           columnType,
           defaultValue: parseDefaultValue(dflt_value),
-          dataType: columnType.split('(')[0],
+          dataType: dataType,
           allowNull: primaryKey ? false : notnull == 0,
           primaryKey,
+          datetimePrecision: rDateType.test(dataType) ? parseInt(precision, 10) : null,
         };
         return result;
       });

package/src/expr_formatter.js

@@ -208,7 +208,7 @@ function coerceLiteral(spell, ast) {
     if (arg.type === 'literal') {
       // { params: { $like: '%foo%' } }
       if (attribute.jsType === JSON && typeof arg.value === 'string') continue;
-      arg.value = attribute.uncast(arg.value);
+      arg.value = attribute.uncast(arg.value, false);
     }
   }
 }

package/src/query_object.js

@@ -3,6 +3,7 @@
 const util = require('util');
 const { isPlainObject } = require('./utils');
 const { parseExpr } = require('./expr');
+const Raw = require('./raw');
 // deferred to break cyclic dependencies
 let Spell;
 
@@ -29,7 +30,7 @@ const OPERATOR_MAP = {
  */
 function parseValue(value) {
   if (value instanceof Spell) return { type: 'subquery', value };
-  if (value && value.__raw) return { type: 'raw', value: value.value };
+  if (value instanceof Raw) return { type: 'raw', value: value.value };
   return parseExpr('?', value);
 }
 

package/src/raw.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = class Raw {
+  constructor(value) {
+    this.value = value;
+    // consumed in expr_formatter.js
+    this.type = 'raw';
+  }
+};

package/src/realm.js

@@ -7,6 +7,8 @@ const Bone = require('./bone');
 const { findDriver } = require('./drivers');
 const { camelCase } = require('./utils/string');
 const sequelize = require('./adapters/sequelize');
+const Raw = require('./raw');
+const { LEGACY_TIMESTAMP_MAP } = require('./constants');
 
 /**
  *
@@ -38,12 +40,6 @@ 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
@@ -163,12 +159,12 @@ class Realm {
     return this.Bone;
   }
 
-  async sync() {
+  async sync(options) {
     if (!this.connected) await this.connect();
     const { models } = this;
 
     for (const model of Object.values(models)) {
-      await model.sync();
+      await model.sync(options);
     }
   }
 
@@ -239,11 +235,7 @@ class Realm {
     if (typeof sql !== 'string') {
       throw new TypeError('sql must be a string');
     }
-    return {
-      __raw: true,
-      value: sql,
-      type: 'raw',
-    };
+    return new Raw(sql);
   }
 
   // instance.raw

package/src/spell.js

@@ -10,6 +10,8 @@ const { parseExprList, parseExpr, walkExpr } = require('./expr');
 const { isPlainObject } = require('./utils');
 const { IndexHint, INDEX_HINT_TYPE, Hint } = require('./hint');
 const { parseObject } = require('./query_object');
+const Raw = require('./raw');
+const { AGGREGATOR_MAP } = require('./constants');
 
 /**
  * Parse condition expressions
@@ -21,7 +23,7 @@ const { parseObject } = require('./query_object');
  * @returns {Array}
  */
 function parseConditions(conditions, ...values) {
-  if (conditions.__raw) return [ conditions ];
+  if (conditions instanceof Raw) return [ conditions ];
   if (isPlainObject(conditions)) {
     return parseObject(conditions);
   } else if (typeof conditions == 'string') {
@@ -41,7 +43,7 @@ function parseSelect(spell, ...names) {
 
   const columns = [];
   for (const name of names) {
-    if (name.__raw) columns.push(name);
+    if (name instanceof Raw) columns.push(name);
     else columns.push(...parseExprList(name));
   }
 
@@ -68,8 +70,7 @@ function parseSelect(spell, ...names) {
  * @returns {Object}
  */
 function formatValueSet(spell, obj, strict = true) {
-  const { Model, silent = false, command } = spell;
-  const { timestamps } = Model;
+  const { Model } = spell;
   const sets = {};
   for (const name in obj) {
     const attribute = Model.attributes[name];
@@ -79,12 +80,8 @@ function formatValueSet(spell, obj, strict = true) {
       throw new Error(`Undefined attribute "${name}"`);
     }
 
-    if (silent && timestamps.updatedAt && name === timestamps.updatedAt && command === 'update') {
-      continue;
-    }
-
     // raw sql don't need to uncast
-    if (value && value.__raw) {
+    if (value instanceof Raw) {
       sets[name] = value;
     } else {
       sets[name] = attribute.uncast(value);
@@ -402,7 +399,6 @@ class Spell {
       hints: [...this.hints],
       // used by transaction
       connection: this.connection,
-      silent: this.silent,
     });
   }
 
@@ -530,8 +526,8 @@ class Spell {
   }
 
   $increment(name, by = 1, opts = {}) {
-    let { Model, silent = false } = this;
-    if (opts.silent != null) silent = opts.silent;
+    const { Model } = this;
+    const silent = opts.silent;
     const { timestamps } = Model;
     this.command = 'update';
     if (!Number.isFinite(by)) throw new Error(`unexpected increment value ${by}`);
@@ -652,7 +648,7 @@ class Spell {
    */
   $order(name, direction) {
     if (isPlainObject(name)) {
-      if (name.__raw) {
+      if (name instanceof Raw) {
         this.orders.push([
           name,
         ]);
@@ -717,7 +713,7 @@ class Spell {
     for (const condition of parseConditions(conditions, ...values)) {
       // Postgres can't have alias in HAVING caluse
       // https://stackoverflow.com/questions/32730296/referring-to-a-select-aggregate-column-alias-in-the-having-clause-in-postgres
-      if (this.Model.driver.type === 'postgres' && !condition.__raw) {
+      if (this.Model.driver.type === 'postgres' && !(condition instanceof Raw)) {
         const { value } = condition.args[0];
         for (const column of this.columns) {
           if (column.value === value && column.type === 'alias') {
@@ -908,14 +904,6 @@ class Spell {
   }
 }
 
-const AGGREGATOR_MAP = {
-  count: 'count',
-  average: 'avg',
-  minimum: 'min',
-  maximum: 'max',
-  sum: 'sum'
-};
-
 for (const aggregator in AGGREGATOR_MAP) {
   const func = AGGREGATOR_MAP[aggregator];
   Object.defineProperty(Spell.prototype, `$${aggregator}`, {

package/types/index.d.ts

@@ -64,10 +64,10 @@ export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Insta
   constructor(Model: T, opts: SpellOptions);
 
   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>;
-  delete(): Spell<T, number>;
+  insert(opts: SetOptions): Spell<T, QueryResult>;
+  update(opts: SetOptions): Spell<T, QueryResult>;
+  upsert(opts: SetOptions): Spell<T, QueryResult>;
+  delete(): Spell<T, QueryResult>;
 
   from(table: string | Spell<T>): Spell<T, U>;
 
@@ -107,8 +107,8 @@ export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Insta
 
   batch(size?: number): AsyncIterable<T>;
 
-  increment(name: string, by?: number, options?: QueryOptions): Spell<T, number>;
-  decrement(name: string, by?: number, options?: QueryOptions): Spell<T, number>;
+  increment(name: string, by?: number, options?: QueryOptions): Spell<T, QueryResult>;
+  decrement(name: string, by?: number, options?: QueryOptions): Spell<T, QueryResult>;
 
   toSqlString(): string;
   toString(): string;