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

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
+    `;
+  }
+}

package/src/update-guard.ts

@@ -10,6 +10,7 @@ type UpdateValues = {
 };
 
 type UpdateAction = 'create' | 'update';
+
 export class UpdateGuard {
   model: ModelStatic<any>;
   action: UpdateAction;
@@ -18,6 +19,21 @@ export class UpdateGuard {
   private blackList: BlackList;
   private whiteList: WhiteList;
 
+  static fromOptions(model, options) {
+    const guard = new UpdateGuard();
+    guard.setModel(model);
+    guard.setWhiteList(options.whitelist);
+    guard.setBlackList(options.blacklist);
+    guard.setAction(lodash.get(options, 'action', 'update'));
+    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+
+    if (options.underscored) {
+      guard.underscored = options.underscored;
+    }
+
+    return guard;
+  }
+
   setAction(action: UpdateAction) {
     this.action = action;
   }
@@ -78,6 +94,10 @@ export class UpdateGuard {
       let associationValues = associationsValues[association];
 
       const filterAssociationToBeUpdate = (value) => {
+        if (value === null) {
+          return value;
+        }
+
         const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
 
         if (associationKeysToBeUpdate.includes(association)) {
@@ -111,7 +131,7 @@ export class UpdateGuard {
 
       if (Array.isArray(associationValues)) {
         associationValues = associationValues.map((value) => {
-          if (typeof value == 'string' || typeof value == 'number') {
+          if (value === undefined || value === null || typeof value == 'string' || typeof value == 'number') {
             return value;
           } else {
             return sanitizeValue(value);
@@ -155,19 +175,4 @@ export class UpdateGuard {
 
     return result;
   }
-
-  static fromOptions(model, options) {
-    const guard = new UpdateGuard();
-    guard.setModel(model);
-    guard.setWhiteList(options.whitelist);
-    guard.setBlackList(options.blacklist);
-    guard.setAction(lodash.get(options, 'action', 'update'));
-    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
-
-    if (options.underscored) {
-      guard.underscored = options.underscored;
-    }
-
-    return guard;
-  }
 }

package/src/utils.ts

@@ -1,69 +1,8 @@
 import crypto from 'crypto';
 import Database from './database';
 import { IdentifierError } from './errors/identifier-error';
-import { Model } from './model';
 import lodash from 'lodash';
 
-type HandleAppendsQueryOptions = {
-  templateModel: any;
-  queryPromises: Array<any>;
-};
-
-export async function handleAppendsQuery(options: HandleAppendsQueryOptions) {
-  const { templateModel, queryPromises } = options;
-
-  if (!templateModel) {
-    return [];
-  }
-
-  const primaryKey = templateModel.constructor.primaryKeyAttribute;
-
-  const results = await Promise.all(queryPromises);
-
-  let rows: Array<Model>;
-
-  for (const appendedResult of results) {
-    if (!rows) {
-      rows = appendedResult.rows;
-
-      if (rows.length == 0) {
-        return [];
-      }
-
-      const modelOptions = templateModel['_options'];
-      for (const row of rows) {
-        row['_options'] = {
-          ...row['_options'],
-          include: modelOptions['include'],
-          includeNames: modelOptions['includeNames'],
-          includeMap: modelOptions['includeMap'],
-        };
-      }
-      continue;
-    }
-
-    for (let i = 0; i < appendedResult.rows.length; i++) {
-      const appendingRow = appendedResult.rows[i];
-      const key = appendedResult.include.association;
-      const val = appendingRow.get(key);
-
-      const rowKey = appendingRow.get(primaryKey);
-
-      const targetIndex = rows.findIndex((row) => row.get(primaryKey) === rowKey);
-
-      if (targetIndex === -1) {
-        throw new Error('target row not found');
-      }
-
-      rows[targetIndex].set(key, val, {
-        raw: true,
-      });
-    }
-  }
-
-  return rows;
-}
-
 export function md5(value: string) {
   return crypto.createHash('md5').update(value).digest('hex');
 }