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

package/lib/eager-loading/eager-loading-tree.js

@@ -0,0 +1,338 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EagerLoadingTree = 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 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) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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; }
+class EagerLoadingTree {
+  constructor(root) {
+    this.root = void 0;
+    this.root = root;
+  }
+  static buildFromSequelizeOptions(options) {
+    const model = options.model,
+      rootAttributes = options.rootAttributes,
+      includeOption = options.includeOption;
+    const root = {
+      model,
+      association: null,
+      rawAttributes: _lodash().default.cloneDeep(rootAttributes),
+      attributes: _lodash().default.cloneDeep(rootAttributes),
+      order: options.rootOrder,
+      children: []
+    };
+    const pushAttribute = (node, attribute) => {
+      if (_lodash().default.isArray(node.attributes) && !node.attributes.includes(attribute)) {
+        node.attributes.push(attribute);
+      }
+    };
+    const traverseIncludeOption = (includeOption, eagerLoadingTreeParent) => {
+      const includeOptions = _lodash().default.castArray(includeOption);
+      if (includeOption.length > 0) {
+        const modelPrimaryKey = eagerLoadingTreeParent.model.primaryKeyAttribute;
+        pushAttribute(eagerLoadingTreeParent, modelPrimaryKey);
+      }
+      var _iterator = _createForOfIteratorHelper(includeOptions),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          const include = _step.value;
+          // skip fromFilter include option
+          if (include.fromFilter) {
+            continue;
+          }
+          const association = eagerLoadingTreeParent.model.associations[include.association];
+          const associationType = association.associationType;
+          const child = {
+            model: association.target,
+            association,
+            rawAttributes: _lodash().default.cloneDeep(include.attributes),
+            attributes: _lodash().default.cloneDeep(include.attributes),
+            parent: eagerLoadingTreeParent,
+            children: []
+          };
+          if (associationType == 'HasOne' || associationType == 'HasMany') {
+            const sourceKey = association.sourceKey,
+              foreignKey = association.foreignKey;
+            pushAttribute(eagerLoadingTreeParent, sourceKey);
+            pushAttribute(child, foreignKey);
+          }
+          if (associationType == 'BelongsTo') {
+            const targetKey = association.targetKey,
+              foreignKey = association.foreignKey;
+            pushAttribute(eagerLoadingTreeParent, foreignKey);
+            pushAttribute(child, targetKey);
+          }
+          if (associationType == 'BelongsToMany') {
+            const sourceKey = association.sourceKey;
+            pushAttribute(eagerLoadingTreeParent, sourceKey);
+          }
+          eagerLoadingTreeParent.children.push(child);
+          if (include.include) {
+            traverseIncludeOption(include.include, child);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    };
+    traverseIncludeOption(includeOption, root);
+    return new EagerLoadingTree(root);
+  }
+  load(pks, transaction) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const result = {};
+      const loadRecursive = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (node, ids) {
+          const modelPrimaryKey = node.model.primaryKeyAttribute;
+          let instances = [];
+          // load instances from database
+          if (!node.parent) {
+            const findOptions = {
+              where: {
+                [modelPrimaryKey]: ids
+              },
+              attributes: node.attributes
+            };
+            if (node.order) {
+              findOptions['order'] = node.order;
+            }
+            instances = yield node.model.findAll(_objectSpread(_objectSpread({}, findOptions), {}, {
+              transaction
+            }));
+          } else if (ids.length > 0) {
+            const association = node.association;
+            const associationType = association.associationType;
+            if (associationType == 'HasOne' || associationType == 'HasMany') {
+              const foreignKey = association.foreignKey;
+              const foreignKeyValues = node.parent.instances.map(instance => instance.get(association.sourceKey));
+              const findOptions = {
+                where: {
+                  [foreignKey]: foreignKeyValues
+                },
+                attributes: node.attributes,
+                transaction
+              };
+              instances = yield node.model.findAll(findOptions);
+            }
+            if (associationType == 'BelongsTo') {
+              const foreignKey = association.foreignKey;
+              const parentInstancesForeignKeyValues = node.parent.instances.map(instance => instance.get(foreignKey));
+              instances = yield node.model.findAll({
+                transaction,
+                where: {
+                  [association.targetKey]: parentInstancesForeignKeyValues
+                },
+                attributes: node.attributes
+              });
+            }
+            if (associationType == 'BelongsToMany') {
+              const foreignKeyValues = node.parent.instances.map(instance => instance.get(association.sourceKey));
+              instances = yield node.model.findAll({
+                transaction,
+                attributes: node.attributes,
+                include: [{
+                  association: association.oneFromTarget,
+                  where: {
+                    [association.foreignKey]: foreignKeyValues
+                  }
+                }]
+              });
+            }
+          }
+          node.instances = instances;
+          var _iterator2 = _createForOfIteratorHelper(node.children),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              const child = _step2.value;
+              const nodeIds = instances.map(instance => instance.get(modelPrimaryKey));
+              yield loadRecursive(child, nodeIds);
+            }
+            // merge instances to parent
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          if (!node.parent) {
+            return;
+          } else {
+            const association = node.association;
+            const associationType = association.associationType;
+            const setParentAccessor = parentInstance => {
+              const key = association.as;
+              const children = parentInstance.getDataValue(association.as);
+              if (association.isSingleAssociation) {
+                const isEmpty = !children;
+                parentInstance[key] = parentInstance.dataValues[key] = isEmpty ? null : children;
+              } else {
+                const isEmpty = !children || children.length == 0;
+                parentInstance[key] = parentInstance.dataValues[key] = isEmpty ? [] : children;
+              }
+            };
+            if (associationType == 'HasMany' || associationType == 'HasOne') {
+              const foreignKey = association.foreignKey;
+              const sourceKey = association.sourceKey;
+              var _iterator3 = _createForOfIteratorHelper(node.instances),
+                _step3;
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  const instance = _step3.value;
+                  const parentInstance = node.parent.instances.find(parentInstance => parentInstance.get(sourceKey) == instance.get(foreignKey));
+                  if (parentInstance) {
+                    if (associationType == 'HasMany') {
+                      const children = parentInstance.getDataValue(association.as);
+                      if (!children) {
+                        parentInstance.setDataValue(association.as, [instance]);
+                      } else {
+                        children.push(instance);
+                      }
+                    }
+                    if (associationType == 'HasOne') {
+                      parentInstance.setDataValue(association.as, instance);
+                    }
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+            if (associationType == 'BelongsTo') {
+              const foreignKey = association.foreignKey;
+              const targetKey = association.targetKey;
+              var _iterator4 = _createForOfIteratorHelper(node.instances),
+                _step4;
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  const instance = _step4.value;
+                  const parentInstances = node.parent.instances.filter(parentInstance => parentInstance.get(foreignKey) == instance.get(targetKey));
+                  var _iterator5 = _createForOfIteratorHelper(parentInstances),
+                    _step5;
+                  try {
+                    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                      const parentInstance = _step5.value;
+                      parentInstance.setDataValue(association.as, instance);
+                    }
+                  } catch (err) {
+                    _iterator5.e(err);
+                  } finally {
+                    _iterator5.f();
+                  }
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+            }
+            if (associationType == 'BelongsToMany') {
+              const sourceKey = association.sourceKey;
+              const foreignKey = association.foreignKey;
+              const oneFromTarget = association.oneFromTarget;
+              var _iterator6 = _createForOfIteratorHelper(node.instances),
+                _step6;
+              try {
+                for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                  const instance = _step6.value;
+                  const parentInstance = node.parent.instances.find(parentInstance => parentInstance.get(sourceKey) == instance[oneFromTarget.as].get(foreignKey));
+                  if (parentInstance) {
+                    const children = parentInstance.getDataValue(association.as);
+                    if (!children) {
+                      parentInstance.setDataValue(association.as, [instance]);
+                    } else {
+                      children.push(instance);
+                    }
+                  }
+                }
+              } catch (err) {
+                _iterator6.e(err);
+              } finally {
+                _iterator6.f();
+              }
+            }
+            var _iterator7 = _createForOfIteratorHelper(node.parent.instances),
+              _step7;
+            try {
+              for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                const parent = _step7.value;
+                setParentAccessor(parent);
+              }
+            } catch (err) {
+              _iterator7.e(err);
+            } finally {
+              _iterator7.f();
+            }
+          }
+        });
+        return function loadRecursive(_x, _x2) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      yield loadRecursive(_this.root, pks);
+      const setInstanceAttributes = node => {
+        const nodeRawAttributes = node.rawAttributes;
+        if (!_lodash().default.isArray(nodeRawAttributes)) {
+          return;
+        }
+        const nodeChildrenAs = node.children.map(child => child.association.as);
+        const includeAttributes = [...nodeRawAttributes, ...nodeChildrenAs];
+        var _iterator8 = _createForOfIteratorHelper(node.instances),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            const instance = _step8.value;
+            const attributes = _lodash().default.pick(instance.dataValues, includeAttributes);
+            instance.dataValues = attributes;
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+      };
+      // traverse tree and set instance attributes
+      const traverse = node => {
+        setInstanceAttributes(node);
+        var _iterator9 = _createForOfIteratorHelper(node.children),
+          _step9;
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            const child = _step9.value;
+            traverse(child);
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+      };
+      traverse(_this.root);
+      return result;
+    })();
+  }
+}
+exports.EagerLoadingTree = EagerLoadingTree;

package/lib/filter-parser.d.ts

@@ -15,13 +15,7 @@ export default class FilterParser {
     context: FilterParserContext;
     constructor(filter: FilterType, context: FilterParserContext);
     prepareFilter(filter: FilterType): any;
-    toSequelizeParams(): {
-        where?: undefined;
-        include?: undefined;
-    } | {
-        where: {};
-        include: any[];
-    };
+    toSequelizeParams(): any;
     private getFieldNameFromQueryPath;
 }
 export {};

package/lib/filter-parser.js

@@ -215,20 +215,40 @@ class FilterParser {
       });
     };
     debug('where %o, include %o', where, include);
-    return {
+    const results = {
       where,
       include: toInclude(include)
     };
+    //traverse filter include, set fromFiler to true
+    const traverseInclude = include => {
+      var _iterator = _createForOfIteratorHelper(include),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          const item = _step.value;
+          if (item.include) {
+            traverseInclude(item.include);
+          }
+          item.fromFilter = true;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    };
+    traverseInclude(results.include);
+    return results;
   }
   getFieldNameFromQueryPath(queryPath) {
     const paths = queryPath.split('.');
     let fieldName;
     const fullPaths = [];
-    var _iterator = _createForOfIteratorHelper(paths),
-      _step;
+    var _iterator2 = _createForOfIteratorHelper(paths),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        const path = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const path = _step2.value;
         if (path.startsWith('$') || !_lodash().default.isNaN(parseInt(path))) {
           continue;
         }
@@ -236,9 +256,9 @@ class FilterParser {
         fieldName = path;
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
     return [fieldName, fullPaths.join('.')];
   }

package/lib/listeners/append-child-collection-name-after-repository-find.d.ts

@@ -0,0 +1,5 @@
+export declare const appendChildCollectionNameAfterRepositoryFind: (db: any) => ({ findOptions, dataCollection, data }: {
+    findOptions: any;
+    dataCollection: any;
+    data: any;
+}) => void;

package/lib/listeners/append-child-collection-name-after-repository-find.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendChildCollectionNameAfterRepositoryFind = void 0;
+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 appendChildCollectionNameAfterRepositoryFind = db => {
+  return ({
+    findOptions,
+    dataCollection,
+    data
+  }) => {
+    if (dataCollection.isParent()) {
+      var _iterator = _createForOfIteratorHelper(data),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          const row = _step.value;
+          const rowCollection = db.tableNameCollectionMap.get(findOptions.raw ? `${row['__schemaName']}.${row['__tableName']}` : `${row.get('__schemaName')}.${row.get('__tableName')}`);
+          if (!rowCollection) {
+            db.logger.warn(`Can not find collection by table name ${JSON.stringify(row)}, current collections: ${Array.from(db.tableNameCollectionMap.keys()).join(', ')}`);
+            return;
+          }
+          const rowCollectionName = rowCollection.name;
+          findOptions.raw ? row['__collection'] = rowCollectionName : row.set('__collection', rowCollectionName, {
+            raw: true
+          });
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  };
+};
+exports.appendChildCollectionNameAfterRepositoryFind = appendChildCollectionNameAfterRepositoryFind;

package/lib/listeners/index.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.registerBuiltInListeners = void 0;
 var _adjacencyList = require("./adjacency-list");
+var _appendChildCollectionNameAfterRepositoryFind = require("./append-child-collection-name-after-repository-find");
 const registerBuiltInListeners = db => {
   db.on('beforeDefineCollection', _adjacencyList.beforeDefineAdjacencyListCollection);
+  db.on('afterRepositoryFind', (0, _appendChildCollectionNameAfterRepositoryFind.appendChildCollectionNameAfterRepositoryFind)(db));
 };
 exports.registerBuiltInListeners = registerBuiltInListeners;

package/lib/mock-database.js

@@ -62,7 +62,9 @@ function getConfigByEnv() {
 }
 function customLogger(queryString, queryObject) {
   console.log(queryString); // outputs a string
-  console.log(queryObject.bind); // outputs an array
+  if (queryObject.bind) {
+    console.log(queryObject.bind); // outputs an array
+  }
 }
 
 function mockDatabase(options = {}) {

package/lib/operators/string.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _utils = require("./utils");
 function _sequelize() {
   const data = require("sequelize");
   _sequelize = function _sequelize() {
@@ -12,6 +11,7 @@ function _sequelize() {
   };
   return data;
 }
+var _utils = require("./utils");
 var _default = {
   $includes(value, ctx) {
     return {

package/lib/options-parser.js

@@ -266,6 +266,10 @@ class OptionsParser {
         queryParams['include'] = [];
       }
       let existIncludeIndex = queryParams['include'].findIndex(include => include['association'] == appendAssociation);
+      // if include from filter, remove fromFilter attribute
+      if (existIncludeIndex != -1) {
+        delete queryParams['include'][existIncludeIndex]['fromFilter'];
+      }
       // if association not exist, create it
       if (existIncludeIndex == -1) {
         // association not exists

package/lib/query-interface/postgres-query-interface.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _queryInterface = _interopRequireDefault(require("./query-interface"));
-var _sqlParser = _interopRequireDefault(require("../sql-parser"));
+var _postgres = _interopRequireDefault(require("../sql-parser/postgres"));
 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; }
@@ -71,7 +71,7 @@ class PostgresQueryInterface extends _queryInterface.default {
       });
       const def = viewDefQuery[0]['definition'];
       try {
-        const _sqlParser$parse = _sqlParser.default.parse(def),
+        const _sqlParser$parse = _postgres.default.parse(def),
           ast = _sqlParser$parse.ast;
         const columns = ast[0].columns;
         const usages = columns.map(column => {

package/lib/relation-repository/belongs-to-many-repository.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from 'sequelize';
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
+import { AggregateOptions, CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
 import { FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 import { AssociatedOptions, PrimaryKeyWithThroughValues } from './types';
 declare type CreateBelongsToManyOptions = CreateOptions;
@@ -20,6 +20,7 @@ interface IBelongsToManyRepository<M extends Model> {
     }): Promise<void>;
 }
 export declare class BelongsToManyRepository extends MultipleRelationRepository implements IBelongsToManyRepository<any> {
+    aggregate(options: AggregateOptions): Promise<any>;
     create(options?: CreateBelongsToManyOptions): Promise<any>;
     destroy(options?: TargetKey | TargetKey[] | DestroyOptions): Promise<boolean>;
     protected setTargets(call: 'add' | 'set', options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions): Promise<void>;