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

package/src/relation-repository/multiple-relation-repository.ts

@@ -1,5 +1,4 @@
-import { omit } from 'lodash';
-import { MultiAssociationAccessors, Op, Sequelize, Transaction, Transactionable } from 'sequelize';
+import { MultiAssociationAccessors, Sequelize, Transaction, Transactionable } from 'sequelize';
 import {
   CommonFindOptions,
   CountOptions,
@@ -14,7 +13,7 @@ import {
 import { updateModelByValues } from '../update-associations';
 import { UpdateGuard } from '../update-guard';
 import { RelationRepository, transaction } from './relation-repository';
-import { handleAppendsQuery } from '../utils';
+import { EagerLoadingTree } from '../eager-loading/eager-loading-tree';
 
 export type FindAndCountOptions = CommonFindOptions;
 
@@ -61,23 +60,19 @@ export abstract class MultipleRelationRepository extends RelationRepository {
         return [];
       }
 
-      return await handleAppendsQuery({
-        templateModel: ids[0].row,
-        queryPromises: findOptions.include.map((include) => {
-          return sourceModel[getAccessor]({
-            ...omit(findOptions, ['limit', 'offset']),
-            include: [include],
-            where: {
-              [this.targetKey()]: {
-                [Op.in]: ids.map((id) => id.pk),
-              },
-            },
-            transaction,
-          }).then((rows) => {
-            return { rows, include };
-          });
-        }),
+      const eagerLoadingTree = EagerLoadingTree.buildFromSequelizeOptions({
+        model: this.targetModel,
+        rootAttributes: findOptions.attributes,
+        includeOption: findOptions.include,
+        rootOrder: findOptions.order,
       });
+
+      await eagerLoadingTree.load(
+        ids.map((i) => i.pk),
+        transaction,
+      );
+
+      return eagerLoadingTree.root.instances;
     }
 
     const data = await sourceModel[getAccessor]({

package/src/relation-repository/single-relation-repository.ts

@@ -3,8 +3,8 @@ import { SingleAssociationAccessors, Transactionable } from 'sequelize';
 import { Model } from '../model';
 import { Appends, Except, Fields, Filter, TargetKey, UpdateOptions } from '../repository';
 import { updateModelByValues } from '../update-associations';
-import { handleAppendsQuery } from '../utils';
 import { RelationRepository, transaction } from './relation-repository';
+import { EagerLoadingTree } from '../eager-loading/eager-loading-tree';
 
 export interface SingleRelationFindOption extends Transactionable {
   fields?: Fields;
@@ -44,7 +44,7 @@ export abstract class SingleRelationRepository extends RelationRepository {
     });
   }
 
-  async find(options?: SingleRelationFindOption): Promise<Model<any> | null> {
+  async find(options?: SingleRelationFindOption): Promise<any> {
     const transaction = await this.getTransaction(options);
 
     const findOptions = this.buildQueryOptions({
@@ -61,23 +61,21 @@ export abstract class SingleRelationRepository extends RelationRepository {
         ...findOptions,
         includeIgnoreAttributes: false,
         transaction,
-        attributes: [this.targetKey()],
-        group: `${this.targetModel.name}.${this.targetKey()}`,
+        attributes: [this.targetModel.primaryKeyAttribute],
+        group: `${this.targetModel.name}.${this.targetModel.primaryKeyAttribute}`,
       });
 
-      const results = await handleAppendsQuery({
-        templateModel,
-        queryPromises: findOptions.include.map((include) => {
-          return sourceModel[getAccessor]({
-            ...findOptions,
-            include: [include],
-          }).then((row) => {
-            return { rows: [row], include };
-          });
-        }),
+      if (!templateModel) return null;
+
+      const eagerLoadingTree = EagerLoadingTree.buildFromSequelizeOptions({
+        model: this.targetModel,
+        rootAttributes: findOptions.attributes,
+        includeOption: findOptions.include,
       });
 
-      return results[0];
+      await eagerLoadingTree.load([templateModel.get(this.targetModel.primaryKeyAttribute)], transaction);
+
+      return eagerLoadingTree.root.instances[0];
     }
 
     return await sourceModel[getAccessor]({

package/src/repository.ts

@@ -1,4 +1,4 @@
-import lodash, { omit } from 'lodash';
+import lodash from 'lodash';
 import {
   Association,
   BulkCreateOptions,
@@ -9,6 +9,7 @@ import {
   FindOptions as SequelizeFindOptions,
   ModelStatic,
   Op,
+  Sequelize,
   Transactionable,
   UpdateOptions as SequelizeUpdateOptions,
   WhereOperators,
@@ -30,7 +31,7 @@ import { HasOneRepository } from './relation-repository/hasone-repository';
 import { RelationRepository } from './relation-repository/relation-repository';
 import { updateAssociations, updateModelByValues } from './update-associations';
 import { UpdateGuard } from './update-guard';
-import { handleAppendsQuery } from './utils';
+import { EagerLoadingTree } from './eager-loading/eager-loading-tree';
 
 const debug = require('debug')('noco-database');
 
@@ -189,10 +190,6 @@ class RelationRepositoryBuilder<R extends RelationRepository> {
     }
   }
 
-  protected builder() {
-    return this.builderMap;
-  }
-
   of(id: string | number): R {
     if (!this.association) {
       return;
@@ -200,6 +197,17 @@ class RelationRepositoryBuilder<R extends RelationRepository> {
     const klass = this.builder()[this.association.associationType];
     return new klass(this.collection, this.associationName, id);
   }
+
+  protected builder() {
+    return this.builderMap;
+  }
+}
+
+export interface AggregateOptions {
+  method: 'avg' | 'count' | 'min' | 'max' | 'sum';
+  field?: string;
+  filter?: Filter;
+  distinct?: boolean;
 }
 
 export class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes>
@@ -259,6 +267,59 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     return count;
   }
 
+  async aggregate(options: AggregateOptions & { optionsTransformer?: (options: any) => any }): Promise<any> {
+    const { method, field } = options;
+
+    const queryOptions = this.buildQueryOptions({
+      ...options,
+      fields: [],
+    });
+
+    options.optionsTransformer?.(queryOptions);
+    const hasAssociationFilter = () => {
+      if (queryOptions.include && queryOptions.include.length > 0) {
+        const filterInclude = queryOptions.include.filter((include) => {
+          return (
+            Object.keys(include.where || {}).length > 0 ||
+            JSON.stringify(queryOptions?.filter)?.includes(include.association)
+          );
+        });
+        return filterInclude.length > 0;
+      }
+      return false;
+    };
+
+    if (hasAssociationFilter()) {
+      const primaryKeyField = this.model.primaryKeyAttribute;
+      const queryInterface = this.database.sequelize.getQueryInterface();
+
+      const findOptions = {
+        ...queryOptions,
+        raw: true,
+        includeIgnoreAttributes: false,
+        attributes: [
+          [
+            Sequelize.literal(
+              `DISTINCT ${queryInterface.quoteIdentifiers(`${this.collection.name}.${primaryKeyField}`)}`,
+            ),
+            primaryKeyField,
+          ],
+        ],
+      };
+
+      const ids = await this.model.findAll(findOptions);
+
+      return await this.model.aggregate(field, method, {
+        ...lodash.omit(queryOptions, ['where', 'include']),
+        where: {
+          [primaryKeyField]: ids.map((node) => node[primaryKeyField]),
+        },
+      });
+    }
+
+    return await this.model.aggregate(field, method, queryOptions);
+  }
+
   /**
    * find
    * @param options
@@ -300,38 +361,20 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         return [];
       }
 
-      // find template model
-      const templateModel = await model.findOne({
-        ...opts,
-        includeIgnoreAttributes: false,
-        attributes: [primaryKeyField],
-        group: `${model.name}.${primaryKeyField}`,
-        transaction,
-        limit: 1,
-        offset: 0,
-      } as any);
+      // find all rows
+      const eagerLoadingTree = EagerLoadingTree.buildFromSequelizeOptions({
+        model,
+        rootAttributes: opts.attributes,
+        includeOption: opts.include,
+        rootOrder: opts.order,
+      });
 
-      const where = {
-        [primaryKeyField]: {
-          [Op.in]: ids.map((id) => id['pk']),
-        },
-      };
+      await eagerLoadingTree.load(
+        ids.map((i) => i.pk),
+        transaction,
+      );
 
-      rows = await handleAppendsQuery({
-        queryPromises: opts.include.map((include) => {
-          const options = {
-            ...omit(opts, ['limit', 'offset', 'filter']),
-            include: include,
-            where,
-            transaction,
-          };
-
-          return model.findAll(options).then((rows) => {
-            return { rows, include };
-          });
-        }),
-        templateModel: templateModel,
-      });
+      rows = eagerLoadingTree.root.instances;
     } else {
       rows = await model.findAll({
         ...opts,