@nocobase/database 0.7.0-alpha.4 → 0.7.0-alpha.56

package/lib/model-hook.js

@@ -1,68 +1,109 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ModelHook = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
-const { hooks } = require('sequelize/lib/hooks');
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+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(_e) { throw _e; }, 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(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+const _require = require('sequelize/lib/hooks'),
+      hooks = _require.hooks;
+
 class ModelHook {
-    constructor(database) {
-        this.boundEvent = new Set();
-        this.database = database;
+  constructor(database) {
+    this.database = void 0;
+    this.boundEvent = new Set();
+    this.database = database;
+  }
+
+  isModelHook(eventName) {
+    if (_lodash().default.isString(eventName)) {
+      const hookType = eventName.split('.').pop();
+
+      if (hooks[hookType]) {
+        return hookType;
+      }
     }
-    isModelHook(eventName) {
-        if (lodash_1.default.isString(eventName)) {
-            const hookType = eventName.split('.').pop();
-            if (hooks[hookType]) {
-                return hookType;
-            }
+
+    return false;
+  }
+
+  findModelName(hookArgs) {
+    var _iterator = _createForOfIteratorHelper(hookArgs),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const arg = _step.value;
+
+        if (arg === null || arg === void 0 ? void 0 : arg._previousDataValues) {
+          return arg.constructor.name;
         }
-        return false;
-    }
-    findModelName(hookArgs) {
-        for (const arg of hookArgs) {
-            if (arg instanceof model_1.Model) {
-                return arg.constructor.name;
-            }
-            if (lodash_1.default.isPlainObject(arg)) {
-                if (arg['model']) {
-                    return arg['model'].name;
-                }
-                if (lodash_1.default.get(arg, 'name.plural')) {
-                    return lodash_1.default.get(arg, 'name.plural');
-                }
-            }
+
+        if (_lodash().default.isPlainObject(arg)) {
+          if (arg['model']) {
+            return arg['model'].name;
+          }
+
+          if (_lodash().default.get(arg, 'name.plural')) {
+            return _lodash().default.get(arg, 'name.plural');
+          }
         }
-        return null;
-    }
-    bindEvent(eventName) {
-        this.boundEvent.add(eventName);
-    }
-    hasBindEvent(eventName) {
-        return this.boundEvent.has(eventName);
-    }
-    sequelizeHookBuilder(eventName) {
-        return (...args) => __awaiter(this, void 0, void 0, function* () {
-            const modelName = this.findModelName(args);
-            if (modelName) {
-                // emit model event
-                yield this.database.emitAsync(`${modelName}.${eventName}`, ...args);
-            }
-            // emit sequelize global event
-            yield this.database.emitAsync(eventName, ...args);
-        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
+
+    return null;
+  }
+
+  bindEvent(eventName) {
+    this.boundEvent.add(eventName);
+  }
+
+  hasBindEvent(eventName) {
+    return this.boundEvent.has(eventName);
+  }
+
+  sequelizeHookBuilder(eventName) {
+    var _this = this;
+
+    return /*#__PURE__*/_asyncToGenerator(function* (...args) {
+      const modelName = _this.findModelName(args);
+
+      if (modelName) {
+        // emit model event
+        yield _this.database.emitAsync(`${modelName}.${eventName}`, ...args);
+      } // emit sequelize global event
+
+
+      yield _this.database.emitAsync(eventName, ...args);
+    });
+  }
+
 }
-exports.ModelHook = ModelHook;
-//# sourceMappingURL=model-hook.js.map
+
+exports.ModelHook = ModelHook;

package/lib/model.js

@@ -1,87 +1,122 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.Model = void 0;
-const sequelize_1 = require("sequelize");
-const lodash_1 = __importDefault(require("lodash"));
-class Model extends sequelize_1.Model {
-    toJSON() {
-        const handleObj = (obj, options) => {
-            const handles = [
-                (data) => {
-                    if (data instanceof Model) {
-                        return data.toJSON();
-                    }
-                    return data;
-                },
-                this.hiddenObjKey,
-            ];
-            return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
-        };
-        const handleArray = (arrayOfObj, options) => {
-            const handles = [this.sortAssociations];
-            return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
-        };
-        const opts = {
-            model: this.constructor,
-            collection: this.constructor.collection,
-            db: this.constructor.database,
-        };
-        const traverseJSON = (data, options) => {
-            const { model, db, collection } = options;
-            // handle Object
-            data = handleObj(data, options);
-            const result = {};
-            for (const key of Object.keys(data)) {
-                // @ts-ignore
-                if (model.hasAlias(key)) {
-                    const association = model.associations[key];
-                    const opts = {
-                        model: association.target,
-                        collection: db.getCollection(association.target.name),
-                        db,
-                        key,
-                        field: collection.getField(key),
-                    };
-                    if (['HasMany', 'BelongsToMany'].includes(association.associationType)) {
-                        result[key] = handleArray(data[key], opts).map((item) => traverseJSON(item, opts));
-                    }
-                    else {
-                        result[key] = data[key] ? traverseJSON(data[key], opts) : null;
-                    }
-                }
-                else {
-                    result[key] = data[key];
-                }
-            }
-            return result;
-        };
-        return traverseJSON(super.toJSON(), opts);
-    }
-    hiddenObjKey(obj, options) {
-        const hiddenFields = Array.from(options.collection.fields.values())
-            .filter((field) => field.options.hidden)
-            .map((field) => field.options.name);
-        return lodash_1.default.omit(obj, hiddenFields);
-    }
-    sortAssociations(data, { field }) {
-        const sortBy = field.options.sortBy;
-        return sortBy ? this.sortArray(data, sortBy) : data;
-    }
-    sortArray(data, sortBy) {
-        if (!lodash_1.default.isArray(sortBy)) {
-            sortBy = [sortBy];
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Model extends _sequelize().Model {
+  toJSON() {
+    const handleObj = (obj, options) => {
+      const handles = [data => {
+        if (data instanceof Model) {
+          return data.toJSON();
+        }
+
+        return data;
+      }, this.hiddenObjKey];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
+    };
+
+    const handleArray = (arrayOfObj, options) => {
+      const handles = [this.sortAssociations];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
+    };
+
+    const opts = {
+      model: this.constructor,
+      collection: this.constructor.collection,
+      db: this.constructor.database
+    };
+
+    const traverseJSON = (data, options) => {
+      const model = options.model,
+            db = options.db,
+            collection = options.collection; // handle Object
+
+      data = handleObj(data, options);
+      const result = {};
+
+      for (var _i = 0, _Object$keys = Object.keys(data); _i < _Object$keys.length; _i++) {
+        const key = _Object$keys[_i];
+
+        // @ts-ignore
+        if (model.hasAlias(key)) {
+          const association = model.associations[key];
+          const opts = {
+            model: association.target,
+            collection: db.getCollection(association.target.name),
+            db,
+            key,
+            field: collection.getField(key)
+          };
+
+          if (['HasMany', 'BelongsToMany'].includes(association.associationType)) {
+            result[key] = handleArray(data[key], opts).map(item => traverseJSON(item, opts));
+          } else {
+            result[key] = data[key] ? traverseJSON(data[key], opts) : null;
+          }
+        } else {
+          result[key] = data[key];
         }
-        const orderItems = [];
-        const orderDirections = [];
-        sortBy.forEach((sortItem) => {
-            orderDirections.push(sortItem.startsWith('-') ? 'desc' : 'asc');
-            orderItems.push(sortItem.replace('-', ''));
-        });
-        return lodash_1.default.orderBy(data, orderItems, orderDirections);
+      }
+
+      return result;
+    };
+
+    return traverseJSON(super.toJSON(), opts);
+  }
+
+  hiddenObjKey(obj, options) {
+    const hiddenFields = Array.from(options.collection.fields.values()).filter(field => field.options.hidden).map(field => field.options.name);
+    return _lodash().default.omit(obj, hiddenFields);
+  }
+
+  sortAssociations(data, {
+    field
+  }) {
+    const sortBy = field.options.sortBy;
+    return sortBy ? this.sortArray(data, sortBy) : data;
+  }
+
+  sortArray(data, sortBy) {
+    if (!_lodash().default.isArray(sortBy)) {
+      sortBy = [sortBy];
     }
+
+    const orderItems = [];
+    const orderDirections = [];
+    sortBy.forEach(sortItem => {
+      orderDirections.push(sortItem.startsWith('-') ? 'desc' : 'asc');
+      orderItems.push(sortItem.replace('-', ''));
+    });
+    return _lodash().default.orderBy(data, orderItems, orderDirections);
+  }
+
 }
+
 exports.Model = Model;
-//# sourceMappingURL=model.js.map
+Model.database = void 0;
+Model.collection = void 0;

package/lib/operators/array.js

@@ -1,107 +1,147 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const utils_1 = require("./utils");
-const getFieldName = (ctx) => {
-    const fieldName = ctx.fieldName;
-    return fieldName;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require("./utils");
+
+const getFieldName = ctx => {
+  const fieldName = ctx.fieldName;
+  return fieldName;
 };
+
 const escape = (value, ctx) => {
-    const sequelize = ctx.db.sequelize;
-    return sequelize.escape(value);
+  const sequelize = ctx.db.sequelize;
+  return sequelize.escape(value);
 };
+
 const sqliteExistQuery = (value, ctx) => {
-    const fieldName = getFieldName(ctx);
-    const sqlArray = `(${value.map((v) => `'${v}'`).join(', ')})`;
-    const subQuery = `exists (select * from json_each(${fieldName}) where json_each.value in ${sqlArray})`;
-    return subQuery;
+  const fieldName = getFieldName(ctx);
+  const sqlArray = `(${value.map(v => `'${v}'`).join(', ')})`;
+  const subQuery = `exists (select * from json_each(${fieldName}) where json_each.value in ${sqlArray})`;
+  return subQuery;
 };
+
 const emptyQuery = (ctx, operator) => {
+  const fieldName = getFieldName(ctx);
+  let funcName = 'json_array_length';
+  let ifNull = 'IFNULL';
+
+  if ((0, _utils.isPg)(ctx)) {
+    funcName = 'jsonb_array_length';
+    ifNull = 'coalesce';
+  }
+
+  if ((0, _utils.isMySQL)(ctx)) {
+    funcName = 'json_length';
+  }
+
+  return `(select ${ifNull}(${funcName}(${fieldName}), 0) ${operator} 0)`;
+};
+
+var _default = {
+  $match(value, ctx) {
     const fieldName = getFieldName(ctx);
-    let funcName = 'json_array_length';
-    let ifNull = 'IFNULL';
-    if ((0, utils_1.isPg)(ctx)) {
-        funcName = 'jsonb_array_length';
-        ifNull = 'coalesce';
+
+    if ((0, _utils.isPg)(ctx)) {
+      return {
+        [_sequelize().Op.contained]: value,
+        [_sequelize().Op.contains]: value
+      };
     }
-    if ((0, utils_1.isMySQL)(ctx)) {
-        funcName = 'json_length';
+
+    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})`);
     }
-    return `(select ${ifNull}(${funcName}(${fieldName}), 0) ${operator} 0)`;
-};
-exports.default = {
-    $match(value, ctx) {
-        const fieldName = getFieldName(ctx);
-        if ((0, utils_1.isPg)(ctx)) {
-            return {
-                [sequelize_1.Op.contained]: value,
-                [sequelize_1.Op.contains]: value,
-            };
-        }
-        value = escape(JSON.stringify(value.sort()), ctx);
-        if ((0, utils_1.isMySQL)(ctx)) {
-            return sequelize_1.Sequelize.literal(`JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName})`);
-        }
-        return {
-            [sequelize_1.Op.eq]: sequelize_1.Sequelize.literal(`json(${value})`),
-        };
-    },
-    $notMatch(value, ctx) {
-        const fieldName = getFieldName(ctx);
-        value = escape(JSON.stringify(value), ctx);
-        if ((0, utils_1.isPg)(ctx)) {
-            return sequelize_1.Sequelize.literal(`not (${fieldName} <@ ${value}::JSONB and ${fieldName} @> ${value}::JSONB)`);
-        }
-        if ((0, utils_1.isMySQL)(ctx)) {
-            return sequelize_1.Sequelize.literal(`not (JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName}))`);
-        }
-        return {
-            [sequelize_1.Op.ne]: sequelize_1.Sequelize.literal(`json(${value})`),
-        };
-    },
-    $anyOf(value, ctx) {
-        const fieldName = getFieldName(ctx);
-        if ((0, utils_1.isPg)(ctx)) {
-            return sequelize_1.Sequelize.literal(`${fieldName} ?| ${escape(value.map((i) => `${i}`), ctx)}`);
-        }
-        if ((0, utils_1.isMySQL)(ctx)) {
-            value = escape(JSON.stringify(value), ctx);
-            return sequelize_1.Sequelize.literal(`JSON_OVERLAPS(${fieldName}, ${value})`);
-        }
-        const subQuery = sqliteExistQuery(value, ctx);
-        return sequelize_1.Sequelize.literal(subQuery);
-    },
-    $noneOf(value, ctx) {
-        let where;
-        if ((0, utils_1.isPg)(ctx)) {
-            const fieldName = getFieldName(ctx);
-            // pg single quote
-            where = sequelize_1.Sequelize.literal(`not (${fieldName} ?| ${escape(value.map((i) => `${i}`), ctx)})`);
-        }
-        else if ((0, utils_1.isMySQL)(ctx)) {
-            const fieldName = getFieldName(ctx);
-            value = escape(JSON.stringify(value), ctx);
-            where = sequelize_1.Sequelize.literal(`NOT JSON_OVERLAPS(${fieldName}, ${value})`);
-        }
-        else {
-            const subQuery = sqliteExistQuery(value, ctx);
-            where = sequelize_1.Sequelize.literal(`not ${subQuery}`);
-        }
-        return {
-            [sequelize_1.Op.or]: [where, { [sequelize_1.Op.is]: null }],
-        };
-    },
-    $arrayEmpty(value, ctx) {
-        const subQuery = emptyQuery(ctx, '=');
-        return {
-            [sequelize_1.Op.and]: [sequelize_1.Sequelize.literal(`${subQuery}`)],
-        };
-    },
-    $arrayNotEmpty(value, ctx) {
-        const subQuery = emptyQuery(ctx, '>');
-        return {
-            [sequelize_1.Op.and]: [sequelize_1.Sequelize.literal(`${subQuery}`)],
-        };
-    },
+
+    return {
+      [_sequelize().Op.eq]: _sequelize().Sequelize.literal(`json(${value})`)
+    };
+  },
+
+  $notMatch(value, ctx) {
+    const fieldName = getFieldName(ctx);
+    value = escape(JSON.stringify(value), ctx);
+
+    if ((0, _utils.isPg)(ctx)) {
+      return _sequelize().Sequelize.literal(`not (${fieldName} <@ ${value}::JSONB and ${fieldName} @> ${value}::JSONB)`);
+    }
+
+    if ((0, _utils.isMySQL)(ctx)) {
+      return _sequelize().Sequelize.literal(`not (JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName}))`);
+    }
+
+    return {
+      [_sequelize().Op.ne]: _sequelize().Sequelize.literal(`json(${value})`)
+    };
+  },
+
+  $anyOf(value, ctx) {
+    const fieldName = getFieldName(ctx);
+
+    if ((0, _utils.isPg)(ctx)) {
+      return _sequelize().Sequelize.literal(`${fieldName} ?| ${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 subQuery = sqliteExistQuery(value, ctx);
+    return _sequelize().Sequelize.literal(subQuery);
+  },
+
+  $noneOf(value, ctx) {
+    let where;
+
+    if ((0, _utils.isPg)(ctx)) {
+      const fieldName = getFieldName(ctx); // pg single quote
+
+      where = _sequelize().Sequelize.literal(`not (${fieldName} ?| ${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})`);
+    } else {
+      const subQuery = sqliteExistQuery(value, ctx);
+      where = _sequelize().Sequelize.literal(`not ${subQuery}`);
+    }
+
+    return {
+      [_sequelize().Op.or]: [where, {
+        [_sequelize().Op.is]: null
+      }]
+    };
+  },
+
+  $arrayEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, '=');
+    return {
+      [_sequelize().Op.and]: [_sequelize().Sequelize.literal(`${subQuery}`)]
+    };
+  },
+
+  $arrayNotEmpty(value, ctx) {
+    const subQuery = emptyQuery(ctx, '>');
+    return {
+      [_sequelize().Op.and]: [_sequelize().Sequelize.literal(`${subQuery}`)]
+    };
+  }
+
 };
-//# sourceMappingURL=array.js.map
+exports.default = _default;