@nocobase/database 3.0.0-alpha.5 → 3.0.0-alpha.7

package/lib/collection.d.ts

@@ -136,6 +136,8 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     setSortable(sortable: any): void;
     updateField(name: string, options: FieldOptions): void;
     private normalizeFieldName;
+    private findAttributeByIndexField;
+    private normalizeIndexFields;
     addIndex(index: string | string[] | {
         fields: string[];
         unique?: boolean;

package/lib/collection.js

@@ -607,6 +607,20 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     }
     return Array.isArray(val) ? val.map((v) => (0, import_utils.snakeCase)(v)) : (0, import_utils.snakeCase)(val);
   }
+  findAttributeByIndexField(field) {
+    var _a;
+    const attributes = this.model.getAttributes();
+    const normalizedField = this.normalizeFieldName(field);
+    return (_a = Object.entries(attributes).find(([name, attribute]) => {
+      return this.normalizeFieldName(name) === normalizedField || attribute.field === normalizedField;
+    })) == null ? void 0 : _a[1];
+  }
+  normalizeIndexFields(fields) {
+    return fields.map((field) => {
+      const attribute = this.findAttributeByIndexField(field);
+      return (attribute == null ? void 0 : attribute.field) || this.normalizeFieldName(field);
+    });
+  }
   addIndex(index) {
     if (!index) {
       return;
@@ -628,19 +642,22 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       indexItem = index;
       indexName = index.fields;
     }
-    if (import_lodash.default.isEqual(this.model.primaryKeyAttributes, indexName)) {
+    const normalizedIndexName = this.normalizeIndexFields(indexName);
+    const normalizedPrimaryKeyAttributes = this.normalizeIndexFields(this.model.primaryKeyAttributes);
+    if (import_lodash.default.isEqual(normalizedPrimaryKeyAttributes, normalizedIndexName)) {
       return;
     }
-    const name = this.model.primaryKeyAttributes.join(",");
-    if (name.startsWith(`${indexName.join(",")},`)) {
+    const name = normalizedPrimaryKeyAttributes.join(",");
+    if (name.startsWith(`${normalizedIndexName.join(",")},`)) {
       return;
     }
     for (const item of indexes) {
-      if (import_lodash.default.isEqual(this.normalizeFieldName(item.fields), this.normalizeFieldName(indexName))) {
+      const normalizedFields = this.normalizeIndexFields(item.fields);
+      if (import_lodash.default.isEqual(normalizedFields, normalizedIndexName)) {
         return;
       }
-      const name2 = item.fields.join(",");
-      if (name2.startsWith(`${indexName.join(",")},`)) {
+      const name2 = normalizedFields.join(",");
+      if (name2.startsWith(`${normalizedIndexName.join(",")},`)) {
         return;
       }
     }
@@ -675,6 +692,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     const attributes = {};
     for (const [name, field] of Object.entries(this.model.getAttributes())) {
       attributes[this.normalizeFieldName(name)] = field;
+      attributes[field.field] = field;
     }
     this.model._indexes = import_lodash.default.uniqBy(
       indexes.filter((item) => {

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

@@ -50,6 +50,23 @@ const pushAttribute = /* @__PURE__ */ __name((node, attribute) => {
     node.attributes.push(attribute);
   }
 }, "pushAttribute");
+const getRootModelOrderFields = /* @__PURE__ */ __name((node) => {
+  if (!import_lodash.default.isArray(node.order)) {
+    return [];
+  }
+  const fields = [];
+  for (const orderItem of node.order) {
+    if (!import_lodash.default.isArray(orderItem) || orderItem.length !== 2 || !import_lodash.default.isString(orderItem[0])) {
+      continue;
+    }
+    const fieldName = orderItem[0];
+    const attribute = node.model.rawAttributes[fieldName] || Object.values(node.model.rawAttributes).find((item) => item.field === fieldName);
+    if (attribute) {
+      fields.push(attribute.field || fieldName);
+    }
+  }
+  return fields;
+}, "getRootModelOrderFields");
 const EagerLoadingNodeProto = {
   afterBuild(db) {
     const collection = db.modelCollection.get(this.model);
@@ -218,11 +235,15 @@ const _EagerLoadingTree = class _EagerLoadingTree {
           if (!primaryKeyField) {
             throw new Error(`Model ${node.model.name} does not have primary key`);
           }
+          const group = [`${node.model.name}.${primaryKeyField}`];
+          if (this.db.inDialect("mssql") || this.db.isMySQLCompatibleDialect()) {
+            group.push(...getRootModelOrderFields(node).map((field) => `${node.model.name}.${field}`));
+          }
           const ids2 = (await node.model.findAll({
             ...this.rootQueryOptions,
             includeIgnoreAttributes: false,
             attributes: [primaryKeyField],
-            group: `${node.model.name}.${primaryKeyField}`,
+            group: import_lodash.default.uniq(group),
             transaction,
             include: (0, import_utils.processIncludes)(includeForFilter, node.model),
             raw: true

package/lib/sync-runner.d.ts

@@ -35,6 +35,10 @@ export declare class SyncRunner {
     isParentColumn(columnName: string, options: any): Promise<boolean>;
     removeUnusedColumns(columns: any, options: any): Promise<void>;
     findAttributeByColumnName(columnName: string): any;
+    private getIndexFields;
+    private indexExists;
+    private deduplicateIndexes;
+    private filterExistingIndexesBeforeSync;
     performSync(options: any): Promise<any>;
     handleZeroColumnModel(options: any): Promise<void>;
     handleSchema(options: any): Promise<void>;

package/lib/sync-runner.js

@@ -286,8 +286,52 @@ const _SyncRunner = class _SyncRunner {
       return attribute.field == columnName;
     });
   }
+  getIndexFields(index) {
+    return (index.fields || []).map((field) => {
+      if (typeof field === "string") {
+        return field;
+      }
+      return field.attribute || field.name;
+    });
+  }
+  indexExists(modelIndex, existingIndexes) {
+    const modelIndexFields = this.getIndexFields(modelIndex);
+    return existingIndexes.some((existingIndex) => {
+      if (modelIndex.name && existingIndex.name === modelIndex.name) {
+        return true;
+      }
+      return Boolean(modelIndex.unique) === Boolean(existingIndex.unique) && JSON.stringify(modelIndexFields) === JSON.stringify(this.getIndexFields(existingIndex));
+    });
+  }
+  deduplicateIndexes(indexes) {
+    return indexes.filter((index, indexPosition) => {
+      return indexes.findIndex((item) => this.indexExists(index, [item])) === indexPosition;
+    });
+  }
+  async filterExistingIndexesBeforeSync(options) {
+    const indexes = this.model["_indexes"];
+    if (!(indexes == null ? void 0 : indexes.length)) {
+      return;
+    }
+    const deduplicatedIndexes = this.deduplicateIndexes(indexes);
+    this.model["_indexes"] = deduplicatedIndexes;
+    try {
+      const existingIndexes = await this.queryInterface.showIndex(this.tableName, options);
+      this.model["_indexes"] = deduplicatedIndexes.filter((index) => !this.indexExists(index, existingIndexes));
+    } catch (error) {
+    }
+  }
   async performSync(options) {
-    return this.collection.isInherited() ? await import_inherited_sync_runner.InheritedSyncRunner.syncInheritModel(this.model, options) : await import_sequelize.Model.sync.call(this.model, options);
+    if (this.collection.isInherited()) {
+      return await import_inherited_sync_runner.InheritedSyncRunner.syncInheritModel(this.model, options);
+    }
+    const indexes = this.model["_indexes"];
+    try {
+      await this.filterExistingIndexesBeforeSync(options);
+      return await import_sequelize.Model.sync.call(this.model, options);
+    } finally {
+      this.model["_indexes"] = indexes;
+    }
   }
   async handleZeroColumnModel(options) {
     if (Object.keys(this.model.tableAttributes).length === 0) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.7",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "3.0.0-alpha.5",
-    "@nocobase/utils": "3.0.0-alpha.5",
+    "@nocobase/logger": "3.0.0-alpha.7",
+    "@nocobase/utils": "3.0.0-alpha.7",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -38,5 +38,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "82c7ed1cdb2f247c190582e34ee37f154cac0968"
+  "gitHead": "19cd28c710f3b3c614ebe2fd7d5a415d527ee559"
 }