@nocobase/database 2.3.0-beta.6 → 2.4.0-alpha.2

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/fields/field.js

@@ -41,7 +41,8 @@ __export(field_exports, {
 });
 module.exports = __toCommonJS(field_exports);
 var import_lodash = __toESM(require("lodash"));
-var import_utils = require("../utils");
+var import_utils = require("@nocobase/utils");
+var import_utils2 = require("../utils");
 const _Field = class _Field {
   options;
   context;
@@ -94,7 +95,7 @@ const _Field = class _Field {
       return this.options.field;
     }
     if (this.database.options.underscored) {
-      return (0, import_utils.snakeCase)(this.name);
+      return (0, import_utils2.snakeCase)(this.name);
     }
     return this.name;
   }
@@ -156,6 +157,23 @@ const _Field = class _Field {
       Object.assign(opts, { type: this.database.sequelize.normalizeDataType(this.dataType) });
     }
     Object.assign(opts, this.additionalSequelizeOptions());
+    if (this.options.interface === "richText") {
+      const { name } = this;
+      const originalSetter = opts.set;
+      const sanitizeValue = /* @__PURE__ */ __name((value) => typeof value === "string" ? (0, import_utils.sanitizeRichTextHtml)(value) : value, "sanitizeValue");
+      opts.set = function(value) {
+        if (typeof originalSetter === "function") {
+          originalSetter.call(this, sanitizeValue(value));
+          const currentValue = this.getDataValue(name);
+          const sanitizedValue = sanitizeValue(currentValue);
+          if (!Object.is(sanitizedValue, currentValue)) {
+            this.setDataValue(name, sanitizedValue);
+          }
+          return;
+        }
+        this.setDataValue(name, sanitizeValue(value));
+      };
+    }
     return opts;
   }
   additionalSequelizeOptions() {

package/lib/model.js

@@ -43,6 +43,7 @@ __export(model_exports, {
 });
 module.exports = __toCommonJS(model_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_utils = require("@nocobase/utils");
 var import_sequelize = require("sequelize");
 var import_sync_runner = require("./sync-runner");
 const _ = import_lodash.default;
@@ -65,6 +66,9 @@ const _Model = class _Model extends import_sequelize.Model {
       } else {
         result[key] = values[key];
       }
+      if ((field == null ? void 0 : field.options.interface) === "richText" && typeof result[key] === "string") {
+        result[key] = (0, import_utils.sanitizeRichTextHtml)(result[key]);
+      }
     }
     return result;
   }

package/lib/operators/string.js

@@ -32,7 +32,11 @@ __export(string_exports, {
 module.exports = __toCommonJS(string_exports);
 var import_sequelize = require("sequelize");
 var import_utils = require("./utils");
-function escapeLike(value) {
+function escapeLike(value, ctx) {
+  if (ctx.db.sequelize.getDialect() === "mssql") {
+    const escapedValue = value.replaceAll("[", "[[]");
+    return escapedValue.replace(/[%_]/g, (character) => `[${character}]`);
+  }
   return value.replace(/[_%]/g, "\\$&");
 }
 __name(escapeLike, "escapeLike");
@@ -85,13 +89,13 @@ var string_default = {
     }
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`%${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+        (item) => getFieldExpression(`%${escapeLike(item, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
       );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return getFieldExpression(`%${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
+    return getFieldExpression(`%${escapeLike(value, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notIncludes(value, ctx) {
     if (value === null) {
@@ -101,56 +105,56 @@ var string_default = {
     }
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`%${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+        (item) => getFieldExpression(`%${escapeLike(item, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
       );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return getFieldExpression(`%${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
+    return getFieldExpression(`%${escapeLike(value, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   },
   $startsWith(value, ctx) {
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+        (item) => getFieldExpression(`${escapeLike(item, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
       );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return getFieldExpression(`${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
+    return getFieldExpression(`${escapeLike(value, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notStartsWith(value, ctx) {
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+        (item) => getFieldExpression(`${escapeLike(item, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
       );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return getFieldExpression(`${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
+    return getFieldExpression(`${escapeLike(value, ctx)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   },
   $endWith(value, ctx) {
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`%${escapeLike(item)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+        (item) => getFieldExpression(`%${escapeLike(item, ctx)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
       );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return getFieldExpression(`%${escapeLike(value)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
+    return getFieldExpression(`%${escapeLike(value, ctx)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notEndWith(value, ctx) {
     if (Array.isArray(value)) {
       const conditions = value.map(
-        (item) => getFieldExpression(`%${escapeLike(item)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+        (item) => getFieldExpression(`%${escapeLike(item, ctx)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
       );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return getFieldExpression(`%${escapeLike(value)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
+    return getFieldExpression(`%${escapeLike(value, ctx)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   }
 };

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": "2.3.0-beta.6",
+  "version": "2.4.0-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "2.3.0-beta.6",
-    "@nocobase/utils": "2.3.0-beta.6",
+    "@nocobase/logger": "2.4.0-alpha.2",
+    "@nocobase/utils": "2.4.0-alpha.2",
     "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": "45b23791f5245d1417047b122d1a76764aaf5473"
+  "gitHead": "706bb81047a05f39f2ddce781ebcafeea4ec9cd5"
 }