leoric 1.14.3 → 2.0.0

package/History.md

@@ -1,3 +1,51 @@
+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
+===================
+
+## What's Changed
+* feat: make duration in precise milliseconds by @fengmk2 in https://github.com/cyjake/leoric/pull/236
+* fix: spell.increment() & spell.decrement() @cyjake https://github.com/cyjake/leoric/pull/234
+* fix: bulkCreate should adapte empty data @JimmyDaddy  https://github.com/cyjake/leoric/pull/232
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.14.4...v1.14.5
+
+1.14.4 / 2021-11-15
+===================
+
+## What's Changed
+
+* test: PostgreSQL v14 test case compatibility by @cyjake https://github.com/cyjake/leoric/pull/230
+* fix: turn off subquery optimization if query criteria contains other column by @cyjake https://github.com/cyjake/leoric/pull/229
+* fix: bone.changed() return `false | string[]` type by @fengmk2 https://github.com/cyjake/leoric/pull/231
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.14.3...v1.14.4
+
 1.14.3 / 2021-11-12
 ===================
 

package/package.json

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

package/src/bone.js

@@ -11,6 +11,7 @@ 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');
@@ -27,12 +28,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 +68,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;
       }
     }
@@ -162,14 +159,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;
     }
@@ -682,7 +680,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 ) {
@@ -933,10 +931,20 @@ 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;
+      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);
@@ -945,8 +953,7 @@ class Bone {
       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 +967,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) {
@@ -1322,6 +1329,7 @@ class Bone {
   }
 
   static async bulkCreate(records, options = {}) {
+    if (!records || !records.length) return records;
     const { driver, attributes, primaryKey, primaryColumn } = this;
 
     const { createdAt, updatedAt } = this.timestamps;
@@ -1415,7 +1423,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();
     }
 
@@ -1536,7 +1544,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;
 
@@ -1553,11 +1561,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

@@ -11,7 +11,8 @@ class Collection extends Array {
    * @param {Array} fields
    * @returns {Collection|Array}
    */
-  static init({ spell, rows, fields }) {
+  static init({ spell, rows, fields, insertId, affectedRows}) {
+    if (spell.command !== 'select') return { insertId, affectedRows };
     return dispatch(spell, rows, fields);
   }
 

package/src/data_types.js

@@ -214,7 +214,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,14 +229,23 @@ 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) {
     if (value == null) return value;
-    if (value instanceof Date) return value;
-    return new Date(value);
+    if (!(value instanceof Date)) value = new Date(value);
+    return this._round(value);
   }
 
   uncast(value) {
@@ -258,13 +267,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,10 +281,17 @@ 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) {
     if (value == null) return value;
-    if (value instanceof Date) return value;
-    return new Date(value);
+    if (!(value instanceof Date)) value = new Date(value);
+    return this._round(value);
   }
 
   uncast(value) {
@@ -301,7 +311,7 @@ class DATEONLY extends DataType {
     if (!(value instanceof Date)) value = new Date(value);
     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,7 +384,12 @@ 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) {

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
@@ -117,21 +118,12 @@ function createSubspell(spell) {
   subspell.groups = [];
 
   subspell.whereConditions = [];
-  for (let i = whereConditions.length - 1; i >= 0; i--) {
-    const condition = whereConditions[i];
-    let internal = true;
-    walkExpr(condition, ({ type, qualifiers }) => {
-      if (type == 'id' && qualifiers[0] != baseName) {
-        internal = false;
-      }
+  while (whereConditions.length > 0) {
+    const condition = whereConditions.shift();
+    const token = copyExpr(condition, ({ type, value }) => {
+      if (type === 'id') return { type, value };
     });
-    if (internal) {
-      const token = copyExpr(condition, ({ type, value }) => {
-        if (type === 'id') return { type, value };
-      });
-      subspell.whereConditions.unshift(token);
-      whereConditions.splice(i, 1);
-    }
+    subspell.whereConditions.push(token);
   }
 
   subspell.orders = [];
@@ -226,7 +218,18 @@ function formatSelectWithJoin(spell) {
   }
   chunks.push(selects.join(', '));
 
-  if (skip > 0 || rowCount > 0) {
+  let hoistable = skip > 0 || rowCount > 0;
+  if (hoistable) {
+    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) {
     const subspell = createSubspell(spell);
     const subquery = this.formatSelectWithoutJoin(subspell);
     values.push(...subquery.values);
@@ -262,6 +265,10 @@ function formatSelectWithJoin(spell) {
   }
 
   if (orders.length > 0) chunks.push(`ORDER BY ${formatOrders(spell, orders).join(', ')}`);
+  if (!hoistable) {
+    if (rowCount > 0) chunks.push(`LIMIT ${rowCount}`);
+    if (skip > 0) chunks.push(`OFFSET ${skip}`);
+  }
   return { sql: chunks.join(' '), values };
 }
 
@@ -380,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);
@@ -443,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))} = ?`);
@@ -451,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
@@ -466,7 +472,10 @@ 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,

package/src/drivers/mysql/index.js

@@ -1,10 +1,13 @@
 'use strict';
 
+const { performance } = require('perf_hooks');
+
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
 const DataTypes = require('./data_types');
 const spellbook = require('./spellbook');
 const schema = require('./schema');
+const { calculateDuration } = require('../../utils');
 
 class MysqlDriver extends AbstractDriver {
   /**
@@ -84,19 +87,19 @@ class MysqlDriver extends AbstractDriver {
       });
     });
     const sql = logger.format(query, values, opts);
-    const start = Date.now();
+    const start = performance.now();
     let result;
 
     try {
       result = await promise;
     } catch (err) {
-      logger.logQueryError(sql, err, Date.now() - start, opts);
+      logger.logQueryError(err, sql, calculateDuration(start), opts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();
     }
 
-    logger.tryLogQuery(sql, Date.now() - start, opts);
+    logger.tryLogQuery(sql, calculateDuration(start), opts);
     const [ results, fields ] = result;
     if (fields) return { rows: results, fields };
     return results;

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/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/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { Pool } = require('pg');
+const { performance } = require('perf_hooks');
 
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
@@ -8,6 +9,7 @@ const DataTypes = require('./data_types');
 const { escape, escapeId } = require('./sqlstring');
 const spellbook = require('./spellbook');
 const schema = require('./schema');
+const { calculateDuration } = require('../../utils');
 
 /**
  * The actual column type can be found by mapping the `oid` (which is called `dataTypeID`) in the `RowDescription`.
@@ -129,19 +131,19 @@ class PostgresDriver extends AbstractDriver {
 
     async function tryQuery(...args) {
       const formatted = logger.format(sql, values, spell);
-      const start = new Date();
+      const start = performance.now();
       let result;
 
       try {
         result = await connection.query(...args);
       } catch (err) {
-        logger.logQueryError(formatted, err, Date.now() - start, spell);
+        logger.logQueryError(err, formatted, calculateDuration(start), spell);
         throw err;
       } finally {
         if (!spell.connection) connection.release();
       }
 
-      logger.tryLogQuery(formatted, Date.now() - start, spell);
+      logger.tryLogQuery(formatted, calculateDuration(start), spell);
       return result;
     }
 

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,14 +3,10 @@
 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();
-  }
 }
 
 class Sqlite_BIGINT extends DataTypes.BIGINT {

package/src/drivers/sqlite/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const strftime = require('strftime');
+const { performance } = require('perf_hooks');
 
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
@@ -9,6 +10,7 @@ const { escapeId, escape } = require('./sqlstring');
 const schema = require('./schema');
 const spellbook = require('./spellbook');
 const Pool = require('./pool');
+const { calculateDuration } = require('../../utils');
 
 class SqliteDriver extends AbstractDriver {
   constructor(opts = {}) {
@@ -40,19 +42,19 @@ class SqliteDriver extends AbstractDriver {
 
     const { logger } = this;
     const sql = logger.format(query, values, opts);
-    const start = Date.now();
+    const start = performance.now();
     let result;
 
     try {
       result = await connection.query(query, values, opts);
     } catch (err) {
-      logger.logQueryError(sql, err, Date.now() - start, opts);
+      logger.logQueryError(err, sql, calculateDuration(start), opts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();
     }
 
-    logger.tryLogQuery(sql, Date.now() - start, opts);
+    logger.tryLogQuery(sql, calculateDuration(start), opts);
     return result;
   }
 

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/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,7 @@ const Bone = require('./bone');
 const { findDriver } = require('./drivers');
 const { camelCase } = require('./utils/string');
 const sequelize = require('./adapters/sequelize');
+const Raw = require('./raw');
 
 /**
  *
@@ -163,12 +164,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 +240,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,7 @@ 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');
 
 /**
  * Parse condition expressions
@@ -21,7 +22,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 +42,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 +69,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 +79,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 +398,6 @@ class Spell {
       hints: [...this.hints],
       // used by transaction
       connection: this.connection,
-      silent: this.silent,
     });
   }
 
@@ -530,8 +525,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 +647,7 @@ class Spell {
    */
   $order(name, direction) {
     if (isPlainObject(name)) {
-      if (name.__raw) {
+      if (name instanceof Raw) {
         this.orders.push([
           name,
         ]);
@@ -717,7 +712,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') {

package/src/utils/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { performance } = require('perf_hooks');
+
 function isPlainObject(value) {
   return Object.prototype.toString.call(value) === '[object Object]';
 }
@@ -28,6 +30,11 @@ function getPropertyNames(obj) {
   return Array.from(propertyNamesSet);
 }
 
+// microseconds to millisecond, 10.456
+function calculateDuration(starttime) {
+  return Math.floor((performance.now() - starttime) * 1000) / 1000;
+}
+
 const logger = {};
 
 [ 'log', 'warn', 'debug', 'info', 'error' ].forEach(key => {
@@ -40,5 +47,6 @@ module.exports = {
   isPlainObject,
   compose,
   getPropertyNames,
+  calculateDuration,
   logger,
 };

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,6 +107,9 @@ 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, QueryResult>;
+  decrement(name: string, by?: number, options?: QueryOptions): Spell<T, QueryResult>;
+
   toSqlString(): string;
   toString(): string;
 }
@@ -158,6 +161,7 @@ interface QueryOptions {
   individualHooks?: boolean;
   hooks?: boolean;
   paranoid?: boolean;
+  silent?: boolean;
 }
 
 interface QueryResult {
@@ -494,7 +498,7 @@ export class Bone {
    * Get changed attributes or check if given attribute is changed or not
    */
   changed(name: string): boolean;
-  changed(): Array<string>;
+  changed(): Array<string> | false;
 
   /**
    * Get attribute changes