@nocobase/database 0.7.0-alpha.9 → 0.7.1-alpha.4

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;

package/lib/operators/association.js

@@ -1,16 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-exports.default = {
-    $exists(value, ctx) {
-        return {
-            [sequelize_1.Op.not]: null,
-        };
-    },
-    $notExists(value, ctx) {
-        return {
-            [sequelize_1.Op.is]: null,
-        };
-    },
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = {
+  $exists(value, ctx) {
+    return {
+      [_sequelize().Op.not]: null
+    };
+  },
+
+  $notExists(value, ctx) {
+    return {
+      [_sequelize().Op.is]: null
+    };
+  }
+
 };
-//# sourceMappingURL=association.js.map
+exports.default = _default;

package/lib/operators/boolean.d.ts

@@ -0,0 +1,13 @@
+import { Op } from 'sequelize';
+declare const _default: {
+    $isFalsy(): {
+        [Op.or]: {
+            [Op.is]: any;
+            [Op.eq]: boolean;
+        };
+    };
+    $isTruly(): {
+        [Op.eq]: boolean;
+    };
+};
+export default _default;

package/lib/operators/boolean.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = {
+  $isFalsy() {
+    return {
+      [_sequelize().Op.or]: {
+        [_sequelize().Op.is]: null,
+        [_sequelize().Op.eq]: false
+      }
+    };
+  },
+
+  $isTruly() {
+    return {
+      [_sequelize().Op.eq]: true
+    };
+  }
+
+};
+exports.default = _default;

package/lib/operators/date.js

@@ -1,40 +1,84 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const moment_1 = __importDefault(require("moment"));
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+function _moment() {
+  const data = _interopRequireDefault(require("moment"));
+
+  _moment = function _moment() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function stringToDate(value) {
-    return (0, moment_1.default)(value).toDate();
+  return (0, _moment().default)(value).toDate();
 }
+
 function getNextDay(value) {
-    return (0, moment_1.default)(value).add(1, 'd').toDate();
+  return (0, _moment().default)(value).add(1, 'd').toDate();
 }
-exports.default = {
-    $dateOn(value) {
-        return {
-            [sequelize_1.Op.and]: [{ [sequelize_1.Op.gte]: stringToDate(value) }, { [sequelize_1.Op.lt]: getNextDay(value) }],
-        };
-    },
-    $dateNotOn(value) {
-        return {
-            [sequelize_1.Op.or]: [{ [sequelize_1.Op.lt]: stringToDate(value) }, { [sequelize_1.Op.gte]: getNextDay(value) }],
-        };
-    },
-    $dateBefore(value) {
-        return { [sequelize_1.Op.lt]: stringToDate(value) };
-    },
-    $dateNotBefore(value) {
-        return {
-            [sequelize_1.Op.gte]: stringToDate(value),
-        };
-    },
-    $dateAfter(value) {
-        return { [sequelize_1.Op.gte]: getNextDay(value) };
-    },
-    $dateNotAfter(value) {
-        return { [sequelize_1.Op.lt]: getNextDay(value) };
-    },
+
+var _default = {
+  $dateOn(value) {
+    return {
+      [_sequelize().Op.and]: [{
+        [_sequelize().Op.gte]: stringToDate(value)
+      }, {
+        [_sequelize().Op.lt]: getNextDay(value)
+      }]
+    };
+  },
+
+  $dateNotOn(value) {
+    return {
+      [_sequelize().Op.or]: [{
+        [_sequelize().Op.lt]: stringToDate(value)
+      }, {
+        [_sequelize().Op.gte]: getNextDay(value)
+      }]
+    };
+  },
+
+  $dateBefore(value) {
+    return {
+      [_sequelize().Op.lt]: stringToDate(value)
+    };
+  },
+
+  $dateNotBefore(value) {
+    return {
+      [_sequelize().Op.gte]: stringToDate(value)
+    };
+  },
+
+  $dateAfter(value) {
+    return {
+      [_sequelize().Op.gte]: getNextDay(value)
+    };
+  },
+
+  $dateNotAfter(value) {
+    return {
+      [_sequelize().Op.lt]: getNextDay(value)
+    };
+  }
+
 };
-//# sourceMappingURL=date.js.map
+exports.default = _default;

package/lib/operators/empty.js

@@ -1,82 +1,120 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const fields_1 = require("../fields");
-const array_1 = __importDefault(require("./array"));
-const lodash_1 = __importStar(require("lodash"));
-const findFilterFieldType = (ctx) => {
-    const db = ctx.db;
-    let path = ctx.path.split('.');
-    // remove operators
-    path.pop();
-    const fieldName = path.pop();
-    let model = ctx.model;
-    const associationPath = path;
-    for (const association of associationPath) {
-        if (lodash_1.default.isNumber((0, lodash_1.parseInt)(association)) || association.startsWith('$')) {
-            continue;
-        }
-        model = model.associations[association].target;
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _fields = require("../fields");
+
+var _array = _interopRequireDefault(require("./array"));
+
+function _lodash() {
+  const data = _interopRequireWildcard(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 findFilterFieldType = ctx => {
+  const db = ctx.db;
+  let path = ctx.path.split('.'); // remove operators
+
+  path.pop();
+  const fieldName = path.pop();
+  let model = ctx.model;
+  const associationPath = path;
+
+  var _iterator = _createForOfIteratorHelper(associationPath),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      const association = _step.value;
+
+      if (_lodash().default.isNumber((0, _lodash().parseInt)(association)) || association.startsWith('$')) {
+        continue;
+      }
+
+      model = model.associations[association].target;
     }
-    const collection = db.modelCollection.get(model);
-    return collection.getField(fieldName);
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  const collection = db.modelCollection.get(model);
+  return collection.getField(fieldName);
 };
-exports.default = {
-    $empty(_, ctx) {
-        const field = findFilterFieldType(ctx);
-        if (field instanceof fields_1.StringField) {
-            return {
-                [sequelize_1.Op.or]: {
-                    [sequelize_1.Op.is]: null,
-                    [sequelize_1.Op.eq]: '',
-                },
-            };
-        }
-        if (field instanceof fields_1.ArrayField) {
-            return array_1.default.$arrayEmpty(_, ctx);
-        }
-        return {
-            [sequelize_1.Op.is]: null,
-        };
-    },
-    $notEmpty(_, ctx) {
-        const field = findFilterFieldType(ctx);
-        if (field instanceof fields_1.StringField) {
-            return {
-                [sequelize_1.Op.and]: {
-                    [sequelize_1.Op.not]: null,
-                    [sequelize_1.Op.ne]: '',
-                },
-            };
+
+var _default = {
+  $empty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+
+    if (field instanceof _fields.StringField) {
+      return {
+        [_sequelize().Op.or]: {
+          [_sequelize().Op.is]: null,
+          [_sequelize().Op.eq]: ''
         }
-        if (field instanceof fields_1.ArrayField) {
-            return array_1.default.$arrayNotEmpty(_, ctx);
+      };
+    }
+
+    if (field instanceof _fields.ArrayField) {
+      return _array.default.$arrayEmpty(_, ctx);
+    }
+
+    return {
+      [_sequelize().Op.is]: null
+    };
+  },
+
+  $notEmpty(_, ctx) {
+    const field = findFilterFieldType(ctx);
+
+    if (field instanceof _fields.StringField) {
+      return {
+        [_sequelize().Op.and]: {
+          [_sequelize().Op.not]: null,
+          [_sequelize().Op.ne]: ''
         }
-        return {
-            [sequelize_1.Op.not]: null,
-        };
-    },
+      };
+    }
+
+    if (field instanceof _fields.ArrayField) {
+      return _array.default.$arrayNotEmpty(_, ctx);
+    }
+
+    return {
+      [_sequelize().Op.not]: null
+    };
+  }
+
 };
-//# sourceMappingURL=empty.js.map
+exports.default = _default;