leoric 1.15.1 → 2.0.3

package/History.md

@@ -1,3 +1,54 @@
+2.0.3 / 2021-02-11
+==================
+
+## What's Changed
+* fix: default updatedAt to new date if model has no createdAt by @LB4027221 in https://github.com/cyjake/leoric/pull/268
+
+## New Contributors
+* @LB4027221 made their first contribution in https://github.com/cyjake/leoric/pull/268
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.0.2...v2.0.3
+
+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
 ===================
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "1.15.1",
+  "version": "2.0.3",
   "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

@@ -15,6 +15,7 @@ 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) => {
@@ -76,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:
  *
@@ -280,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);
   }
 
   /**
@@ -306,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);
   }
 
   /**
@@ -722,9 +711,10 @@ class Bone {
     }
 
     if (attributes[updatedAt] && !this[updatedAt]) {
-      this[updatedAt] = this[createdAt];
+      this[updatedAt] = this[createdAt] || new Date();
     }
 
+    const validateValues = {};
     for (const name in attributes) {
       const value = this.attribute(name);
       const { defaultValue } = attributes[name];
@@ -733,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);
@@ -822,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;
   }
 
@@ -840,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 });
   }
 
   /**
@@ -855,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];
       }
     }
 
@@ -940,6 +936,15 @@ class Bone {
       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) {
@@ -949,7 +954,7 @@ class Bone {
 
     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];
 
@@ -1318,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
     });
   }
 
@@ -1544,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;
 
@@ -1569,7 +1570,14 @@ class Bone {
     if (columns.length === 0) {
       await driver.createTable(table, attributes);
     } else {
-      await driver.alterTable(table, compare(attributes, columnMap));
+      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;
   }
 }
@@ -243,15 +247,17 @@ class DATE extends DataType {
   }
 
   cast(value) {
+    const original = value;
     if (value == null) return 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();
     }
@@ -289,15 +295,17 @@ class DATEONLY extends DataType {
   }
 
   cast(value) {
+    const original = value;
     if (value == null) return 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();
     }
@@ -309,7 +317,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));;
+    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));
 
     return this._round(value);
   }
@@ -393,7 +401,7 @@ class JSON extends DataType {
   }
 
   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

@@ -129,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]);
     }
@@ -220,7 +220,7 @@ function formatSelectWithJoin(spell) {
 
   let hoistable = skip > 0 || rowCount > 0;
   if (hoistable) {
-    function checkQualifier({ type, qualifiers }) {
+    function checkQualifier({ type, qualifiers = [] }) {
       if (type === 'id' && qualifiers.length> 0 && !qualifiers.includes(baseName)) {
         hoistable = false;
       }
@@ -476,6 +476,7 @@ function formatUpdate(spell) {
     for (const condition of whereConditions) collectLiteral(spell, condition, values);
     chunks.push(`WHERE ${formatConditions(spell, whereConditions)}`);
   }
+
   return {
     sql: chunks.join(' '),
     values,
@@ -606,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/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/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/sqlite/data_types.js

@@ -7,8 +7,42 @@ class Sqlite_DATE extends DataTypes.DATE {
     super(precision, timezone);
     this.dataType = 'datetime';
   }
+
+  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();
@@ -58,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/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/realm.js

@@ -8,6 +8,7 @@ const { findDriver } = require('./drivers');
 const { camelCase } = require('./utils/string');
 const sequelize = require('./adapters/sequelize');
 const Raw = require('./raw');
+const { LEGACY_TIMESTAMP_MAP } = require('./constants');
 
 /**
  *
@@ -39,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
@@ -164,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);
     }
   }
 

package/src/spell.js

@@ -11,6 +11,7 @@ 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
@@ -903,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;