leoric 2.2.2 → 2.3.1

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) {
@@ -65,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':
@@ -72,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();
@@ -99,17 +104,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/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/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/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/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/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/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/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/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/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/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/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) {