@nocobase/database 0.9.2-alpha.4 → 0.9.3-alpha.1

package/src/repository.ts

@@ -263,7 +263,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
    * find
    * @param options
    */
-  async find(options?: FindOptions) {
+  async find(options: FindOptions = {}) {
     const model = this.collection.model;
     const transaction = await this.getTransaction(options);
 
@@ -278,6 +278,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       // @ts-ignore
       const primaryKeyField = model.primaryKeyField || model.primaryKeyAttribute;
 
+      // find all ids
       const ids = (
         await model.findAll({
           ...opts,
@@ -299,6 +300,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         return [];
       }
 
+      // find template model
       const templateModel = await model.findOne({
         ...opts,
         includeIgnoreAttributes: false,
@@ -318,7 +320,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       rows = await handleAppendsQuery({
         queryPromises: opts.include.map((include) => {
           const options = {
-            ...omit(opts, ['limit', 'offset']),
+            ...omit(opts, ['limit', 'offset', 'filter']),
             include: include,
             where,
             transaction,
@@ -351,10 +353,9 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
    * @param options
    */
   async findAndCount(options?: FindAndCountOptions): Promise<[Model[], number]> {
-    const transaction = await this.getTransaction(options);
     options = {
       ...options,
-      transaction,
+      transaction: await this.getTransaction(options),
     };
 
     const count = await this.count(options);
@@ -472,6 +473,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         records: options.values,
       });
     }
+
     const transaction = await this.getTransaction(options);
 
     const guard = UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });

package/src/tree-repository/adjacency-list-repository.ts

@@ -0,0 +1,159 @@
+import { FindOptions, Repository } from '../repository';
+import lodash from 'lodash';
+
+export class AdjacencyListRepository extends Repository {
+  async update(options): Promise<any> {
+    return super.update({
+      ...(options || {}),
+      addIndex: false,
+    });
+  }
+
+  async find(options: FindOptions & { addIndex?: boolean } = {}): Promise<any> {
+    if (options.raw || !options.tree) {
+      return await super.find(options);
+    }
+
+    const collection = this.collection;
+    const primaryKey = collection.model.primaryKeyAttribute;
+
+    if (options.fields && !options.fields.includes(primaryKey)) {
+      options.fields.push(primaryKey);
+    }
+
+    const parentNodes = await super.find(options);
+    if (parentNodes.length === 0) {
+      return [];
+    }
+
+    const { treeParentField } = collection;
+    const foreignKey = treeParentField.options.foreignKey;
+
+    const childrenKey = collection.treeChildrenField?.name ?? 'children';
+
+    const parentIds = parentNodes.map((node) => node[primaryKey]);
+
+    if (parentIds.length == 0) {
+      this.database.logger.warn('parentIds is empty');
+      return parentNodes;
+    }
+
+    const sql = this.querySQL(parentIds, collection);
+
+    const childNodes = await this.database.sequelize.query(sql, {
+      type: 'SELECT',
+      transaction: options.transaction,
+    });
+
+    const childIds = childNodes.map((node) => node[primaryKey]);
+
+    const findChildrenOptions = {
+      ...lodash.omit(options, ['limit', 'offset', 'filterByTk']),
+      filter: {
+        [primaryKey]: childIds,
+      },
+    };
+
+    if (findChildrenOptions.fields) {
+      [primaryKey, foreignKey].forEach((field) => {
+        if (!findChildrenOptions.fields.includes(field)) {
+          findChildrenOptions.fields.push(field);
+        }
+      });
+    }
+
+    const childInstances = await super.find(findChildrenOptions);
+
+    const nodeMap = {};
+
+    childInstances.forEach((node) => {
+      if (!nodeMap[`${node[foreignKey]}`]) {
+        nodeMap[`${node[foreignKey]}`] = [];
+      }
+
+      nodeMap[`${node[foreignKey]}`].push(node);
+    });
+
+    function buildTree(parentId) {
+      const children = nodeMap[parentId];
+
+      if (!children) {
+        return [];
+      }
+
+      return children.map((child) => {
+        const childrenValues = buildTree(child.id);
+        if (childrenValues.length > 0) {
+          child.setDataValue(childrenKey, childrenValues);
+        }
+        return child;
+      });
+    }
+
+    for (const parent of parentNodes) {
+      const parentId = parent[primaryKey];
+      const children = buildTree(parentId);
+      if (children.length > 0) {
+        parent.setDataValue(childrenKey, children);
+      }
+    }
+
+    this.addIndex(parentNodes, childrenKey, options);
+
+    return parentNodes;
+  }
+
+  private addIndex(treeArray, childrenKey, options) {
+    function traverse(node, index) {
+      // patch for sequelize toJSON
+      if (node._options.includeNames && !node._options.includeNames.includes(childrenKey)) {
+        node._options.includeNames.push(childrenKey);
+      }
+
+      if (options.addIndex !== false) {
+        node.setDataValue('__index', `${index}`);
+      }
+
+      const children = node.getDataValue(childrenKey);
+
+      if (children && children.length === 0) {
+        node.setDataValue(childrenKey, undefined);
+      }
+
+      if (children && children.length > 0) {
+        children.forEach((child, i) => {
+          traverse(child, `${index}.${childrenKey}.${i}`);
+        });
+      }
+    }
+
+    treeArray.forEach((tree, i) => {
+      traverse(tree, i);
+    });
+  }
+
+  private querySQL(rootIds, collection) {
+    const { treeParentField } = collection;
+    const foreignKey = treeParentField.options.foreignKey;
+    const foreignKeyField = collection.model.rawAttributes[foreignKey].field;
+
+    const primaryKey = collection.model.primaryKeyAttribute;
+
+    const queryInterface = this.database.sequelize.getQueryInterface();
+    const q = queryInterface.quoteIdentifier.bind(queryInterface);
+
+    return `
+      WITH RECURSIVE cte AS (
+        SELECT ${q(primaryKey)}, ${q(foreignKeyField)}, 1 AS level
+        FROM ${collection.quotedTableName()}
+        WHERE ${q(foreignKeyField)} IN (${rootIds.join(',')})
+        UNION ALL
+        SELECT t.${q(primaryKey)}, t.${q(foreignKeyField)}, cte.level + 1 AS level
+        FROM ${collection.quotedTableName()} t
+               JOIN cte ON t.${q(foreignKeyField)} = cte.${q(primaryKey)}
+      )
+      SELECT ${q(primaryKey)}, ${q(foreignKeyField)} as ${q(foreignKey)}, level
+      FROM cte
+    `;
+  }
+}