@nocobase/database 0.7.4-alpha.4 → 0.7.5-alpha.1

package/lib/fields/sort-field.js

@@ -56,113 +56,126 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
 const sortFieldMutex = new (_asyncMutex().Mutex)();
 
 class SortField extends _field.Field {
-  get dataType() {
-    return _sequelize().DataTypes.INTEGER;
-  }
+  constructor(...args) {
+    var _this;
 
-  setSortValue(instance, options) {
-    var _this = this;
+    super(...args);
+    _this = this;
 
-    return _asyncToGenerator(function* () {
-      const _this$options = _this.options,
-            name = _this$options.name,
-            scopeKey = _this$options.scopeKey;
-      const model = _this.context.collection.model;
+    this.setSortValue = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (instance, options) {
+        const _this$options = _this.options,
+              name = _this$options.name,
+              scopeKey = _this$options.scopeKey;
+        const model = _this.context.collection.model;
 
-      if ((0, _lodash().isNumber)(instance.get(name)) && instance._previousDataValues[scopeKey] == instance[scopeKey]) {
-        return;
-      }
+        if ((0, _lodash().isNumber)(instance.get(name)) && instance._previousDataValues[scopeKey] == instance[scopeKey]) {
+          return;
+        }
 
-      const where = {};
+        const where = {};
 
-      if (scopeKey) {
-        const value = instance.get(scopeKey);
+        if (scopeKey) {
+          const value = instance.get(scopeKey);
 
-        if (value !== undefined && value !== null) {
-          where[scopeKey] = value;
+          if (value !== undefined && value !== null) {
+            where[scopeKey] = value;
+          }
         }
-      }
 
-      yield sortFieldMutex.runExclusive( /*#__PURE__*/_asyncToGenerator(function* () {
-        const max = yield model.max(name, _objectSpread(_objectSpread({}, options), {}, {
-          where
+        yield sortFieldMutex.runExclusive( /*#__PURE__*/_asyncToGenerator(function* () {
+          const max = yield model.max(name, _objectSpread(_objectSpread({}, options), {}, {
+            where
+          }));
+          const newValue = (max || 0) + 1;
+          instance.set(name, newValue);
         }));
-        const newValue = (max || 0) + 1;
-        instance.set(name, newValue);
-      }));
-    })();
-  }
+      });
 
-  onScopeChange(instance, options) {
-    var _this2 = this;
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }();
 
-    return _asyncToGenerator(function* () {
-      const scopeKey = _this2.options.scopeKey;
+    this.onScopeChange = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(function* (instance, options) {
+        const scopeKey = _this.options.scopeKey;
 
-      if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
-        yield _this2.setSortValue(instance, options);
-      }
-    })();
-  }
+        if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
+          yield _this.setSortValue(instance, options);
+        }
+      });
 
-  initRecordsSortValue({
-    transaction
-  }) {
-    var _this3 = this;
+      return function (_x3, _x4) {
+        return _ref3.apply(this, arguments);
+      };
+    }();
 
-    return _asyncToGenerator(function* () {
-      const totalCount = yield _this3.collection.repository.count({
-        transaction
-      });
-      const emptyCount = yield _this3.collection.repository.count({
-        filter: {
-          [_this3.name]: null
-        },
+    this.initRecordsSortValue = /*#__PURE__*/function () {
+      var _ref4 = _asyncToGenerator(function* ({
         transaction
-      });
-
-      if (emptyCount === totalCount && emptyCount > 0) {
-        const records = yield _this3.collection.repository.find({
-          order: [_this3.collection.model.primaryKeyAttribute],
+      }) {
+        const totalCount = yield _this.collection.repository.count({
+          transaction
+        });
+        const emptyCount = yield _this.collection.repository.count({
+          filter: {
+            [_this.name]: null
+          },
           transaction
         });
-        let start = 1;
-
-        var _iterator = _createForOfIteratorHelper(records),
-            _step;
-
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            const record = _step.value;
-            yield record.update({
-              sort: start
-            }, {
-              transaction,
-              silent: true
-            });
-            start += 1;
+
+        if (emptyCount === totalCount && emptyCount > 0) {
+          const records = yield _this.collection.repository.find({
+            order: [_this.collection.model.primaryKeyAttribute],
+            transaction
+          });
+          let start = 1;
+
+          var _iterator = _createForOfIteratorHelper(records),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              const record = _step.value;
+              yield record.update({
+                sort: start
+              }, {
+                transaction,
+                silent: true
+              });
+              start += 1;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
-      }
-    })();
+      });
+
+      return function (_x5) {
+        return _ref4.apply(this, arguments);
+      };
+    }();
+  }
+
+  get dataType() {
+    return _sequelize().DataTypes.INTEGER;
   }
 
   bind() {
     super.bind();
-    this.on('afterSync', this.initRecordsSortValue.bind(this));
-    this.on('beforeUpdate', this.onScopeChange.bind(this));
-    this.on('beforeCreate', this.setSortValue.bind(this));
+    this.on('afterSync', this.initRecordsSortValue);
+    this.on('beforeUpdate', this.onScopeChange);
+    this.on('beforeCreate', this.setSortValue);
   }
 
   unbind() {
     super.unbind();
-    this.off('beforeUpdate', this.onScopeChange.bind(this));
-    this.off('beforeCreate', this.setSortValue.bind(this));
-    this.off('afterSync', this.initRecordsSortValue.bind(this));
+    this.off('beforeUpdate', this.onScopeChange);
+    this.off('beforeCreate', this.setSortValue);
+    this.off('afterSync', this.initRecordsSortValue);
   }
 
 }

package/lib/filter-parser.js

@@ -161,11 +161,17 @@ class FilterParser {
 
               const queryValue = _lodash().default.get((0, _flat().unflatten)(originalFiler), skipPrefix);
 
+              const _this$getFieldNameFro = this.getFieldNameFromQueryPath(skipPrefix),
+                    _this$getFieldNameFro2 = _slicedToArray(_this$getFieldNameFro, 2),
+                    fieldName = _this$getFieldNameFro2[0],
+                    fullName = _this$getFieldNameFro2[1];
+
               value = opKey(queryValue, {
                 app: this.context.app,
                 db: this.database,
                 path: skipPrefix,
-                fieldName: this.getFieldNameFromQueryPath(skipPrefix),
+                fullName,
+                fieldName,
                 model: this.model
               });
               break;
@@ -272,6 +278,7 @@ class FilterParser {
   getFieldNameFromQueryPath(queryPath) {
     const paths = queryPath.split('.');
     let fieldName;
+    let fullPaths = [];
 
     var _iterator = _createForOfIteratorHelper(paths),
         _step;
@@ -284,6 +291,7 @@ class FilterParser {
           continue;
         }
 
+        fullPaths.push(path);
         fieldName = path;
       }
     } catch (err) {
@@ -292,7 +300,7 @@ class FilterParser {
       _iterator.f();
     }
 
-    return fieldName;
+    return [fieldName, fullPaths.join('.')];
   }
 
 }

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-export { ModelCtor, Op, SyncOptions } from 'sequelize';
+export { DataTypes, ModelCtor, Op, SyncOptions } from 'sequelize';
 export * from './collection';
 export * from './database';
 export { Database as default } from './database';

package/lib/index.js

@@ -4,8 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
+  DataTypes: true,
   Op: true
 };
+Object.defineProperty(exports, "DataTypes", {
+  enumerable: true,
+  get: function get() {
+    return _sequelize().DataTypes;
+  }
+});
 Object.defineProperty(exports, "Op", {
   enumerable: true,
   get: function get() {

package/lib/magic-attribute-model.d.ts

@@ -2,6 +2,7 @@ import { Model } from './model';
 export declare class MagicAttributeModel extends Model {
     get magicAttribute(): string;
     set(key: any, value?: any, options?: any): this;
+    setV1(key?: any, value?: any, options?: any): this;
     get(key?: any, value?: any): any;
     update(values?: any, options?: any): Promise<this>;
 }

package/lib/magic-attribute-model.js

@@ -25,6 +25,16 @@ function _lodash() {
   return data;
 }
 
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
 var _model = require("./model");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -33,6 +43,8 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -51,6 +63,8 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
+const Dottie = require('dottie');
+
 class MagicAttributeModel extends _model.Model {
   get magicAttribute() {
     const db = this.constructor.database;
@@ -65,30 +79,217 @@ class MagicAttributeModel extends _model.Model {
             column = _key$split2[0];
 
       if (this.constructor.hasAlias(column)) {
-        return super.set(key, value, options);
+        return this.setV1(key, value, options);
       }
 
       if (this.constructor.rawAttributes[column]) {
-        return super.set(key, value, options);
+        return this.setV1(key, value, options);
       }
 
       if (_lodash().default.isPlainObject(value)) {
         const opts = super.get(this.magicAttribute) || {};
-        return super.set(`${this.magicAttribute}.${key}`, (0, _utils().merge)(opts === null || opts === void 0 ? void 0 : opts[key], value), options);
+        return this.setV1(`${this.magicAttribute}.${key}`, (0, _utils().merge)(opts === null || opts === void 0 ? void 0 : opts[key], value), options);
       }
 
-      return super.set(`${this.magicAttribute}.${key}`, value, options);
+      return this.setV1(`${this.magicAttribute}.${key}`, value, options);
     } else {
       if (!key) {
         return;
       }
 
       Object.keys(key).forEach(k => {
-        this.set(k, key[k], options);
+        this.setV1(k, key[k], options);
       });
     }
 
-    return super.set(key, value, options);
+    return this.setV1(key, value, options);
+  }
+
+  setV1(key, value, options) {
+    let values;
+    let originalValue;
+
+    if (typeof key === 'object' && key !== null) {
+      values = key;
+      options = value || {};
+
+      if (options.reset) {
+        // @ts-ignore
+        this.dataValues = {};
+
+        for (const key in values) {
+          this.changed(key, false);
+        }
+      } // If raw, and we're not dealing with includes or special attributes, just set it straight on the dataValues object
+      // @ts-ignore
+
+
+      if (options.raw && // @ts-ignore
+      !(this._options && this._options.include) && !(options && options.attributes) && // @ts-ignore
+      !this.constructor._hasDateAttributes && // @ts-ignore
+      !this.constructor._hasBooleanAttributes) {
+        // @ts-ignore
+        if (Object.keys(this.dataValues).length) {
+          // @ts-ignore
+          Object.assign(this.dataValues, values);
+        } else {
+          // @ts-ignore
+          this.dataValues = values;
+        } // If raw, .changed() shouldn't be true
+        // @ts-ignore
+
+
+        this._previousDataValues = _objectSpread({}, this.dataValues);
+      } else {
+        // Loop and call set
+        if (options.attributes) {
+          const setKeys = data => {
+            var _iterator = _createForOfIteratorHelper(data),
+                _step;
+
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                const k = _step.value;
+
+                if (values[k] === undefined) {
+                  continue;
+                }
+
+                this.set(k, values[k], options);
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          };
+
+          setKeys(options.attributes); // @ts-ignore
+
+          if (this.constructor._hasVirtualAttributes) {
+            // @ts-ignore
+            setKeys(this.constructor._virtualAttributes);
+          } // @ts-ignore
+
+
+          if (this._options.includeNames) {
+            // @ts-ignore
+            setKeys(this._options.includeNames);
+          }
+        } else {
+          for (const key in values) {
+            this.set(key, values[key], options);
+          }
+        }
+
+        if (options.raw) {
+          // If raw, .changed() shouldn't be true
+          // @ts-ignore
+          this._previousDataValues = _objectSpread({}, this.dataValues);
+        }
+      }
+
+      return this;
+    }
+
+    if (!options) options = {};
+
+    if (!options.raw) {
+      // @ts-ignore
+      originalValue = this.dataValues[key];
+    } // If not raw, and there's a custom setter
+    // @ts-ignore
+
+
+    if (!options.raw && this._customSetters[key]) {
+      // @ts-ignore
+      this._customSetters[key].call(this, value, key); // custom setter should have changed value, get that changed value
+      // TODO: v5 make setters return new value instead of changing internal store
+      // @ts-ignore
+
+
+      const newValue = this.dataValues[key];
+
+      if (!_lodash().default.isEqual(newValue, originalValue)) {
+        // @ts-ignore
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      }
+    } else {
+      // Check if we have included models, and if this key matches the include model names/aliases
+      // @ts-ignore
+      if (this._options && this._options.include && this._options.includeNames.includes(key)) {
+        // Pass it on to the include handler
+        // @ts-ignore
+        this._setInclude(key, value, options);
+
+        return this;
+      } // Bunch of stuff we won't do when it's raw
+
+
+      if (!options.raw) {
+        // If attribute is not in model definition, return
+        // @ts-ignore
+        if (!this._isAttribute(key)) {
+          // @ts-ignore
+          if (key.includes('.') && this.constructor._jsonAttributes.has(key.split('.')[0])) {
+            // @ts-ignore
+            const previousNestedValue = Dottie.get(this.dataValues, key);
+
+            if (!_lodash().default.isEqual(previousNestedValue, value)) {
+              // @ts-ignore
+              this._previousDataValues = _lodash().default.cloneDeep(this._previousDataValues); // @ts-ignore
+
+              Dottie.set(this.dataValues, key, value);
+              this.changed(key.split('.')[0], true);
+            }
+          }
+
+          return this;
+        } // If attempting to set primary key and primary key is already defined, return
+        // @ts-ignore
+
+
+        if (this.constructor._hasPrimaryKeys && originalValue && this.constructor._isPrimaryKey(key)) {
+          return this;
+        } // If attempting to set read only attributes, return
+        // @ts-ignore
+
+
+        if (!this.isNewRecord && // @ts-ignore
+        this.constructor._hasReadOnlyAttributes && // @ts-ignore
+        this.constructor._readOnlyAttributes.has(key)) {
+          return this;
+        }
+      } // If there's a data type sanitizer
+
+
+      if (!(value instanceof _sequelize().Utils.SequelizeMethod) && // @ts-ignore
+      Object.prototype.hasOwnProperty.call(this.constructor._dataTypeSanitizers, key)) {
+        // @ts-ignore
+        value = this.constructor._dataTypeSanitizers[key].call(this, value, options);
+      } // Set when the value has changed and not raw
+
+
+      if (!options.raw && ( // True when sequelize method
+      value instanceof _sequelize().Utils.SequelizeMethod || // Check for data type type comparators
+      // @ts-ignore
+      !(value instanceof _sequelize().Utils.SequelizeMethod) && // @ts-ignore
+      this.constructor._dataTypeChanges[key] && // @ts-ignore
+      this.constructor._dataTypeChanges[key].call(this, value, originalValue, options) || // Check default
+      // @ts-ignore
+      !this.constructor._dataTypeChanges[key] && !_lodash().default.isEqual(value, originalValue))) {
+        // @ts-ignore
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      } // set data value
+      // @ts-ignore
+
+
+      this.dataValues[key] = value;
+    }
+
+    return this;
   }
 
   get(key, value) {

package/lib/mock-database.js

@@ -55,7 +55,7 @@ function getConfigByEnv() {
     database: process.env.DB_DATABASE,
     host: process.env.DB_HOST,
     port: process.env.DB_PORT,
-    dialect: process.env.DB_DIALECT,
+    dialect: process.env.DB_DIALECT || 'sqlite',
     logging: process.env.DB_LOGGING === 'on' ? console.log : false,
     storage: process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:' ? (0, _path().resolve)(process.cwd(), process.env.DB_STORAGE) : ':memory:',
     define: {

package/lib/operators/array.js

@@ -29,8 +29,9 @@ const escape = (value, ctx) => {
 
 const sqliteExistQuery = (value, ctx) => {
   const fieldName = getFieldName(ctx);
+  const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
   const sqlArray = `(${value.map(v => `'${v}'`).join(', ')})`;
-  const subQuery = `exists (select * from json_each(${fieldName}) where json_each.value in ${sqlArray})`;
+  const subQuery = `exists (select * from json_each(${name}) where json_each.value in ${sqlArray})`;
   return subQuery;
 };
 
@@ -65,7 +66,8 @@ var _default = {
     value = escape(JSON.stringify(value.sort()), ctx);
 
     if ((0, _utils.isMySQL)(ctx)) {
-      return _sequelize().Sequelize.literal(`JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return _sequelize().Sequelize.literal(`JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name})`);
     }
 
     return {
@@ -78,11 +80,13 @@ var _default = {
     value = escape(JSON.stringify(value), ctx);
 
     if ((0, _utils.isPg)(ctx)) {
-      return _sequelize().Sequelize.literal(`not (${fieldName} <@ ${value}::JSONB and ${fieldName} @> ${value}::JSONB)`);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      return _sequelize().Sequelize.literal(`not (${name} <@ ${value}::JSONB and ${name} @> ${value}::JSONB)`);
     }
 
     if ((0, _utils.isMySQL)(ctx)) {
-      return _sequelize().Sequelize.literal(`not (JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName}))`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return _sequelize().Sequelize.literal(`not (JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name}))`);
     }
 
     return {
@@ -94,12 +98,14 @@ var _default = {
     const fieldName = getFieldName(ctx);
 
     if ((0, _utils.isPg)(ctx)) {
-      return _sequelize().Sequelize.literal(`${fieldName} ?| ${escape(value.map(i => `${i}`), ctx)}`);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      return _sequelize().Sequelize.literal(`${name} ?| ${escape(value.map(i => `${i}`), ctx)}`);
     }
 
     if ((0, _utils.isMySQL)(ctx)) {
       value = escape(JSON.stringify(value), ctx);
-      return _sequelize().Sequelize.literal(`JSON_OVERLAPS(${fieldName}, ${value})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return _sequelize().Sequelize.literal(`JSON_OVERLAPS(${name}, ${value})`);
     }
 
     const subQuery = sqliteExistQuery(value, ctx);
@@ -110,13 +116,15 @@ var _default = {
     let where;
 
     if ((0, _utils.isPg)(ctx)) {
-      const fieldName = getFieldName(ctx); // pg single quote
+      const fieldName = getFieldName(ctx);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`; // pg single quote
 
-      where = _sequelize().Sequelize.literal(`not (${fieldName} ?| ${escape(value.map(i => `${i}`), ctx)})`);
+      where = _sequelize().Sequelize.literal(`not (${name} ?| ${escape(value.map(i => `${i}`), ctx)})`);
     } else if ((0, _utils.isMySQL)(ctx)) {
       const fieldName = getFieldName(ctx);
       value = escape(JSON.stringify(value), ctx);
-      where = _sequelize().Sequelize.literal(`NOT JSON_OVERLAPS(${fieldName}, ${value})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      where = _sequelize().Sequelize.literal(`NOT JSON_OVERLAPS(${name}, ${value})`);
     } else {
       const subQuery = sqliteExistQuery(value, ctx);
       where = _sequelize().Sequelize.literal(`not ${subQuery}`);

package/lib/operators/ne.d.ts

@@ -1,10 +1,14 @@
 import { Op } from 'sequelize';
 declare const _default: {
     $ne(val: any, ctx: any): {
+        [Op.ne]: any;
+        [Op.or]?: undefined;
+    } | {
         [Op.or]: {
             [Op.ne]: any;
             [Op.is]: any;
         };
+        [Op.ne]?: undefined;
     };
 };
 export default _default;

package/lib/operators/ne.js

@@ -17,7 +17,9 @@ function _sequelize() {
 
 var _default = {
   $ne(val, ctx) {
-    return {
+    return val === null ? {
+      [_sequelize().Op.ne]: null
+    } : {
       [_sequelize().Op.or]: {
         [_sequelize().Op.ne]: val,
         [_sequelize().Op.is]: null

package/lib/relation-repository/belongs-to-many-repository.js

@@ -68,6 +68,12 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
     var _this = this;
 
     return _asyncToGenerator(function* () {
+      if (Array.isArray(options.values)) {
+        return Promise.all(options.values.map(record => _this.create(_objectSpread(_objectSpread({}, options), {}, {
+          values: record
+        }))));
+      }
+
       const transaction = yield _this.getTransaction(options);
 
       const createAccessor = _this.accessors().create;