@nocobase/database 0.9.3-alpha.1 → 0.9.4-alpha.1

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

@@ -43,53 +43,74 @@ var __decorate = void 0 && (void 0).__decorate || function (decorators, target,
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelationRepository {
-  create(options) {
+  aggregate(options) {
     var _this = this;
+    return _asyncToGenerator(function* () {
+      const targetRepository = _this.targetCollection.repository;
+      const sourceModel = yield _this.getSourceModel();
+      const association = _this.association;
+      return yield targetRepository.aggregate(_objectSpread(_objectSpread({}, options), {}, {
+        optionsTransformer: modelOptions => {
+          modelOptions.include = modelOptions.include || [];
+          const throughWhere = {};
+          throughWhere[association.foreignKey] = sourceModel.get(association.sourceKey);
+          modelOptions.include.push({
+            association: association.oneFromTarget,
+            required: true,
+            attributes: [],
+            where: throughWhere
+          });
+        }
+      }));
+    })();
+  }
+  create(options) {
+    var _this2 = this;
     return _asyncToGenerator(function* () {
       if (Array.isArray(options.values)) {
-        return Promise.all(options.values.map(record => _this.create(_objectSpread(_objectSpread({}, options), {}, {
+        return Promise.all(options.values.map(record => _this2.create(_objectSpread(_objectSpread({}, options), {}, {
           values: record
         }))));
       }
-      const transaction = yield _this.getTransaction(options);
-      const createAccessor = _this.accessors().create;
+      const transaction = yield _this2.getTransaction(options);
+      const createAccessor = _this2.accessors().create;
       const values = options.values || {};
-      const sourceModel = yield _this.getSourceModel(transaction);
+      const sourceModel = yield _this2.getSourceModel(transaction);
       const createOptions = _objectSpread(_objectSpread({}, options), {}, {
-        through: values[_this.throughName()],
+        through: values[_this2.throughName()],
         transaction
       });
       return sourceModel[createAccessor](values, createOptions);
     })();
   }
   destroy(options) {
-    var _this2 = this;
+    var _this3 = this;
     return _asyncToGenerator(function* () {
-      const transaction = yield _this2.getTransaction(options);
-      const association = _this2.association;
-      const throughModel = _this2.throughModel();
+      const transaction = yield _this3.getTransaction(options);
+      const association = _this3.association;
+      const throughModel = _this3.throughModel();
       const instancesToIds = instances => {
-        return instances.map(instance => instance.get(_this2.targetKey()));
+        return instances.map(instance => instance.get(_this3.targetKey()));
       };
       // Through Table
       const throughTableWhere = [{
-        [throughModel.rawAttributes[association.foreignKey].field]: _this2.sourceKeyValue
+        [throughModel.rawAttributes[association.foreignKey].field]: _this3.sourceKeyValue
       }];
       let ids;
       if (options && options['filter']) {
-        const instances = yield _this2.find({
+        const instances = yield _this3.find({
           filter: options['filter'],
           transaction
         });
         ids = instancesToIds(instances);
       }
       if (options && options['filterByTk']) {
-        const instances = _this2.association.toInstanceArray(options['filterByTk']);
+        const instances = _this3.association.toInstanceArray(options['filterByTk']);
         ids = ids ? _lodash().default.intersection(ids, instancesToIds(instances)) : instancesToIds(instances);
       }
       if (options && !options['filterByTk'] && !options['filter']) {
-        const sourceModel = yield _this2.getSourceModel(transaction);
-        const instances = yield sourceModel[_this2.accessors().get]({
+        const sourceModel = yield _this3.getSourceModel(transaction);
+        const instances = yield sourceModel[_this3.accessors().get]({
           transaction
         });
         ids = instancesToIds(instances);
@@ -100,13 +121,13 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
         }
       });
       // delete through table data
-      yield _this2.throughModel().destroy({
+      yield _this3.throughModel().destroy({
         where: throughTableWhere,
         transaction
       });
-      yield _this2.targetModel.destroy({
+      yield _this3.targetModel.destroy({
         where: {
-          [_this2.targetKey()]: {
+          [_this3.targetKey()]: {
             [_sequelize().Op.in]: ids
           }
         },
@@ -116,10 +137,10 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
     })();
   }
   setTargets(call, options) {
-    var _this3 = this;
+    var _this4 = this;
     return _asyncToGenerator(function* () {
       let handleKeys;
-      const transaction = yield _this3.getTransaction(options, false);
+      const transaction = yield _this4.getTransaction(options, false);
       if (_lodash().default.isPlainObject(options)) {
         options = options.tk || [];
       }
@@ -131,7 +152,7 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
       } else {
         handleKeys = options;
       }
-      const sourceModel = yield _this3.getSourceModel(transaction);
+      const sourceModel = yield _this4.getSourceModel(transaction);
       const setObj = handleKeys.reduce((carry, item) => {
         if (Array.isArray(item)) {
           carry[item[0]] = item[1];
@@ -141,14 +162,14 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
         return carry;
       }, {});
       const targetKeys = Object.keys(setObj);
-      const association = _this3.association;
-      const targetObjects = yield _this3.targetModel.findAll({
+      const association = _this4.association;
+      const targetObjects = yield _this4.targetModel.findAll({
         where: {
           [association['targetKey']]: targetKeys
         },
         transaction
       });
-      yield sourceModel[_this3.accessors()[call]](targetObjects, {
+      yield sourceModel[_this4.accessors()[call]](targetObjects, {
         transaction
       });
       for (var _i = 0, _Object$entries = Object.entries(setObj); _i < _Object$entries.length; _i++) {
@@ -156,40 +177,40 @@ class BelongsToManyRepository extends _multipleRelationRepository.MultipleRelati
           id = _Object$entries$_i[0],
           throughValues = _Object$entries$_i[1];
         if (typeof throughValues === 'object') {
-          const instance = yield _this3.targetModel.findByPk(id, {
+          const instance = yield _this4.targetModel.findByPk(id, {
             transaction
           });
-          yield (0, _updateAssociations.updateThroughTableValue)(instance, _this3.throughName(), throughValues, sourceModel, transaction);
+          yield (0, _updateAssociations.updateThroughTableValue)(instance, _this4.throughName(), throughValues, sourceModel, transaction);
         }
       }
     })();
   }
   add(options) {
-    var _this4 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
-      yield _this4.setTargets('add', options);
+      yield _this5.setTargets('add', options);
     })();
   }
   set(options) {
-    var _this5 = this;
+    var _this6 = this;
     return _asyncToGenerator(function* () {
-      yield _this5.setTargets('set', options);
+      yield _this6.setTargets('set', options);
     })();
   }
   toggle(options) {
-    var _this6 = this;
+    var _this7 = this;
     return _asyncToGenerator(function* () {
-      const transaction = yield _this6.getTransaction(options);
-      const sourceModel = yield _this6.getSourceModel(transaction);
-      const has = yield sourceModel[_this6.accessors().hasSingle](options['tk'], {
+      const transaction = yield _this7.getTransaction(options);
+      const sourceModel = yield _this7.getSourceModel(transaction);
+      const has = yield sourceModel[_this7.accessors().hasSingle](options['tk'], {
         transaction
       });
       if (has) {
-        yield _this6.remove(_objectSpread(_objectSpread({}, options), {}, {
+        yield _this7.remove(_objectSpread(_objectSpread({}, options), {}, {
           transaction
         }));
       } else {
-        yield _this6.add(_objectSpread(_objectSpread({}, options), {}, {
+        yield _this7.add(_objectSpread(_objectSpread({}, options), {}, {
           transaction
         }));
       }

package/lib/relation-repository/hasmany-repository.d.ts

@@ -1,5 +1,5 @@
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { AggregateOptions, CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
 import { AssociatedOptions, FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 interface IHasManyRepository<M extends Model> {
     find(options?: FindOptions): Promise<M>;
@@ -14,6 +14,7 @@ interface IHasManyRepository<M extends Model> {
 }
 export declare class HasManyRepository extends MultipleRelationRepository implements IHasManyRepository<any> {
     find(options?: FindOptions): Promise<any>;
+    aggregate(options: AggregateOptions): Promise<any>;
     destroy(options?: TK | DestroyOptions): Promise<boolean>;
     handleKeyOfAdd(options: any): any;
     set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;

package/lib/relation-repository/hasmany-repository.js

@@ -53,18 +53,33 @@ class HasManyRepository extends _multipleRelationRepository.MultipleRelationRepo
       return yield targetRepository.find(findOptions);
     })();
   }
-  destroy(options) {
+  aggregate(options) {
     var _this2 = this;
     return _asyncToGenerator(function* () {
-      const transaction = yield _this2.getTransaction(options);
-      const sourceModel = yield _this2.getSourceModel(transaction);
+      const targetRepository = _this2.targetCollection.repository;
+      const addFilter = {
+        [_this2.association.foreignKey]: _this2.sourceKeyValue
+      };
+      const aggOptions = _objectSpread(_objectSpread({}, options), {}, {
+        filter: {
+          $and: [options.filter || {}, addFilter]
+        }
+      });
+      return yield targetRepository.aggregate(aggOptions);
+    })();
+  }
+  destroy(options) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this3.getTransaction(options);
+      const sourceModel = yield _this3.getSourceModel(transaction);
       const where = [{
-        [_this2.association.foreignKey]: sourceModel.get(_this2.association.sourceKey)
+        [_this3.association.foreignKey]: sourceModel.get(_this3.association.sourceKey)
       }];
       if (options && options['filter']) {
-        const filterResult = _this2.parseFilter(options['filter'], options);
+        const filterResult = _this3.parseFilter(options['filter'], options);
         if (filterResult.include && filterResult.include.length > 0) {
-          return yield _this2.destroyByFilter(options['filter'], transaction);
+          return yield _this3.destroyByFilter(options['filter'], transaction);
         }
         where.push(filterResult.where);
       }
@@ -73,10 +88,10 @@ class HasManyRepository extends _multipleRelationRepository.MultipleRelationRepo
           options = options['filterByTk'];
         }
         where.push({
-          [_this2.targetKey()]: options
+          [_this3.targetKey()]: options
         });
       }
-      yield _this2.targetModel.destroy({
+      yield _this3.targetModel.destroy({
         where: {
           [_sequelize().Op.and]: where
         },
@@ -96,21 +111,21 @@ class HasManyRepository extends _multipleRelationRepository.MultipleRelationRepo
     return handleKeys;
   }
   set(options) {
-    var _this3 = this;
+    var _this4 = this;
     return _asyncToGenerator(function* () {
-      const transaction = yield _this3.getTransaction(options);
-      const sourceModel = yield _this3.getSourceModel(transaction);
-      yield sourceModel[_this3.accessors().set](_this3.handleKeyOfAdd(options), {
+      const transaction = yield _this4.getTransaction(options);
+      const sourceModel = yield _this4.getSourceModel(transaction);
+      yield sourceModel[_this4.accessors().set](_this4.handleKeyOfAdd(options), {
         transaction
       });
     })();
   }
   add(options) {
-    var _this4 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
-      const transaction = yield _this4.getTransaction(options);
-      const sourceModel = yield _this4.getSourceModel(transaction);
-      yield sourceModel[_this4.accessors().add](_this4.handleKeyOfAdd(options), {
+      const transaction = yield _this5.getTransaction(options);
+      const sourceModel = yield _this5.getSourceModel(transaction);
+      yield sourceModel[_this5.accessors().add](_this5.handleKeyOfAdd(options), {
         transaction
       });
     })();

package/lib/relation-repository/multiple-relation-repository.js

@@ -4,13 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.MultipleRelationRepository = void 0;
-function _lodash() {
-  const data = require("lodash");
-  _lodash = function _lodash() {
-    return data;
-  };
-  return data;
-}
 function _sequelize() {
   const data = require("sequelize");
   _sequelize = function _sequelize() {
@@ -21,7 +14,7 @@ function _sequelize() {
 var _updateAssociations = require("../update-associations");
 var _updateGuard = require("../update-guard");
 var _relationRepository = require("./relation-repository");
-var _utils = require("../utils");
+var _eagerLoadingTree = require("../eager-loading/eager-loading-tree");
 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; }
@@ -68,25 +61,14 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
         if (ids.length == 0) {
           return [];
         }
-        return yield (0, _utils.handleAppendsQuery)({
-          templateModel: ids[0].row,
-          queryPromises: findOptions.include.map(include => {
-            return sourceModel[getAccessor](_objectSpread(_objectSpread({}, (0, _lodash().omit)(findOptions, ['limit', 'offset'])), {}, {
-              include: [include],
-              where: {
-                [_this.targetKey()]: {
-                  [_sequelize().Op.in]: ids.map(id => id.pk)
-                }
-              },
-              transaction
-            })).then(rows => {
-              return {
-                rows,
-                include
-              };
-            });
-          })
+        const eagerLoadingTree = _eagerLoadingTree.EagerLoadingTree.buildFromSequelizeOptions({
+          model: _this.targetModel,
+          rootAttributes: findOptions.attributes,
+          includeOption: findOptions.include,
+          rootOrder: findOptions.order
         });
+        yield eagerLoadingTree.load(ids.map(i => i.pk), transaction);
+        return eagerLoadingTree.root.instances;
       }
       const data = yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
         transaction

package/lib/relation-repository/relation-repository.d.ts

@@ -22,12 +22,6 @@ export declare abstract class RelationRepository {
     create(options?: CreateOptions): Promise<any>;
     getSourceModel(transaction?: Transaction): Promise<Model<any, any>>;
     protected buildQueryOptions(options: FindOptions): any;
-    protected parseFilter(filter: Filter, options?: any): {
-        where?: undefined;
-        include?: undefined;
-    } | {
-        where: {};
-        include: any[];
-    };
+    protected parseFilter(filter: Filter, options?: any): any;
     protected getTransaction(options: any, autoGen?: boolean): Promise<Transaction | null>;
 }

package/lib/relation-repository/single-relation-repository.d.ts

@@ -14,7 +14,7 @@ interface SetOption extends Transactionable {
 export declare abstract class SingleRelationRepository extends RelationRepository {
     remove(options?: Transactionable): Promise<void>;
     set(options: TargetKey | SetOption): Promise<void>;
-    find(options?: SingleRelationFindOption): Promise<Model<any> | null>;
+    find(options?: SingleRelationFindOption): Promise<any>;
     findOne(options?: SingleRelationFindOption): Promise<Model<any>>;
     destroy(options?: Transactionable): Promise<boolean>;
     update(options: UpdateOptions): Promise<any>;

package/lib/relation-repository/single-relation-repository.js

@@ -12,8 +12,8 @@ function _lodash() {
   return data;
 }
 var _updateAssociations = require("../update-associations");
-var _utils = require("../utils");
 var _relationRepository = require("./relation-repository");
+var _eagerLoadingTree = require("../eager-loading/eager-loading-tree");
 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; }
@@ -64,23 +64,17 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
         const templateModel = yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
           includeIgnoreAttributes: false,
           transaction,
-          attributes: [_this3.targetKey()],
-          group: `${_this3.targetModel.name}.${_this3.targetKey()}`
+          attributes: [_this3.targetModel.primaryKeyAttribute],
+          group: `${_this3.targetModel.name}.${_this3.targetModel.primaryKeyAttribute}`
         }));
-        const results = yield (0, _utils.handleAppendsQuery)({
-          templateModel,
-          queryPromises: findOptions.include.map(include => {
-            return sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
-              include: [include]
-            })).then(row => {
-              return {
-                rows: [row],
-                include
-              };
-            });
-          })
+        if (!templateModel) return null;
+        const eagerLoadingTree = _eagerLoadingTree.EagerLoadingTree.buildFromSequelizeOptions({
+          model: _this3.targetModel,
+          rootAttributes: findOptions.attributes,
+          includeOption: findOptions.include
         });
-        return results[0];
+        yield eagerLoadingTree.load([templateModel.get(_this3.targetModel.primaryKeyAttribute)], transaction);
+        return eagerLoadingTree.root.instances[0];
       }
       return yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
         transaction

package/lib/repository.d.ts

@@ -104,6 +104,7 @@ declare class RelationRepositoryBuilder<R extends RelationRepository> {
         ArrayField: typeof ArrayFieldRepository;
     };
     constructor(collection: Collection, associationName: string);
+    of(id: string | number): R;
     protected builder(): {
         HasOne: typeof HasOneRepository;
         BelongsTo: typeof BelongsToRepository;
@@ -111,7 +112,12 @@ declare class RelationRepositoryBuilder<R extends RelationRepository> {
         HasMany: typeof HasManyRepository;
         ArrayField: typeof ArrayFieldRepository;
     };
-    of(id: string | number): R;
+}
+export interface AggregateOptions {
+    method: 'avg' | 'count' | 'min' | 'max' | 'sum';
+    field?: string;
+    filter?: Filter;
+    distinct?: boolean;
 }
 export declare class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> implements IRepository {
     database: Database;
@@ -122,6 +128,9 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      * return count by filter
      */
     count(countOptions?: CountOptions): Promise<number>;
+    aggregate(options: AggregateOptions & {
+        optionsTransformer?: (options: any) => any;
+    }): Promise<any>;
     /**
      * find
      * @param options
@@ -173,12 +182,6 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      */
     relation<R extends RelationRepository>(association: string): RelationRepositoryBuilder<R>;
     buildQueryOptions(options: any): any;
-    protected parseFilter(filter: Filter, options?: any): {
-        where?: undefined;
-        include?: undefined;
-    } | {
-        where: {};
-        include: any[];
-    };
+    protected parseFilter(filter: Filter, options?: any): any;
     protected getTransaction(options: any, autoGen?: boolean): Promise<any>;
 }