leoric 2.2.3 → 2.3.2

package/History.md

@@ -1,3 +1,39 @@
+2.3.2 / 2022-04-15
+==================
+
+## What's Changed
+* fix: order by raw with mix-type array in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/298
+* docs: monthly updates and example about egg-orm usage with TypeScript by @cyjake in https://github.com/cyjake/leoric/pull/299
+* docs: monthly updates in en & docmentation about typescript support by @cyjake in https://github.com/cyjake/leoric/pull/300
+* fix: raw query should format replacements with extra blank by @JimmyDaddy in https://github.com/cyjake/leoric/pull/301
+* docs: elaborate on querying by @cyjake in https://github.com/cyjake/leoric/pull/302
+* feat: transaction should return result by @JimmyDaddy in https://github.com/cyjake/leoric/pull/303
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.3.1...v2.3.2
+
+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
 ==================
 

package/Readme.md

@@ -74,6 +74,32 @@ await realm.sync();
 
 A more detailed syntax table may be found at the [documentation](https://leoric.js.org/#syntax-table) site.
 
+## TypeScript charged
+
+```ts
+import { Bone, BelongsTo, Column, DataTypes: { TEXT } } from 'leoric';
+import User from './user';
+
+export default class Post extends Bone {
+  @Column({ autoIncrement: true })
+  id: bigint;
+
+  @Column(TEXT)
+  content: string;
+
+  @Column()
+  description: string;
+
+  @Column()
+  userId: bigint;
+
+  @BelongsTo()
+  user: User;
+}
+```
+
+More about TypeScript integration examples can be found at [the TypeScript support documentation](https://leoric.js.org/types)
+
 ## Contributing
 
 There are many ways in which you can participate in the project, for example:
@@ -89,6 +115,6 @@ If you are interested in fixing issues and contributing directly to the code bas
 - Submitting pull requests
 - Contributing to translations
 
-## Related Projects
+## egg-orm
 
-If developing web applications with [egg framework](https://eggjs.org/), it's highly recommended using the [egg-orm](https://github.com/eggjs/egg-orm) plugin.
+If developing web applications with [egg framework](https://eggjs.org/), it's highly recommended using the [egg-orm](https://github.com/eggjs/egg-orm) plugin. More detailed examples about setting up egg-orm with egg framework in either JavaScript or TypeScript can be found at <https://github.com/eggjs/egg-orm/tree/master/examples>

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.3",
+  "version": "2.3.2",
   "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"

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))) {
@@ -34,6 +35,8 @@ function translateOptions(spell, options) {
       } else if (order.length && order[0]) {
         // ['created_at', 'asc']
         spell.$order(order[0], order[1] || '');
+      } else if (order instanceof Raw) {
+        spell.$order(order);
       }
     }
   }
@@ -317,10 +320,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 +501,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;
     }
 
@@ -204,9 +216,9 @@ class Bone {
    * @memberof Bone
    */
   _clone(target) {
-    this.#raw = Object.assign({}, target.getRaw());
-    this.#rawSaved = Object.assign({}, target.getRawSaved());
-    this.#rawPrevious = Object.assign({}, target.getRawPrevious());
+    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;
     });
   }
@@ -717,7 +769,6 @@ class Bone {
     for (const name in attributes) {
       const value = this.attribute(name);
       const { defaultValue } = attributes[name];
-      // console.log(attributes[name], name, defaultValue);
       if (value != null) {
         data[name] = value;
       } else if (value === undefined && defaultValue != null) {
@@ -731,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;
     });
@@ -857,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;
 
@@ -978,6 +1038,7 @@ class Bone {
     for (const hookName of hookNames) {
       if (this[hookName]) setupSingleHook(this, hookName, this[hookName]);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -990,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.
@@ -1108,6 +1174,7 @@ class Bone {
       Reflect.deleteProperty(this.prototype, originalName);
       this.loadAttribute(newName);
     }
+    this[columnAttributesKey] = null;
   }
 
   /**
@@ -1117,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);
   }
 
   /**
@@ -1135,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);
   }
 
   /**
@@ -1154,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 });
   }
 
   /**
@@ -1182,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) {
@@ -1495,11 +1567,12 @@ class Bone {
 
   static async transaction(callback) {
     const connection = await this.driver.getConnection();
+    let result;
     if (callback.constructor.name === 'AsyncFunction') {
       // if callback is an AsyncFunction
       await this.driver.query('BEGIN', [], { connection, Model: this, command: 'BEGIN'  });
       try {
-        await callback({ connection });
+        result = await callback({ connection });
         await this.driver.query('COMMIT', [], { connection, Model: this, command: 'COMMIT'  });
       } catch (err) {
         await this.driver.query('ROLLBACK', [], { connection, Model: this, command: 'ROLLBACK' });
@@ -1509,7 +1582,6 @@ class Bone {
       }
     } else if (callback.constructor.name === 'GeneratorFunction') {
       const gen = callback({ connection });
-      let result;
 
       try {
         await this.driver.query('BEGIN', [], {  connection, Model: this, command: 'BEGIN' });
@@ -1529,6 +1601,7 @@ class Bone {
     } else {
       throw new Error('unexpected transaction function, should be GeneratorFunction or AsyncFunction.');
     }
+    return result;
   }
 
   static init(attributes = {}, opts = {}, overrides = {}) {
@@ -1560,6 +1633,7 @@ class Bone {
       return result;
     }, {});
 
+    this[columnAttributesKey] = null;
     Object.defineProperties(this, looseReadonly({ ...hookMethods, attributes, table }));
   }
 
@@ -1579,7 +1653,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
 };