@nocobase/database 0.8.0-alpha.8 → 0.8.1-alpha.3

package/lib/inherited-collection.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InheritedCollection = void 0;
+
+var _collection = require("./collection");
+
+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 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; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+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 _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; }
+
+class InheritedCollection extends _collection.Collection {
+  constructor(options, context) {
+    if (!options.inherits) {
+      throw new Error('InheritedCollection must have inherits option');
+    }
+
+    options.inherits = _lodash().default.castArray(options.inherits);
+    super(options, context);
+    this.parents = void 0;
+
+    try {
+      this.bindParents();
+    } catch (err) {
+      if (err instanceof ParentCollectionNotFound) {
+        const listener = collection => {
+          if (options.inherits.includes(collection.name) && options.inherits.every(name => this.db.collections.has(name))) {
+            this.bindParents();
+            this.db.removeListener('afterDefineCollection', listener);
+          }
+        };
+
+        this.db.addListener('afterDefineCollection', listener);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  bindParents() {
+    this.setParents(this.options.inherits);
+    this.setParentFields();
+    this.setFields(this.options.fields, false);
+    this.db.inheritanceMap.setInheritance(this.name, this.options.inherits);
+  }
+
+  setParents(inherits) {
+    this.parents = _lodash().default.castArray(inherits).map(name => {
+      const existCollection = this.db.collections.get(name);
+
+      if (!existCollection) {
+        throw new ParentCollectionNotFound(name);
+      }
+
+      return existCollection;
+    });
+  }
+
+  setParentFields() {
+    var _iterator = _createForOfIteratorHelper(this.parentFields()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const _step$value = _slicedToArray(_step.value, 2),
+              name = _step$value[0],
+              fieldOptions = _step$value[1];
+
+        this.setField(name, _objectSpread(_objectSpread({}, fieldOptions), {}, {
+          inherit: true
+        }));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  getParents() {
+    return this.parents;
+  }
+
+  parentFields() {
+    const fields = new Map();
+
+    var _iterator2 = _createForOfIteratorHelper(this.parents),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const parent = _step2.value;
+
+        if (parent.isInherited()) {
+          var _iterator3 = _createForOfIteratorHelper(parent.parentFields()),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              const _step3$value = _slicedToArray(_step3.value, 2),
+                    name = _step3$value[0],
+                    field = _step3$value[1];
+
+              fields.set(name, field.options);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+
+        const parentFields = parent.fields;
+
+        var _iterator4 = _createForOfIteratorHelper(parentFields),
+            _step4;
+
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            const _step4$value = _slicedToArray(_step4.value, 2),
+                  name = _step4$value[0],
+                  field = _step4$value[1];
+
+            fields.set(name, field.options);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return fields;
+  }
+
+  parentAttributes() {
+    const attributes = {};
+
+    var _iterator5 = _createForOfIteratorHelper(this.parents),
+        _step5;
+
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        const parent = _step5.value;
+
+        if (parent.isInherited()) {
+          Object.assign(attributes, parent.parentAttributes());
+        }
+
+        const parentAttributes = parent.model.tableAttributes;
+        Object.assign(attributes, parentAttributes);
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+
+    return attributes;
+  }
+
+  isInherited() {
+    return true;
+  }
+
+}
+
+exports.InheritedCollection = InheritedCollection;
+
+class ParentCollectionNotFound extends Error {
+  constructor(name) {
+    super(`parent collection ${name} not found`);
+  }
+
+}

package/lib/inherited-map.d.ts

@@ -0,0 +1,21 @@
+declare class TableNode {
+    name: string;
+    parents: Set<TableNode>;
+    children: Set<TableNode>;
+    constructor(name: string);
+}
+export default class InheritanceMap {
+    nodes: Map<string, TableNode>;
+    removeNode(name: string): void;
+    getOrCreateNode(name: string): TableNode;
+    getNode(name: string): TableNode;
+    setInheritance(name: string, inherits: string | string[]): void;
+    isParentNode(name: string): boolean;
+    getChildren(name: string, options?: {
+        deep: boolean;
+    }): Set<string>;
+    getParents(name: string, options?: {
+        deep: boolean;
+    }): Set<string>;
+}
+export {};

package/lib/inherited-map.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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 _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; }
+
+class TableNode {
+  constructor(name) {
+    this.name = void 0;
+    this.parents = void 0;
+    this.children = void 0;
+    this.name = name;
+    this.parents = new Set();
+    this.children = new Set();
+  }
+
+}
+
+class InheritanceMap {
+  constructor() {
+    this.nodes = new Map();
+  }
+
+  removeNode(name) {
+    const node = this.nodes.get(name);
+    if (!node) return;
+
+    var _iterator = _createForOfIteratorHelper(node.parents),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const parent = _step.value;
+        parent.children.delete(node);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    var _iterator2 = _createForOfIteratorHelper(node.children),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const child = _step2.value;
+        child.parents.delete(node);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    this.nodes.delete(name);
+  }
+
+  getOrCreateNode(name) {
+    if (!this.nodes.has(name)) {
+      this.nodes.set(name, new TableNode(name));
+    }
+
+    return this.getNode(name);
+  }
+
+  getNode(name) {
+    return this.nodes.get(name);
+  }
+
+  setInheritance(name, inherits) {
+    const node = this.getOrCreateNode(name);
+
+    const parents = _lodash().default.castArray(inherits).map(name => this.getOrCreateNode(name));
+
+    node.parents = new Set(parents);
+
+    var _iterator3 = _createForOfIteratorHelper(parents),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        const parent = _step3.value;
+        parent.children.add(node);
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+
+  isParentNode(name) {
+    const node = this.getNode(name);
+    return node && node.children.size > 0;
+  }
+
+  getChildren(name, options = {
+    deep: true
+  }) {
+    const results = new Set();
+    const node = this.getNode(name);
+    if (!node) return results;
+
+    var _iterator4 = _createForOfIteratorHelper(node.children),
+        _step4;
+
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        const child = _step4.value;
+        results.add(child.name);
+
+        if (!options.deep) {
+          continue;
+        }
+
+        var _iterator5 = _createForOfIteratorHelper(this.getChildren(child.name)),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            const grandchild = _step5.value;
+            results.add(grandchild);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+
+    return results;
+  }
+
+  getParents(name, options = {
+    deep: true
+  }) {
+    const results = new Set();
+    const node = this.getNode(name);
+    if (!node) return results;
+
+    var _iterator6 = _createForOfIteratorHelper(node.parents),
+        _step6;
+
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        const parent = _step6.value;
+        results.add(parent.name);
+
+        if (!options.deep) {
+          continue;
+        }
+
+        var _iterator7 = _createForOfIteratorHelper(this.getParents(parent.name)),
+            _step7;
+
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            const grandparent = _step7.value;
+            results.add(grandparent);
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+
+    return results;
+  }
+
+}
+
+exports.default = InheritanceMap;

package/lib/model-hook.d.ts

@@ -1,4 +1,4 @@
-import type { SequelizeHooks } from 'sequelize/types/lib/hooks';
+import { SequelizeHooks } from 'sequelize/types/hooks';
 import Database from './database';
 export declare class ModelHook {
     database: Database;

package/lib/model.d.ts

@@ -17,5 +17,6 @@ export declare class Model<TModelAttributes extends {} = any, TCreationAttribute
     private hiddenObjKey;
     private sortAssociations;
     private sortArray;
+    static sync(options: any): Promise<any>;
 }
 export {};

package/lib/model.js

@@ -25,8 +25,16 @@ function _sequelize() {
   return data;
 }
 
+var _syncRunner = require("./sync-runner");
+
 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); }); }; }
+
+const _ = _lodash().default;
+
 class Model extends _sequelize().Model {
   constructor(...args) {
     super(...args);
@@ -157,6 +165,45 @@ class Model extends _sequelize().Model {
     return _lodash().default.orderBy(data, orderItems, orderDirections);
   }
 
+  static sync(options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const model = _this; // fix sequelize sync with model that not have any column
+
+      if (Object.keys(model.tableAttributes).length === 0) {
+        if (_this.database.inDialect('sqlite', 'mysql')) {
+          throw new Error(`Zero-column tables aren't supported in ${_this.database.sequelize.getDialect()}`);
+        } // @ts-ignore
+
+
+        const queryInterface = _this.sequelize.queryInterface;
+
+        if (!queryInterface.patched) {
+          const oldDescribeTable = queryInterface.describeTable;
+          queryInterface.describeTable = /*#__PURE__*/_asyncToGenerator(function* (...args) {
+            try {
+              return yield oldDescribeTable.call(this, ...args);
+            } catch (err) {
+              if (err.message.includes('No description found for')) {
+                return [];
+              } else {
+                throw err;
+              }
+            }
+          });
+          queryInterface.patched = true;
+        }
+      }
+
+      if (_this.collection.isInherited()) {
+        return _syncRunner.SyncRunner.syncInheritModel(model, options);
+      }
+
+      return _sequelize().Model.sync.call(_this, options);
+    })();
+  }
+
 }
 
 exports.Model = Model;

package/lib/operators/array.d.ts

@@ -1,26 +1,2 @@
-import { Op } from 'sequelize';
-declare const _default: {
-    $match(value: any, ctx: any): import("sequelize/types/lib/utils").Literal | {
-        [Op.contained]: any;
-        [Op.contains]: any;
-        [Op.eq]?: undefined;
-    } | {
-        [Op.eq]: import("sequelize/types/lib/utils").Literal;
-        [Op.contained]?: undefined;
-        [Op.contains]?: undefined;
-    };
-    $notMatch(value: any, ctx: any): import("sequelize/types/lib/utils").Literal | {
-        [Op.ne]: import("sequelize/types/lib/utils").Literal;
-    };
-    $anyOf(value: any, ctx: any): import("sequelize/types/lib/utils").Literal;
-    $noneOf(value: any, ctx: any): {
-        [Op.or]: any[];
-    };
-    $arrayEmpty(value: any, ctx: any): {
-        [Op.and]: import("sequelize/types/lib/utils").Literal[];
-    };
-    $arrayNotEmpty(value: any, ctx: any): {
-        [Op.and]: import("sequelize/types/lib/utils").Literal[];
-    };
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/operators/association.d.ts

@@ -1,10 +1,2 @@
-import { Op } from 'sequelize';
-declare const _default: {
-    $exists(value: any, ctx: any): {
-        [Op.not]: any;
-    };
-    $notExists(value: any, ctx: any): {
-        [Op.is]: any;
-    };
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/operators/boolean.d.ts

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

package/lib/operators/date.d.ts

@@ -1,34 +1,2 @@
-import { Op } from 'sequelize';
-declare const _default: {
-    $dateOn(value: any): {
-        [Op.and]: ({
-            [Op.gte]: Date;
-            [Op.lt]?: undefined;
-        } | {
-            [Op.lt]: Date;
-            [Op.gte]?: undefined;
-        })[];
-    };
-    $dateNotOn(value: any): {
-        [Op.or]: ({
-            [Op.lt]: Date;
-            [Op.gte]?: undefined;
-        } | {
-            [Op.gte]: Date;
-            [Op.lt]?: undefined;
-        })[];
-    };
-    $dateBefore(value: any): {
-        [Op.lt]: Date;
-    };
-    $dateNotBefore(value: any): {
-        [Op.gte]: Date;
-    };
-    $dateAfter(value: any): {
-        [Op.gte]: Date;
-    };
-    $dateNotAfter(value: any): {
-        [Op.lt]: Date;
-    };
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/operators/empty.d.ts

@@ -1,28 +1,5 @@
-import { Op } from 'sequelize';
 declare const _default: {
-    $empty(_: any, ctx: any): {
-        [Op.and]: import("sequelize/types/lib/utils").Literal[];
-    } | {
-        [Op.or]: {
-            [Op.is]: any;
-            [Op.eq]: string;
-        };
-        [Op.is]?: undefined;
-    } | {
-        [Op.is]: any;
-        [Op.or]?: undefined;
-    };
-    $notEmpty(_: any, ctx: any): {
-        [Op.and]: import("sequelize/types/lib/utils").Literal[];
-    } | {
-        [Op.and]: {
-            [Op.not]: any;
-            [Op.ne]: string;
-        };
-        [Op.not]?: undefined;
-    } | {
-        [Op.not]: any;
-        [Op.and]?: undefined;
-    };
+    $empty(_: any, ctx: any): any;
+    $notEmpty(_: any, ctx: any): any;
 };
 export default _default;

package/lib/operators/ne.d.ts

@@ -1,14 +1,2 @@
-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;
-    };
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/operators/notIn.d.ts

@@ -1,10 +1,2 @@
-import { Op } from 'sequelize';
-declare const _default: {
-    $notIn(val: any, ctx: any): {
-        [Op.or]: {
-            [Op.notIn]: any;
-            [Op.is]: any;
-        };
-    };
-};
+declare const _default: Record<string, any>;
 export default _default;

package/lib/options-parser.d.ts

@@ -1,4 +1,4 @@
-import { ModelCtor } from 'sequelize';
+import { ModelStatic } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import FilterParser from './filter-parser';
@@ -11,7 +11,7 @@ export declare class OptionsParser {
     options: FindOptions;
     database: Database;
     collection: Collection;
-    model: ModelCtor<any>;
+    model: ModelStatic<any>;
     filterParser: FilterParser;
     context: OptionsParserContext;
     constructor(options: FindOptions, context: OptionsParserContext);
@@ -24,6 +24,7 @@ export declare class OptionsParser {
      * @protected
      */
     protected parseSort(filterParams: any): any;
+    protected inheritFromSubQuery(): any;
     protected parseFields(filterParams: any): any;
     protected parseExcept(except: Except, filterParams: any): any;
     protected parseAppends(appends: Appends, filterParams: any): any;