leoric 2.2.1 → 2.3.0

package/History.md

@@ -1,3 +1,30 @@
+2.3.0 / 2022-03-10
+==================
+
+## What's Changed
+* feat: model declaration with decorators by @cyjake in https://github.com/cyjake/leoric/pull/287
+* feat: add VIRTUAL data type by @JimmyDaddy in https://github.com/cyjake/leoric/pull/289
+* fix: create instance dirty check rule fix by @JimmyDaddy in https://github.com/cyjake/leoric/pull/290
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.2.3...v2.3.0
+2.2.3 / 2022-03-01
+==================
+
+## What's Changed
+* fix: normalize attribute defaultValue by @cyjake in https://github.com/cyjake/leoric/pull/285
+* fix: instance beforeUpdate hooks should not modify any Raw if there are no Raw assignment in them by @JimmyDaddy in https://github.com/cyjake/leoric/pull/283
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.2.2...v2.2.3
+
+2.2.2 / 2022-02-28
+==================
+
+## What's Changed
+* fix: tddl gives misleading information_schema.columns.table_name by @cyjake in https://github.com/cyjake/leoric/pull/284
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.2.1...v2.2.2
+
 2.2.1 / 2022-02-24
 ==================
 

package/index.js

@@ -11,6 +11,7 @@ const sequelize = require('./src/adapters/sequelize');
 const { heresql } = require('./src/utils/string');
 const Hint = require('./src/hint');
 const Realm = require('./src/realm');
+const Decorators = require('./src/decorators');
 
 /**
  * @typedef {Object} RawSql
@@ -38,6 +39,7 @@ const connect = async function connect(opts) {
 
 Object.assign(Realm.prototype, migrations, { DataTypes });
 Object.assign(Realm, {
+  default: Realm,
   connect,
   Bone,
   Collection,
@@ -47,6 +49,7 @@ Object.assign(Realm, {
   sequelize,
   heresql,
   ...Hint,
+  ...Decorators,
 });
 
 module.exports = Realm;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -11,7 +11,8 @@
   ],
   "scripts": {
     "jsdoc": "rm -rf docs/api && jsdoc -c .jsdoc.json -d docs/api -t node_modules/@cara/minami",
-    "pretest": "./test/prepare.sh",
+    "prepack": "tsc",
+    "pretest": "tsc && ./test/prepare.sh",
     "test": "./test/start.sh",
     "test:local": "./test/start.sh",
     "test:unit": "./test/start.sh unit",
@@ -50,6 +51,7 @@
     "debug": "^3.1.0",
     "heredoc": "^1.3.1",
     "pluralize": "^7.0.0",
+    "reflect-metadata": "^0.1.13",
     "sqlstring": "^2.3.0",
     "strftime": "^0.10.0",
     "validator": "^13.5.2"
@@ -72,6 +74,6 @@
     "pg": "^8.5.1",
     "sinon": "^10.0.0",
     "sqlite3": "^5.0.2",
-    "typescript": "^4.4.4"
+    "typescript": "^4.6.2"
   }
 }

package/src/bone.js

@@ -7,6 +7,7 @@
 const util = require('util');
 const pluralize = require('pluralize');
 const { executeValidator, LeoricValidateError } = require('./validator');
+require('reflect-metadata');
 
 const DataTypes = require('./data_types');
 const Collection = require('./collection');
@@ -14,8 +15,13 @@ 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');
+const {
+  TIMESTAMP_NAMES,
+  LEGACY_TIMESTAMP_COLUMN_MAP,
+  ASSOCIATE_METADATA_MAP,
+} = require('./constants');
+
+const columnAttributesKey = Symbol('leoric#columns');
 
 function looseReadonly(props) {
   return Object.keys(props).reduce((result, name) => {
@@ -156,7 +162,6 @@ class Bone {
    * Get or set attribute value by name. This method is quite similiar to `jQuery.attr()`. If the attribute isn't selected when queried from database, an error will be thrown when accessing it.
    *
    *     const post = Post.select('title').first
-   *     post.content   // throw Error('Unset attribute "content"')
    *
    * This is the underlying method of attribute getter/setters:
    *
@@ -189,7 +194,6 @@ class Bone {
     }
 
     if (this.#rawUnset.has(name)) {
-      logger.warn(`unset attribute "${name}"`);
       return;
     }
 
@@ -199,14 +203,14 @@ class Bone {
   }
 
   /**
-   *
-   * clone instance
+   * @protected clone instance
    * @param {Bone} target
    * @memberof Bone
    */
   _clone(target) {
-    Object.assign(this.#raw, target.getRaw());
-    Object.assign(this.#rawSaved, target.getRawSaved());
+    this.#raw = Object.assign({}, this.getRaw(), target.getRaw());
+    this.#rawSaved = Object.assign({}, this.getRawSaved(), target.getRawSaved());
+    this.#rawPrevious = Object.assign({}, this.getRawPrevious(), target.getRawPrevious());
   }
 
   /**
@@ -235,6 +239,34 @@ class Bone {
     return attributes.hasOwnProperty(name);
   }
 
+  /**
+   * get attributes except virtuals
+   */
+  static get columnAttributes() {
+    if (this[columnAttributesKey]) return this[columnAttributesKey];
+    const { attributes } = this;
+    this[columnAttributesKey] = {};
+    for (const key in this.attributes) {
+      if (!attributes[key].virtual) this[columnAttributesKey][key] = attributes[key];
+    }
+    return this[columnAttributesKey];
+  }
+
+  /**
+   * get actual update/insert columns to avoid empty insert or update
+   * @param {Object} data 
+   * @returns 
+   */
+  static _getColumns(data) {
+    if (!Object.keys(data).length) return data;
+    const attributes = this.columnAttributes;
+    const res = {};
+    for (const key in data) {
+      if (attributes[key]) res[key] = data[key];
+    }
+    return res;
+  }
+
   getRaw(key) {
     if (key) return this.#raw[key];
     return this.#raw;
@@ -320,7 +352,6 @@ class Bone {
    * post.attributeWas('title')  // => 'Leah'
    */
   attributeWas(name) {
-    if (this.#rawUnset.has(name)) throw new Error(`unset attribute "${name}"`);
     const value = this.#rawSaved[name];
     return value == null ? null : value;
   }
@@ -536,18 +567,18 @@ class Bone {
    * Sync changes made in {@link Bone.raw} back to {@link Bone.rawSaved}.
    * @private
    */
-  syncRaw(changes) {
+  syncRaw() {
     const { attributes } = this.constructor;
     this.isNewRecord = false;
-    for (const name of Object.keys(changes || attributes)) {
+    for (const name of Object.keys(attributes)) {
       const attribute = attributes[name];
       // Take advantage of uncast/cast to create new copy of value
       const value = attribute.uncast(this.#raw[name]);
       if (this.#rawSaved[name] !== undefined) {
         this.#rawPrevious[name] = this.#rawSaved[name];
-      } else if (!changes && this.#rawPrevious[name] === undefined) {
+      } else if (this.#rawPrevious[name] === undefined && this.#raw[name] != null) {
         // first persisting
-        this.#rawPrevious[name] = attribute.cast(value);
+        this.#rawPrevious[name] = null;
       }
       this.#rawSaved[name] = attribute.cast(value);
     }
@@ -579,7 +610,10 @@ class Bone {
       if (this.changed(name)) data[name] = this.attribute(name);
     }
 
-    if (Object.keys(data).length === 0) return Promise.resolve(0);
+    if (!Object.keys(Model._getColumns(data)).length) {
+      this.syncRaw();
+      return Promise.resolve(0);
+    }
 
     const { createdAt, updatedAt } = Model.timestamps;
 
@@ -659,7 +693,10 @@ class Bone {
       }
     }
 
-    if (Object.keys(changes).length === 0) return Promise.resolve(0);
+    if (!Object.keys(Model._getColumns(changes)).length) {
+      this.syncRaw();
+      return Promise.resolve(0);
+    }
     if (this[primaryKey] == null) {
       throw new Error(`unset primary key ${primaryKey}`);
     }
@@ -680,7 +717,7 @@ class Bone {
       for (const key in changes) {
         this.attribute(key, changes[key]);
       }
-      this.syncRaw(changes);
+      this.syncRaw();
       return result.affectedRows;
     });
   }
@@ -730,9 +767,15 @@ class Bone {
       this._validateAttributes(validateValues);
     }
 
+    if (!Object.keys(Model._getColumns(data)).length) {
+      this.syncRaw();
+      return this;
+    }
+
     const spell = new Spell(Model, opts).$insert(data);
     return spell.later(result => {
       this[primaryKey] = result.insertId;
+      // this.#rawSaved[primaryKey] = null;
       this.syncRaw();
       return this;
     });
@@ -856,7 +899,10 @@ class Bone {
       }
     }
 
-    if (Object.keys(data).length === 0) return Promise.resolve(0);
+    if (!Object.keys(Model._getColumns(data)).length) {
+      this.syncRaw();
+      return Promise.resolve(0);
+    }
 
     const { createdAt, updatedAt } = Model.timestamps;
 
@@ -977,6 +1023,7 @@ class Bone {
     for (const hookName of hookNames) {
       if (this[hookName]) setupSingleHook(this, hookName, this[hookName]);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -989,7 +1036,12 @@ class Bone {
    *   }
    * }
    */
-  static initialize() {}
+  static initialize() {
+    for (const [key, metadataKey] of Object.entries(ASSOCIATE_METADATA_MAP)) {
+      const result = Reflect.getMetadata(metadataKey, this);
+      for (const property in result) this[key].call(this, property, result[property]);
+    }
+  }
 
   /**
    * The primary key of the model, in camelCase.
@@ -1107,6 +1159,7 @@ class Bone {
       Reflect.deleteProperty(this.prototype, originalName);
       this.loadAttribute(newName);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -1116,15 +1169,16 @@ class Bone {
    * @param {string} [opts.className]
    * @param {string} [opts.foreignKey]
    */
-  static hasOne(name, opts) {
-    opts = Object.assign({
+  static hasOne(name, options) {
+    options = ({
       className: capitalize(name),
-      foreignKey: this.table + 'Id',
-    }, opts);
+      foreignKey: camelCase(`${this.name}Id`),
+      ...options,
+    });
 
-    if (opts.through) opts.foreignKey = '';
+    if (options.through) options.foreignKey = '';
 
-    this.associate(name, opts);
+    this.associate(name, options);
   }
 
   /**
@@ -1134,16 +1188,17 @@ class Bone {
    * @param {string} [opts.className]
    * @param {string} [opts.foreignKey]
    */
-  static hasMany(name, opts) {
-    opts = Object.assign({
+  static hasMany(name, options) {
+    options = {
       className: capitalize(pluralize(name, 1)),
-    }, opts, {
+      foreignKey: camelCase(`${this.name}Id`),
+      ...options,
       hasMany: true,
-    });
+    };
 
-    if (opts.through) opts.foreignKey = '';
+    if (options.through) options.foreignKey = '';
 
-    this.associate(name, opts);
+    this.associate(name, options);
   }
 
   /**
@@ -1153,15 +1208,15 @@ class Bone {
    * @param {string} [opts.className]
    * @param {string} [opts.foreignKey]
    */
-  static belongsTo(name, opts) {
-    opts = Object.assign({
-      className: capitalize(name),
-    }, opts);
-
-    let { className, foreignKey } = opts;
-    if (!foreignKey) foreignKey = camelCase(className) + 'Id';
+  static belongsTo(name, options = {}) {
+    const { className = capitalize(name) } = options;
+    options = {
+      className,
+      foreignKey: camelCase(`${className}Id`),
+      ...options,
+    };
 
-    this.associate(name, Object.assign(opts, { foreignKey, belongsTo: true }));
+    this.associate(name, { ...options, belongsTo: true });
   }
 
   /**
@@ -1181,6 +1236,9 @@ class Bone {
     const { className } = opts;
     const Model = this.models[className];
     if (!Model) throw new Error(`unable to find model "${className}"`);
+    if (opts.foreignKey && Model.attributes[opts.foreignKey] && Model.attributes[opts.foreignKey].virtual) {
+      throw new Error(`unable to use virtual attribute ${opts.foreignKey} as foreign key in model ${Model.name}`);
+    }
 
     const { deletedAt } = this.timestamps;
     if (Model.attributes[deletedAt] && !opts.where) {
@@ -1559,6 +1617,7 @@ class Bone {
       return result;
     }, {});
 
+    this[columnAttributesKey] = null;
     Object.defineProperties(this, looseReadonly({ ...hookMethods, attributes, table }));
   }
 
@@ -1578,7 +1637,7 @@ class Bone {
       throw new Error('unable to sync model with custom physic tables');
     }
 
-    const { attributes, columns } = this;
+    const { columnAttributes: attributes, columns } = this;
     const columnMap = columns.reduce((result, entry) => {
       result[entry.columnName] = entry;
       return result;

package/src/collection.js

@@ -63,14 +63,14 @@ class Collection extends Array {
  */
 function instantiatable(spell) {
   const { columns, groups, Model } = spell;
-  const { attributes, tableAlias } = Model;
+  const { columnAttributes, tableAlias } = Model;
 
   if (groups.length > 0) return false;
   if (columns.length === 0) return true;
 
   return columns
     .filter(({ qualifiers }) => (!qualifiers || qualifiers.includes(tableAlias)))
-    .every(({ value }) => attributes[value]);
+    .every(({ value }) => columnAttributes[value]);
 }
 
 /**

package/src/constants.js

@@ -22,9 +22,16 @@ const LEGACY_TIMESTAMP_COLUMN_MAP = {
 
 const TIMESTAMP_NAMES = [ 'createdAt', 'updatedAt', 'deletedAt' ];
 
+const ASSOCIATE_METADATA_MAP = {
+  hasMany: Symbol('hasMany'),
+  hasOne: Symbol('hasOne'),
+  belongsTo: Symbol('belongsTo'),
+};
+
 module.exports = {
   AGGREGATOR_MAP,
   LEGACY_TIMESTAMP_MAP,
   TIMESTAMP_NAMES,
-  LEGACY_TIMESTAMP_COLUMN_MAP
+  LEGACY_TIMESTAMP_COLUMN_MAP,
+  ASSOCIATE_METADATA_MAP
 };

package/src/data_types.js

@@ -475,6 +475,18 @@ class JSONB extends JSON {
   }
 }
 
+class VIRTUAL extends DataType {
+  constructor() {
+    super();
+    this.dataType = 'virtual';
+    this.virtual = true;
+  }
+
+  toSqlString() {
+    return 'VIRTUAL';
+  }
+}
+
 const DataTypes = {
   STRING,
   TINYINT,
@@ -491,6 +503,7 @@ const DataTypes = {
   JSONB,
   BINARY,
   VARBINARY,
+  VIRTUAL,
 };
 
 Object.assign(DataType, DataTypes);

package/src/decorators.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsTo = exports.HasOne = exports.HasMany = exports.Column = void 0;
+const data_types_1 = __importDefault(require("./data_types"));
+const constants_1 = require("./constants");
+require("reflect-metadata");
+function findType(tsType) {
+    const { BIGINT, INTEGER, DATE, STRING, BOOLEAN, } = data_types_1.default;
+    switch (tsType) {
+        case BigInt:
+            return BIGINT;
+        case Number:
+            return INTEGER;
+        case Date:
+            return DATE;
+        case String:
+            return STRING;
+        case Boolean:
+            return BOOLEAN;
+        default:
+            throw new Error(`unknown typescript type ${tsType}`);
+    }
+}
+function Column(options = {}) {
+    return function (target, propertyKey) {
+        if (options['prototype'] instanceof data_types_1.default)
+            options = { type: options };
+        if (!('type' in options)) {
+            const tsType = Reflect.getMetadata('design:type', target, propertyKey);
+            options['type'] = findType(tsType);
+        }
+        // narrowing the type of options to ColumnOption
+        if (!('type' in options))
+            throw new Error(`unknown column options ${options}`);
+        // target refers to model prototype, an internal instance of `Bone {}`
+        const model = target.constructor;
+        const { attributes = (model.attributes = {}) } = model;
+        const { name: columnName, ...restOptions } = options;
+        attributes[propertyKey] = { ...restOptions, columnName };
+    };
+}
+exports.Column = Column;
+const { hasMany, hasOne, belongsTo } = constants_1.ASSOCIATE_METADATA_MAP;
+function HasMany(options) {
+    return function (target, propertyKey) {
+        const model = target.constructor;
+        Reflect.defineMetadata(hasMany, {
+            ...Reflect.getMetadata(hasMany, model),
+            [propertyKey]: options,
+        }, model);
+    };
+}
+exports.HasMany = HasMany;
+function HasOne(options) {
+    return function (target, propertyKey) {
+        const model = target.constructor;
+        Reflect.defineMetadata(hasOne, {
+            ...Reflect.getMetadata(hasOne, model),
+            [propertyKey]: options,
+        }, model);
+    };
+}
+exports.HasOne = HasOne;
+function BelongsTo(options) {
+    return function (target, propertyKey) {
+        const model = target.constructor;
+        Reflect.defineMetadata(belongsTo, {
+            ...Reflect.getMetadata(belongsTo, model),
+            [propertyKey]: options,
+        }, model);
+    };
+}
+exports.BelongsTo = BelongsTo;
+//# sourceMappingURL=decorators.js.map

package/src/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["decorators.ts"],"names":[],"mappings":"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"}

package/src/decorators.ts

@@ -0,0 +1,96 @@
+import Bone from './bone';
+import DataType from './data_types';
+import { ASSOCIATE_METADATA_MAP } from './constants';
+import 'reflect-metadata';
+
+type DataTypes<T> = {
+  [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property];
+}
+
+interface ColumnOption {
+  type?: DataTypes<DataType>;
+  name?: string;
+  defaultValue?: null | boolean | number | string | Date | JSON;
+  allowNull?: boolean;
+}
+
+function findType(tsType) {
+  const {
+    BIGINT, INTEGER,
+    DATE,
+    STRING,
+    BOOLEAN,
+  } = DataType;
+
+  switch (tsType) {
+    case BigInt:
+      return BIGINT;
+    case Number:
+      return INTEGER;
+    case Date:
+      return DATE;
+    case String:
+      return STRING;
+    case Boolean:
+      return BOOLEAN;
+    default:
+      throw new Error(`unknown typescript type ${tsType}`);
+  }
+}
+
+export function Column(options: ColumnOption | DataTypes<DataType> = {}) {
+  return function(target: Bone, propertyKey: string) {
+    if (options['prototype'] instanceof DataType) options = { type: options };
+
+    if (!('type' in options)) {
+      const tsType = Reflect.getMetadata('design:type', target, propertyKey);
+      options['type'] = findType(tsType);
+    }
+
+    // narrowing the type of options to ColumnOption
+    if (!('type' in options)) throw new Error(`unknown column options ${options}`);
+
+    // target refers to model prototype, an internal instance of `Bone {}`
+    const model = target.constructor;
+    const { attributes = (model.attributes = {}) } = model;
+    const { name: columnName, ...restOptions } = options;
+    attributes[propertyKey] = { ...restOptions, columnName };
+  };
+}
+
+interface AssociateOptions {
+  className?: string;
+  foreignKey?: string;
+}
+
+const { hasMany, hasOne, belongsTo } = ASSOCIATE_METADATA_MAP;
+
+export function HasMany(options?: AssociateOptions) {
+  return function(target: Bone, propertyKey: string) {
+    const model = target.constructor;
+    Reflect.defineMetadata(hasMany, {
+      ...Reflect.getMetadata(hasMany, model),
+      [propertyKey]: options,
+    }, model);
+  }
+}
+
+export function HasOne(options?: AssociateOptions) {
+  return function(target: Bone, propertyKey: string) {
+    const model = target.constructor;
+    Reflect.defineMetadata(hasOne, {
+      ...Reflect.getMetadata(hasOne, model),
+      [propertyKey]: options,
+    }, model);
+  }
+}
+
+export function BelongsTo(options?: AssociateOptions) {
+  return function(target: Bone, propertyKey: string) {
+    const model = target.constructor;
+    Reflect.defineMetadata(belongsTo, {
+      ...Reflect.getMetadata(belongsTo, model),
+      [propertyKey]: options,
+    }, model);
+  }
+}

package/src/drivers/abstract/attribute.js

@@ -9,6 +9,7 @@ const { snakeCase } = require('../../utils/string');
  * @param {string} dataType
  */
 function findJsType(DataTypes, type, dataType) {
+  if (type instanceof DataTypes.VIRTUAL) return '';
   if (type instanceof DataTypes.BOOLEAN) return Boolean;
   if (type instanceof DataTypes.JSON) return JSON;
   if (type instanceof DataTypes.BINARY || type instanceof DataTypes.BLOB) {
@@ -99,17 +100,26 @@ class Attribute {
     }
     const type = createType(DataTypes, params);
     const dataType = params.dataType || type.dataType;
+    let { defaultValue = null } = params;
+    try {
+      // normalize column defaults like `'0'` or `CURRENT_TIMESTAMP`
+      defaultValue = type.cast(type.uncast(defaultValue));
+    } catch {
+      defaultValue = null;
+    }
+
     Object.assign(this, {
       name,
-      columnName,
       primaryKey: false,
-      defaultValue: null,
       allowNull: !params.primaryKey,
-      columnType: type.toSqlString().toLowerCase(),
       ...params,
+      columnName: params.columnName || columnName,
+      columnType: type.toSqlString().toLowerCase(),
       type,
+      defaultValue,
       dataType,
       jsType: findJsType(DataTypes, type, dataType),
+      virtual: type.virtual,
     });
   }
 

package/src/drivers/abstract/spellbook.js

@@ -146,7 +146,7 @@ function qualify(spell) {
   const baseName = Model.tableAlias;
   const clarify = node => {
     if (node.type === 'id' && !node.qualifiers) {
-      if (Model.attributes[node.value]) node.qualifiers = [baseName];
+      if (Model.columnAttributes[node.value]) node.qualifiers = [baseName];
     }
   };
 
@@ -335,7 +335,7 @@ function formatDelete(spell) {
  * @param {Spell} spell
  */
 function formatInsert(spell) {
-  const { Model, sets, attributes: optAttrs, updateOnDuplicate } = spell;
+  const { Model, sets, columnAttributes: optAttrs, updateOnDuplicate } = spell;
   const { shardingKey } = Model;
   const { createdAt } = Model.timestamps;
   const { escapeId } = Model.driver;
@@ -345,22 +345,22 @@ function formatInsert(spell) {
   let values = [];
   let placeholders = [];
   if (Array.isArray(sets)) {
-    // merge records to get the big picture of involved attributes
+    // merge records to get the big picture of involved columnAttributes
     const involved = sets.reduce((result, entry) => {
       return Object.assign(result, entry);
     }, {});
-    const attributes = [];
+    const columnAttributes = [];
     if (optAttrs) {
       for (const name in optAttrs) {
-        if (involved.hasOwnProperty(name)) attributes.push(attributes[name]);
+        if (involved.hasOwnProperty(name)) columnAttributes.push(columnAttributes[name]);
       }
     } else {
       for (const name in involved) {
-        attributes.push(Model.attributes[name]);
+        columnAttributes.push(Model.columnAttributes[name]);
       }
     }
 
-    for (const entry of attributes) {
+    for (const entry of columnAttributes) {
       columns.push(entry.columnName);
       if (updateOnDuplicate && createdAt && entry.name === createdAt 
         && !(Array.isArray(updateOnDuplicate) && updateOnDuplicate.includes(createdAt))) continue;
@@ -371,11 +371,11 @@ function formatInsert(spell) {
       if (shardingKey && entry[shardingKey] == null) {
         throw new Error(`Sharding key ${Model.table}.${shardingKey} cannot be NULL.`);
       }
-      for (const attribute of attributes) {
+      for (const attribute of columnAttributes) {
         const { name } = attribute;
         values.push(entry[name]);
       }
-      placeholders.push(`(${new Array(attributes.length).fill('?').join(',')})`);
+      placeholders.push(`(${new Array(columnAttributes.length).fill('?').join(',')})`);
     }
 
   } else {
@@ -488,7 +488,7 @@ function formatUpdate(spell) {
 function formatUpdateOnDuplicate(spell, columns) {
   const { updateOnDuplicate, uniqueKeys, Model } = spell;
   if (!updateOnDuplicate) return '';
-  const { attributes, primaryColumn } = Model;
+  const { columnAttributes, primaryColumn } = Model;
   const { escapeId } = Model.driver;
   const actualUniqueKeys = [];
 
@@ -499,9 +499,9 @@ function formatUpdateOnDuplicate(spell, columns) {
   } else {
     // conflict_target must be unique
     // get all unique keys
-    if (attributes) {
-      for (const key in attributes) {
-        const att = attributes[key];
+    if (columnAttributes) {
+      for (const key in columnAttributes) {
+        const att = columnAttributes[key];
         // use the first unique key
         if (att.unique) {
           actualUniqueKeys.push(escapeId(att.columnName));
@@ -515,9 +515,9 @@ function formatUpdateOnDuplicate(spell, columns) {
   }
 
   if (Array.isArray(updateOnDuplicate) && updateOnDuplicate.length) {
-    columns = updateOnDuplicate.map(column => (attributes[column] && attributes[column].columnName )|| column);
+    columns = updateOnDuplicate.map(column => (columnAttributes[column] && columnAttributes[column].columnName )|| column);
   } else if (!columns.length) {
-    columns = Object.values(attributes).map(({ columnName }) => columnName);
+    columns = Object.values(columnAttributes).map(({ columnName }) => columnName);
   }
   const updateKeys = columns.map((column) => `${escapeId(column)}=EXCLUDED.${escapeId(column)}`);
 

package/src/drivers/mysql/index.js

@@ -99,8 +99,8 @@ class MysqlDriver extends AbstractDriver {
       if (!opts.connection) connection.release();
     }
 
-    logger.tryLogQuery(sql, calculateDuration(start), opts);
     const [ results, fields ] = result;
+    logger.tryLogQuery(sql, calculateDuration(start), opts, results);
     if (fields) return { rows: results, fields };
     return results;
   }

package/src/drivers/mysql/spellbook.js

@@ -37,19 +37,19 @@ module.exports = {
     const { updateOnDuplicate, Model } = spell;
     if (!updateOnDuplicate) return null;
     const { escapeId } = Model.driver;
-    const { attributes, primaryColumn } = Model;
+    const { columnAttributes, primaryColumn } = Model;
 
     if (Array.isArray(updateOnDuplicate) && updateOnDuplicate.length) {
-      columns = updateOnDuplicate.map(column => (attributes[column] && attributes[column].columnName ) || column)
+      columns = updateOnDuplicate.map(column => (columnAttributes[column] && columnAttributes[column].columnName ) || column)
         .filter(column => column !== primaryColumn);
     } else if (!columns.length) {
-      columns = Object.values(attributes).map(attribute => attribute.columnName).filter(column => column !== primaryColumn);
+      columns = Object.values(columnAttributes).map(attribute => attribute.columnName).filter(column => column !== primaryColumn);
     }
 
     const sets = [];
     // Make sure the correct LAST_INSERT_ID is returned.
     // - https://stackoverflow.com/questions/778534/mysql-on-duplicate-key-last-insert-id
-    // if insert attributes include primary column, `primaryKey = LAST_INSERT_ID(primaryKey)` is not need any more
+    // if insert columnAttributes include primary column, `primaryKey = LAST_INSERT_ID(primaryKey)` is not need any more
     if (!columns.includes(primaryColumn)) {
       sets.push(`${escapeId(primaryColumn)} = LAST_INSERT_ID(${escapeId(primaryColumn)})`);
     }

package/src/drivers/postgres/index.js

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

package/src/drivers/sqlite/index.js

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

package/src/drivers/sqlite/spellbook.js

@@ -8,7 +8,7 @@ function renameSelectExpr(spell) {
 
   for (const token of columns) {
     if (token.type == 'id') {
-      if (!token.qualifiers && Model.attributes[token.value]) {
+      if (!token.qualifiers && Model.columnAttributes[token.value]) {
         token.qualifiers = [Model.tableAlias];
       }
       whitelist.add(token.qualifiers[0]);

package/src/expr_formatter.js

@@ -203,6 +203,9 @@ function coerceLiteral(spell, ast) {
   const attribute = model && model.attributes[firstArg.value];
 
   if (!attribute) return;
+  if (attribute.virtual) {
+    throw new Error(`unable to use virtual attribute ${attribute.name} in model ${model.name}`);
+  }
 
   for (const arg of args.slice(1)) {
     if (arg.type === 'literal') {

package/src/realm.js

@@ -75,7 +75,7 @@ async function loadModels(Spine, models, opts) {
   const schemaInfo = await Spine.driver.querySchemaInfo(database, tables);
 
   for (const model of models) {
-    const columns = schemaInfo[model.physicTable];
+    const columns = schemaInfo[model.physicTable] || schemaInfo[model.table];
     if (!model.attributes) initAttributes(model, columns);
     model.load(columns);
     Spine.models[model.name] = model;

package/src/setup_hooks.js

@@ -129,9 +129,28 @@ function addHook(target, hookName, func) {
       if (useHooks && type === hookType.BEFORE) {
         // this.change(key) or this.attributeChanged(key) should work at before update
         if (method === 'update' && typeof arguments[0] === 'object' && !arguments[0] != null) {
-          for (const name in arguments[0]) this[name] = arguments[0][name];
+          const values = arguments[0];
+          const fields = arguments[1] && arguments[1].fields && arguments[1].fields.length? arguments[1].fields : [];
+          const originalRaw = {};
+          const changeRaw = {};
+          for (const name in values) {
+            if ((!fields.length || fields.includes(name)) && this.hasAttribute(name)) {
+              originalRaw[name] = this.attribute(name);
+              this[name] = values[name];
+              changeRaw[name] = this.attribute(name);
+            }
+          }
+          await func.apply(this, args);
+          // revert instance after before hooks
+          Object.keys(originalRaw).forEach((key) => {
+            const current = this.attribute(key);
+            // raw[key] may changed in beforeUpdate hooks
+            if (current !== originalRaw[key] && current !== changeRaw[key]) return;
+            this.attribute(key, originalRaw[key]);
+          });
+        } else {
+          await func.apply(this, args);
         }
-        await func.apply(this, args);
       }
       const res = await instanceOriginFunc.call(this, ...arguments);
       if (useHooks && type === hookType.AFTER) {

package/src/spell.js

@@ -13,30 +13,53 @@ const { parseObject } = require('./query_object');
 const Raw = require('./raw');
 const { AGGREGATOR_MAP } = require('./constants');
 
+/**
+ * check condition to avoid use virtual fields as where condtions
+ * @param {Bone} Model 
+ * @param {Array<Object>} conds 
+ */
+function checkCond(Model, conds) {
+  if (Array.isArray(conds)) {
+    for (const cond of conds) {
+      if (cond.type === 'id' && cond.value != null) {
+        if (Model.attributes[cond.value] && Model.attributes[cond.value].virtual) {
+          throw new Error(`unable to use virtual attribute ${cond.value} as condition in model ${Model.name}`);
+        }
+      } else if (cond.type === 'op' && cond.args && cond.args.length) {
+        checkCond(Model, cond.args);
+      }
+    }
+  }
+}
+
 /**
  * Parse condition expressions
  * @example
- * parseConditions({ foo: { $op: value } });
- * parseConditions('foo = ?', value);
+ * parseConditions(Model, { foo: { $op: value } });
+ * parseConditions(Model, 'foo = ?', value);
+ * @param {Bone} Model
  * @param {(string|Object)} conditions
  * @param {...*} values
  * @returns {Array}
  */
-function parseConditions(conditions, ...values) {
+function parseConditions(Model, conditions, ...values) {
   if (conditions instanceof Raw) return [ conditions ];
+  let conds;
   if (isPlainObject(conditions)) {
-    return parseObject(conditions);
+    conds = parseObject(conditions);
   } else if (typeof conditions == 'string') {
-    return [parseExpr(conditions, ...values)];
+    conds = [parseExpr(conditions, ...values)];
   } else {
     throw new Error(`unexpected conditions ${conditions}`);
   }
+  checkCond(Model, conds);
+  return conds;
 }
 
 function parseSelect(spell, ...names) {
   const { joins, Model } = spell;
   if (typeof names[0] === 'function') {
-    names = Object.keys(Model.attributes).filter(names[0]);
+    names = Object.keys(Model.columnAttributes).filter(names[0]);
   } else {
     names = names.reduce((result, name) => result.concat(name), []);
   }
@@ -53,7 +76,10 @@ function parseSelect(spell, ...names) {
       if (type != 'id') return;
       const qualifier = qualifiers && qualifiers[0];
       const model = qualifier && joins && (qualifier in joins) ? joins[qualifier].Model : Model;
-      if (!model.attributes[value]) {
+      if (!model.columnAttributes[value]) {
+        if (model.attributes[value]) {
+          throw new Error(`unable to use virtual attribute ${value} as field in model ${model.name}`);
+        }
         throw new Error(`unable to find attribute ${value} in model ${model.name}`);
       }
     });
@@ -63,9 +89,9 @@ function parseSelect(spell, ...names) {
 }
 
 /**
- * Translate key-value pairs of attributes into key-value pairs of columns. Get ready for the SET part when generating SQL.
+ * Translate key-value pairs of columnAttributes into key-value pairs of columns. Get ready for the SET part when generating SQL.
  * @param {Spell} spell
- * @param {Object} obj - key-value pairs of attributes
+ * @param {Object} obj - key-value pairs of columnAttributes
  * @param {boolean} strict - check attribute exist or not
  * @returns {Object}
  */
@@ -73,11 +99,11 @@ function formatValueSet(spell, obj, strict = true) {
   const { Model } = spell;
   const sets = {};
   for (const name in obj) {
-    const attribute = Model.attributes[name];
+    const attribute = Model.columnAttributes[name];
     const value = obj[name];
 
-    if (!attribute && strict) {
-      throw new Error(`Undefined attribute "${name}"`);
+    if (!attribute) {
+      continue;
     }
 
     // raw sql don't need to uncast
@@ -91,9 +117,9 @@ function formatValueSet(spell, obj, strict = true) {
 }
 
 /**
- * Translate key-value pairs of attributes into key-value pairs of columns. Get ready for the SET part when generating SQL.
+ * Translate key-value pairs of columnAttributes into key-value pairs of columns. Get ready for the SET part when generating SQL.
  * @param {Spell}  spell
- * @param {Object|Array} obj   - key-value pairs of attributes
+ * @param {Object|Array} obj   - key-value pairs of columnAttributes
  */
 function parseSet(spell, obj) {
   let sets;
@@ -139,7 +165,7 @@ function joinOnConditions(spell, BaseModel, baseName, refName, { where, associat
   };
   if (!where) where = association.where;
   if (where) {
-    const whereConditions = walkExpr(parseConditions(where)[0], node => {
+    const whereConditions = walkExpr(parseConditions(BaseModel, where)[0], node => {
       if (node.type == 'id') node.qualifiers = [refName];
     });
     return { type: 'op', name: 'and', args: [ onConditions, whereConditions ] };
@@ -212,7 +238,7 @@ function joinAssociation(spell, BaseModel, baseName, refName, opts = {}) {
     const columns = parseSelect({ Model: RefModel }, select);
     for (const token of columns) {
       walkExpr(token, node => {
-        if (node.type === 'id' && !node.qualifiers && RefModel.attributes[node.value]) {
+        if (node.type === 'id' && !node.qualifiers && RefModel.columnAttributes[node.value]) {
           node.qualifiers = [refName];
         }
       });
@@ -284,7 +310,7 @@ class Spell {
   /**
    * Create a spell.
    * @param {Model}          Model    - A sub class of {@link Bone}.
-   * @param {Object}         opts     - Extra attributes to be set.
+   * @param {Object}         opts     - Extra columnAttributes to be set.
    */
   constructor(Model, opts = {}) {
     if (Model.synchronized == null) {
@@ -299,7 +325,7 @@ class Spell {
 
     const { deletedAt } = Model.timestamps;
     // FIXME: need to implement paranoid mode
-    if (Model.attributes[deletedAt] && opts.paranoid !== false) {
+    if (Model.columnAttributes[deletedAt] && opts.paranoid !== false) {
       scopes.push(scopeDeletedAt);
     }
 
@@ -502,7 +528,7 @@ class Spell {
   }
 
   /**
-   * Whitelist attributes to select. Can be called repeatedly to select more attributes.
+   * Whitelist columnAttributes to select. Can be called repeatedly to select more columnAttributes.
    * @param {...string} names
    * @example
    * .select('title');
@@ -531,7 +557,7 @@ class Spell {
     const { timestamps } = Model;
     this.command = 'update';
     if (!Number.isFinite(by)) throw new Error(`unexpected increment value ${by}`);
-    if (!Model.attributes.hasOwnProperty(name)) {
+    if (!Model.columnAttributes.hasOwnProperty(name)) {
       throw new Error(`undefined attribute "${name}"`);
     }
 
@@ -590,7 +616,8 @@ class Spell {
    * @returns {Spell}
    */
   $where(conditions, ...values) {
-    this.whereConditions.push(...parseConditions(conditions, ...values));
+    const Model = this.Model;
+    this.whereConditions.push(...parseConditions(Model, conditions, ...values));
     return this;
   }
 
@@ -600,15 +627,16 @@ class Spell {
     const combined = whereConditions.slice(1).reduce((result, condition) => {
       return { type: 'op', name: 'and', args: [result, condition] };
     }, whereConditions[0]);
+    const Model = this.Model;
     this.whereConditions = [
       { type: 'op', name: 'or', args:
-        [combined, ...parseConditions(conditions, ...values)] }
+        [combined, ...parseConditions(Model, conditions, ...values)] }
     ];
     return this;
   }
 
   /**
-   * Set GROUP BY attributes. `select_expr` with `AS` is supported, hence following expressions have the same effect:
+   * Set GROUP BY columnAttributes. `select_expr` with `AS` is supported, hence following expressions have the same effect:
    *
    *     .select('YEAR(createdAt)) AS year').group('year');
    *
@@ -619,9 +647,12 @@ class Spell {
    * @returns {Spell}
    */
   $group(...names) {
-    const { columns, groups } = this;
+    const { columns, groups, Model } = this;
 
     for (const name of names) {
+      if (Model.attributes[name] && Model.attributes[name].virtual) {
+        throw new Error(`unable to use virtual attribute ${name} as group column in model ${Model.name}`);
+      }
       const token = parseExpr(name);
       if (token.type === 'alias') {
         groups.push({ type: 'id', value: token.value });
@@ -666,10 +697,12 @@ class Spell {
       });
     }
     else {
-      this.orders.push([
+      const order = [
         parseExpr(name),
         direction && direction.toLowerCase() == 'desc' ? 'desc' : 'asc'
-      ]);
+      ];
+      checkCond(this.Model, order);
+      this.orders.push(order);
     }
     return this;
   }
@@ -710,10 +743,11 @@ class Spell {
    * @returns {Spell}
    */
   $having(conditions, ...values) {
-    for (const condition of parseConditions(conditions, ...values)) {
+    const Model = this.Model;
+    for (const condition of parseConditions(Model, 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 instanceof Raw)) {
+      if (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') {
@@ -784,7 +818,7 @@ class Spell {
     if (qualifier in joins) {
       throw new Error(`invalid join target. ${qualifier} already defined.`);
     }
-    joins[qualifier] = { Model, on: parseConditions(onConditions, ...values)[0] };
+    joins[qualifier] = { Model, on: parseConditions(Model, onConditions, ...values)[0] };
     return this;
   }
 

package/types/data_types.d.ts

@@ -20,6 +20,8 @@ export default class DataType {
   static DATE: typeof DATE & INVOKABLE<DATE>;
   static DATEONLY: typeof DATEONLY & INVOKABLE<DATEONLY>;
   static BOOLEAN: typeof BOOLEAN & INVOKABLE<BOOLEAN>;
+  static VIRTUAL: typeof VIRTUAL & INVOKABLE<VIRTUAL>;
+
 }
 
 declare class STRING extends DataType {
@@ -86,3 +88,7 @@ declare class DATEONLY extends DataType {
 declare class BOOLEAN extends DataType {
   dataType: 'boolean'
 }
+
+declare class VIRTUAL extends DataType {
+  dataType: 'virtual'
+}

package/types/index.d.ts

@@ -1,6 +1,7 @@
 import DataType from './data_types';
 
 export { DataType as DataTypes };
+export * from '../src/decorators';
 
 type DataTypes<T> = {
   [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property]
@@ -129,26 +130,27 @@ type OperatorCondition = {
 };
 
 type WhereConditions<T extends typeof Bone> = {
-  [Property in keyof T['attributes']]?: Literal | Literal[] | OperatorCondition;
+  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal | Literal[] | OperatorCondition;
 }
 
 type Values<T extends typeof Bone> = {
-  [Property in keyof T['attributes']]?: Literal;
+  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal;
 }
 
 type InstanceValues<T> = {
   [Property in keyof Extract<T, Literal>]?: Extract<T, Literal>[Property]
 }
 
-interface AttributeMeta {
-  column?: string;
+export interface AttributeMeta {
+  columnName?: string;
   columnType?: string;
   allowNull?: boolean;
   defaultValue?: Literal;
   primaryKey?: boolean;
   dataType?: string;
   jsType?: Literal;
-  type: DataTypes<DataType>;
+  type: DataType;
+  toSqlString: () => string;
 }
 
 interface RelateOptions {
@@ -233,7 +235,7 @@ export class Bone {
   /**
    * The connected models structured as `{ [model.name]: model }`, e.g. `Bone.model.Post => Post`
    */
-  static model: { [key: string]: Bone };
+  static models: { [key: string]: typeof Bone };
 
   /**
    * The table name of the model, which needs to be specified by the model subclass.
@@ -468,10 +470,13 @@ export class Bone {
    */
   static truncate(): Promise<void>;
 
+  static sync(options: SyncOptions): Promise<void>;
+
+  static initialize(): void;
+
   constructor(values: { [key: string]: Literal });
 
   /**
-   * Get or set attribute value. Getting the value of unset attribute gives an error.
    * @example
    * bone.attribute('foo');     // => 1
    * bone.attribute('foo', 2);  // => bone
@@ -601,6 +606,7 @@ export interface ConnectOptions {
   user?: string;
   password?: string;
   database: string;
+  charset?: string;
   models?: string | (typeof Bone)[];
   subclass?: boolean;
 }