leoric 2.3.0 → 2.3.1

package/History.md

@@ -1,3 +1,16 @@
+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
 ==================
 

package/package.json

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

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

@@ -37,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] = {
@@ -50,6 +52,12 @@ function compare(attributes, columnMap) {
     }
   }
 
+  for (const columnName in columnMap) {
+    if (!columnNames.has(columnName)) {
+      diff[columnName] = { remove: true };
+    }
+  }
+
   return diff;
 }
 
@@ -254,8 +262,8 @@ class Bone {
 
   /**
    * get actual update/insert columns to avoid empty insert or update
-   * @param {Object} data 
-   * @returns 
+   * @param {Object} data
+   * @returns
    */
   static _getColumns(data) {
     if (!Object.keys(data).length) return data;
@@ -573,7 +581,14 @@ class Bone {
     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 (this.#rawPrevious[name] === undefined && this.#raw[name] != null) {

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 {
@@ -494,6 +533,7 @@ const DataTypes = {
   MEDIUMINT,
   INTEGER,
   BIGINT,
+  DECIMAL,
   DATE,
   DATEONLY,
   BOOLEAN,

package/src/drivers/abstract/attribute.js

@@ -66,6 +66,8 @@ function createType(DataTypes, params) {
   switch (type.constructor.name) {
     case 'DATE':
       return new DataType(type.precision, type.timezone);
+    case 'DECIMAL':
+      return new DataType(type.precision, type.scale);
     case 'TINYINT':
     case 'SMALLINT':
     case 'MEDIUMINT':
@@ -73,6 +75,8 @@ function createType(DataTypes, params) {
     case 'BIGINT':
     case 'BINARY':
     case 'VARBINARY':
+    case 'CHAR':
+    case 'VARCHAR':
       return new DataType(type.length);
     default:
       return new DataType();

package/src/drivers/abstract/schema.js

@@ -19,9 +19,12 @@ module.exports = {
     const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
 
     const actions = Object.keys(attributes).map(name => {
-      const attribute = new Attribute(name, attributes[name]);
+      const options = attributes[name];
+      // { [columnName]: { remove: true } }
+      if (options.remove) return `DROP COLUMN ${escapeId(name)}`;
+      const attribute = new Attribute(name, options);
       return [
-        attribute.modify ? 'MODIFY COLUMN' : 'ADD COLUMN',
+        options.modify ? 'MODIFY COLUMN' : 'ADD COLUMN',
         attribute.toSqlString(),
       ].join(' ');
     });

package/src/drivers/mysql/attribute.js

@@ -15,8 +15,13 @@ class MysqlAttribute extends Attribute {
   }
 
   toSqlString() {
-    const { allowNull, defaultValue, primaryKey } = this;
-    const { columnName, type, columnType } = this;
+    const {
+      columnName,
+      type, columnType,
+      allowNull, defaultValue,
+      primaryKey,
+      comment,
+    } = this;
 
     const chunks = [
       escapeId(columnName),
@@ -33,6 +38,10 @@ class MysqlAttribute extends Attribute {
       chunks.push(`DEFAULT ${escape(defaultValue)}`);
     }
 
+    if (typeof comment === 'string') {
+      chunks.push(`COMMENT ${escape(comment)}`);
+    }
+
     return chunks.join(' ');
   }
 }

package/src/drivers/mysql/schema.js

@@ -38,7 +38,7 @@ module.exports = {
       columns.push({
         columnName: row.column_name,
         columnType: row.column_type,
-        columnComment: row.column_comment,
+        comment: row.column_comment,
         defaultValue: row.column_default,
         dataType: row.data_type,
         allowNull: row.is_nullable === 'YES',

package/src/drivers/postgres/schema.js

@@ -28,6 +28,10 @@ function formatAddColumn(driver, columnName, attribute) {
   return `ADD COLUMN ${attribute.toSqlString()}`;
 }
 
+function formatDropColumn(driver, columnName) {
+  return `DROP COLUMN ${driver.escapeId(columnName)}`;
+}
+
 module.exports = {
   ...schema,
 
@@ -85,7 +89,9 @@ module.exports = {
     const { escapeId } = this;
     const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
     const actions = Object.keys(changes).map(name => {
-      const attribute = new Attribute(name, changes[name]);
+      const options = changes[name];
+      if (options.remove) return formatDropColumn(this, name);
+      const attribute = new Attribute(name, options);
       const { columnName } = attribute;;
       return attribute.modify
         ? formatAlterColumns(this, columnName, attribute).join(', ')

package/src/drivers/sqlite/schema.js

@@ -108,7 +108,8 @@ module.exports = {
     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 columns = rows.map(row => {
+        const { name, type, notnull, dflt_value, pk } = row;
         const columnType = type.toLowerCase();
         const [, dataType, precision ] = columnType.match(rColumnType);
         const primaryKey = pk === 1;
@@ -145,6 +146,8 @@ module.exports = {
     const { escapeId } = this;
     const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
     const attributes = Object.keys(changes).map(name => {
+      const options = changes[name];
+      if (options.remove) return { columnName: name, remove: true };
       return new Attribute(name, changes[name]);
     });
 
@@ -157,7 +160,12 @@ module.exports = {
     // SQLite can only add one column a time
     // - https://www.sqlite.org/lang_altertable.html
     for (const attribute of attributes) {
-      await this.query(chunks.concat(`ADD COLUMN ${attribute.toSqlString()}`).join(' '));
+      if (attribute.remove) {
+        const { columnName } = attribute;
+        await this.query(chunks.concat(`DROP COLUMN ${this.escapeId(columnName)}`).join(' '));
+      } else {
+        await this.query(chunks.concat(`ADD COLUMN ${attribute.toSqlString()}`).join(' '));
+      }
     }
   },
 

package/types/data_types.d.ts

@@ -11,6 +11,7 @@ export default class DataType {
   static STRING: typeof STRING & INVOKABLE<STRING>;
   static INTEGER: typeof INTEGER & INVOKABLE<INTEGER>;
   static BIGINT: typeof BIGINT & INVOKABLE<BIGINT>;
+  static DECIMAL: typeof DECIMAL & INVOKABLE<DECIMAL>;
   static TEXT: typeof TEXT & INVOKABLE<TEXT>;
   static BLOB: typeof BLOB & INVOKABLE<BLOB>;
   static JSON: typeof JSON & INVOKABLE<JSON>;
@@ -31,7 +32,7 @@ declare class STRING extends DataType {
 }
 
 declare class INTEGER extends DataType {
-  dataType: 'integer' | 'bigint';
+  dataType: 'integer' | 'bigint' | 'decimal';
   length: number;
   constructor(length: number);
   get UNSIGNED(): this;
@@ -42,6 +43,13 @@ declare class BIGINT extends INTEGER {
   dataType: 'bigint';
 }
 
+declare class DECIMAL extends INTEGER {
+  dataType: 'decimal';
+  precision: number;
+  scale: number;
+  constructor(precision: number, scale: number);
+}
+
 declare class TEXT extends DataType {
   dataType: 'text';
   length: LENGTH_VARIANTS;