leoric 2.2.2 → 2.3.1

package/History.md

@@ -1,3 +1,34 @@
+2.3.1 / 2022-03-22
+==================
+
+## What's Changed
+* fix: mysql2 Invalid Date compatible by @JimmyDaddy in https://github.com/cyjake/leoric/pull/291
+* fix: order by raw in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/292
+* fix: bulk update query conditions duplicated in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/293
+* fix: bulk destroy query conditions duplicated in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/295
+* fix: drop column if not defined in attributes when alter table by @cyjake in https://github.com/cyjake/leoric/pull/296
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.3.0...v2.3.1
+
+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
 ==================
 

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.2",
+  "version": "2.3.1",
   "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/adapters/sequelize.js

@@ -2,6 +2,7 @@
 
 const { setupSingleHook } = require('../setup_hooks');
 const { compose, isPlainObject } = require('../utils');
+const Raw = require('../raw');
 
 function translateOptions(spell, options) {
   const { attributes, where, group, order, offset, limit, include, having } = options;
@@ -18,7 +19,7 @@ function translateOptions(spell, options) {
   if (having) spell.$having(having);
 
   if (order) {
-    if (typeof order === 'string') {
+    if (typeof order === 'string' || order instanceof Raw) {
       spell.$order(order);
     } else if (Array.isArray(order) && order.length) {
       if (order.some(item => Array.isArray(item))) {
@@ -317,10 +318,12 @@ module.exports = Bone => {
     }
 
     // proxy to class.destroy({ individualHooks=false }) see https://github.com/sequelize/sequelize/blob/4063c2ab627ad57919d5b45cc7755f077a69fa5e/lib/model.js#L2895  before(after)BulkDestroy
-    static async bulkDestroy(options = {}) {
+    static bulkDestroy(options = {}) {
       const { where, force } = options;
       const spell = this._remove(where || {}, force, { ...options });
-      translateOptions(spell, options);
+      const transOptions = { ...options };
+      delete transOptions.where;
+      translateOptions(spell, transOptions);
       return spell;
     }
 
@@ -496,7 +499,9 @@ 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);
+      const transOptions = { ...options };
+      delete transOptions.where;
+      translateOptions(spell, transOptions);
       if (!paranoid) return spell.unparanoid;
       return spell;
     }

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) => {
@@ -31,10 +37,12 @@ function looseReadonly(props) {
 
 function compare(attributes, columnMap) {
   const diff = {};
+  const columnNames = new Set();
 
   for (const name in attributes) {
     const attribute = attributes[name];
     const { columnName } = attribute;
+    columnNames.add(columnName);
 
     if (!attribute.equals(columnMap[columnName])) {
       diff[name] = {
@@ -44,6 +52,12 @@ function compare(attributes, columnMap) {
     }
   }
 
+  for (const columnName in columnMap) {
+    if (!columnNames.has(columnName)) {
+      diff[columnName] = { remove: true };
+    }
+  }
+
   return diff;
 }
 
@@ -156,7 +170,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 +202,6 @@ class Bone {
     }
 
     if (this.#rawUnset.has(name)) {
-      logger.warn(`unset attribute "${name}"`);
       return;
     }
 
@@ -199,14 +211,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 +247,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 +360,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 +575,25 @@ 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]);
+      let value;
+      try {
+        value = attribute.uncast(this.#raw[name]);
+      } catch (error) {
+        console.error(error);
+        // do not interrupt sync raw
+        value = 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 +625,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 +708,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 +732,7 @@ class Bone {
       for (const key in changes) {
         this.attribute(key, changes[key]);
       }
-      this.syncRaw(changes);
+      this.syncRaw();
       return result.affectedRows;
     });
   }
@@ -730,9 +782,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 +914,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 +1038,7 @@ class Bone {
     for (const hookName of hookNames) {
       if (this[hookName]) setupSingleHook(this, hookName, this[hookName]);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -989,7 +1051,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 +1174,7 @@ class Bone {
       Reflect.deleteProperty(this.prototype, originalName);
       this.loadAttribute(newName);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -1116,15 +1184,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 +1203,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 +1223,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 +1251,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 +1632,7 @@ class Bone {
       return result;
     }, {});
 
+    this[columnAttributesKey] = null;
     Object.defineProperties(this, looseReadonly({ ...hookMethods, attributes, table }));
   }
 
@@ -1578,7 +1652,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

@@ -17,17 +17,20 @@ class DataType {
     const {
       STRING, TEXT,
       DATE, DATEONLY,
-      TINYINT, SMALLINT, MEDIUMINT, INTEGER, BIGINT,
+      TINYINT, SMALLINT, MEDIUMINT, INTEGER, BIGINT, DECIMAL,
       BOOLEAN,
       BINARY, VARBINARY, BLOB,
     } = this;
-    const [ , dataType, appendix ] = columnType.match(/(\w+)(?:\((\d+)\))?/);
-    const length = appendix && parseInt(appendix, 10);
+    const [ , dataType, ...matches ] = columnType.match(/(\w+)(?:\((\d+)(?:,(\d+))?\))?/);
+    const params = [];
+    for (let i = 0; i < matches.length; i++) {
+      if (matches[i] != null) params[i] = parseInt(matches[i], 10);
+    }
 
     switch (dataType) {
       case 'varchar':
       case 'char':
-        return new STRING(length);
+        return new STRING(...params);
       // longtext is only for MySQL
       case 'longtext':
         return new TEXT('long');
@@ -40,30 +43,31 @@ class DataType {
       case 'datetime':
       case 'timestamp':
         // new DATE(precision)
-        return new DATE(length);
+        return new DATE(...params);
       case 'decimal':
+        return new DECIMAL(...params);
       case 'int':
       case 'integer':
       case 'numeric':
-        return new INTEGER(length);
+        return new INTEGER(...params);
       case 'mediumint':
-        return new MEDIUMINT(length);
+        return new MEDIUMINT(...params);
       case 'smallint':
-        return new SMALLINT(length);
+        return new SMALLINT(...params);
       case 'tinyint':
-        return new TINYINT(length);
+        return new TINYINT(...params);
       case 'bigint':
-        return new BIGINT(length);
+        return new BIGINT(...params);
       case 'boolean':
         return new BOOLEAN();
       // mysql only
       case 'binary':
       // postgres only
       case 'bytea':
-        return new BINARY(length);
+        return new BINARY(...params);
       // mysql only
       case 'varbinary':
-        return new VARBINARY(length);
+        return new VARBINARY(...params);
       case 'longblob':
         return new BLOB('long');
       case 'mediumblob':
@@ -273,6 +277,41 @@ class BIGINT extends INTEGER {
   }
 }
 
+/**
+ * fixed-point decimal types
+ * @example
+ * DECIMAL
+ * DECIMAL.UNSIGNED
+ * DECIMAL(5, 2)
+ * @param {number} precision
+ * @param {number} scale
+ * - https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html
+ */
+class DECIMAL extends INTEGER {
+  constructor(precision, scale) {
+    super();
+    this.dataType = 'decimal';
+    this.precision = precision;
+    this.scale = scale;
+  }
+
+  toSqlString() {
+    const { precision, scale, unsigned, zerofill } = this;
+    const dataType = this.dataType.toUpperCase();
+    const chunks = [];
+    if (precision > 0 && scale >= 0) {
+      chunks.push(`${dataType}(${precision},${scale})`);
+    } else if (precision > 0) {
+      chunks.push(`${dataType}(${precision})`);
+    } else {
+      chunks.push(dataType);
+    }
+    if (unsigned) chunks.push('UNSIGNED');
+    if (zerofill) chunks.push('ZEROFILL');
+    return chunks.join(' ');
+  }
+}
+
 const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6})$/;
 
 class DATE extends DataType {
@@ -475,6 +514,18 @@ class JSONB extends JSON {
   }
 }
 
+class VIRTUAL extends DataType {
+  constructor() {
+    super();
+    this.dataType = 'virtual';
+    this.virtual = true;
+  }
+
+  toSqlString() {
+    return 'VIRTUAL';
+  }
+}
+
 const DataTypes = {
   STRING,
   TINYINT,
@@ -482,6 +533,7 @@ const DataTypes = {
   MEDIUMINT,
   INTEGER,
   BIGINT,
+  DECIMAL,
   DATE,
   DATEONLY,
   BOOLEAN,
@@ -491,6 +543,7 @@ const DataTypes = {
   JSONB,
   BINARY,
   VARBINARY,
+  VIRTUAL,
 };
 
 Object.assign(DataType, DataTypes);