@nocobase/database 1.6.0-alpha.3 → 1.6.0-alpha.31

package/lib/{relation-repository → belongs-to-array}/belongs-to-array-repository.d.ts

@@ -9,9 +9,10 @@
 import { Transactionable } from 'sequelize/types';
 import { Collection } from '../collection';
 import { FindOptions } from '../repository';
-import { MultipleRelationRepository } from './multiple-relation-repository';
+import { MultipleRelationRepository } from '../relation-repository/multiple-relation-repository';
 import Database from '../database';
 import { Model } from '../model';
+import { UpdateAssociationOptions } from '../update-associations';
 export declare class BelongsToArrayAssociation {
     db: Database;
     associationType: string;
@@ -33,6 +34,7 @@ export declare class BelongsToArrayAssociation {
     generateInclude(): {
         on: import("sequelize/types/utils").Literal;
     };
+    update(instance: Model, value: any, options?: UpdateAssociationOptions): Promise<void>;
 }
 export declare class BelongsToArrayRepository extends MultipleRelationRepository {
     private belongsToArrayAssociation;

package/lib/{relation-repository → belongs-to-array}/belongs-to-array-repository.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -24,6 +26,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
@@ -39,9 +49,9 @@ __export(belongs_to_array_repository_exports, {
   BelongsToArrayRepository: () => BelongsToArrayRepository
 });
 module.exports = __toCommonJS(belongs_to_array_repository_exports);
-var import_lodash = require("lodash");
+var import_lodash = __toESM(require("lodash"));
 var import_transaction_decorator = require("../decorators/transaction-decorator");
-var import_multiple_relation_repository = require("./multiple-relation-repository");
+var import_multiple_relation_repository = require("../relation-repository/multiple-relation-repository");
 const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
   return this.collection.model.sequelize.transaction();
 });
@@ -83,6 +93,19 @@ const _BelongsToArrayAssociation = class _BelongsToArrayAssociation {
       on: this.db.sequelize.literal(`${left}=any(${right})`)
     };
   }
+  async update(instance, value, options = {}) {
+    await instance.update(
+      {
+        [this.as]: value
+      },
+      {
+        values: {
+          [this.as]: value
+        },
+        transaction: options == null ? void 0 : options.transaction
+      }
+    );
+  }
 };
 __name(_BelongsToArrayAssociation, "BelongsToArrayAssociation");
 let BelongsToArrayAssociation = _BelongsToArrayAssociation;
@@ -109,7 +132,7 @@ const _BelongsToArrayRepository = class _BelongsToArrayRepository extends import
       addFilter[targetKey] = options.filterByTk;
     }
     const findOptions = {
-      ...(0, import_lodash.omit)(options, ["filterByTk", "where", "values", "attributes"]),
+      ...import_lodash.default.omit(options, ["filterByTk", "where", "values", "attributes"]),
       filter: {
         $and: [options.filter || {}, addFilter]
       }

package/lib/collection.d.ts

@@ -29,17 +29,21 @@ export type DumpRules = BuiltInGroup | ({
 } & BaseDumpRules) | ({
     group: BuiltInGroup | string;
 } & BaseDumpRules);
+export type MigrationRule = 'overwrite' | 'skip' | 'upsert' | 'schema-only' | 'insert-ignore' | (string & {}) | null;
 export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
     name: string;
     title?: string;
     namespace?: string;
+    migrationRules?: MigrationRule[];
     dumpRules?: DumpRules;
     tableName?: string;
     inherits?: string[] | string;
     viewName?: string;
     writableView?: boolean;
+    isThrough?: boolean;
     filterTargetKey?: string | string[];
     fields?: FieldOptions[];
+    fieldSort?: string[];
     model?: string | ModelStatic<Model>;
     repository?: string | RepositoryType;
     sortable?: CollectionSortable;

package/lib/database.js

@@ -220,6 +220,7 @@ const _Database = class _Database extends import_events.EventEmitter {
       autoGenId: false,
       timestamps: false,
       dumpRules: "required",
+      migrationRules: ["schema-only", "overwrite"],
       origin: "@nocobase/database",
       fields: [{ type: "string", name: "name", primaryKey: true }]
     });

package/lib/dialects/mysql-dialect.d.ts

@@ -14,4 +14,5 @@ export declare class MysqlDialect extends BaseDialect {
         get: (v: string) => string;
         version: string;
     };
+    getSequelizeOptions(options: any): any;
 }

package/lib/dialects/mysql-dialect.js

@@ -32,6 +32,7 @@ __export(mysql_dialect_exports, {
   MysqlDialect: () => MysqlDialect
 });
 module.exports = __toCommonJS(mysql_dialect_exports);
+var import_utils = require("@nocobase/utils");
 var import_base_dialect = require("./base-dialect");
 const _MysqlDialect = class _MysqlDialect extends import_base_dialect.BaseDialect {
   getVersionGuard() {
@@ -44,6 +45,10 @@ const _MysqlDialect = class _MysqlDialect extends import_base_dialect.BaseDialec
       version: ">=8.0.17"
     };
   }
+  getSequelizeOptions(options) {
+    import_utils.lodash.set(options, "dialectOptions.multipleStatements", true);
+    return options;
+  }
 };
 __name(_MysqlDialect, "MysqlDialect");
 __publicField(_MysqlDialect, "dialectName", "mysql");

package/lib/fields/belongs-to-many-field.js

@@ -125,7 +125,10 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       Through = database.getCollection(through);
     } else {
       const throughCollectionOptions = {
-        name: through
+        name: through,
+        isThrough: true,
+        sourceCollectionName: this.collection.name,
+        targetCollectionName: this.target
       };
       if (this.collection.options.dumpRules) {
         throughCollectionOptions["dumpRules"] = this.collection.options.dumpRules;

package/lib/fields/unix-timestamp-field.js

@@ -52,7 +52,7 @@ const _UnixTimestampField = class _UnixTimestampField extends import_date_field.
     if (accuracy === "millisecond") {
       rationalNumber = 1;
     }
-    return Math.floor(new Date(val).getTime() / rationalNumber);
+    return Math.floor(typeof val === "number" ? val : new Date(val).getTime() / rationalNumber);
   }
   additionalSequelizeOptions() {
     var _a, _b, _c, _d, _e;
@@ -71,16 +71,19 @@ const _UnixTimestampField = class _UnixTimestampField extends import_date_field.
     return {
       get() {
         const value = this.getDataValue(name);
-        if (value === null || value === void 0) {
+        if (value == null) {
           return value;
         }
         return new Date(value * rationalNumber);
       },
       set(value) {
-        if (value === null || value === void 0) {
+        if (value == null) {
           this.setDataValue(name, value);
         } else {
-          this.setDataValue(name, Math.floor(new Date(value).getTime() / rationalNumber));
+          this.setDataValue(
+            name,
+            Math.floor(typeof value === "number" ? value : new Date(value).getTime() / rationalNumber)
+          );
         }
       }
     };

package/lib/filter-match.js

@@ -69,7 +69,9 @@ function filterMatch(model, where) {
     $ne: /* @__PURE__ */ __name((value, condition) => value !== condition, "$ne"),
     $in: /* @__PURE__ */ __name((value, condition) => condition.includes(value), "$in"),
     $or: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).some((condition) => filterMatch(model2, condition)), "$or"),
-    $and: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).every((condition) => filterMatch(model2, condition)), "$and")
+    $and: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).every((condition) => filterMatch(model2, condition)), "$and"),
+    // boolean
+    $isFalsy: /* @__PURE__ */ __name((value) => !value, "$isFalsy")
   };
   for (const [key, value] of Object.entries(where)) {
     if (operatorFunctions[key] !== void 0) {

package/lib/index.d.ts

@@ -26,7 +26,7 @@ export * from './relation-repository/belongs-to-repository';
 export * from './relation-repository/hasmany-repository';
 export * from './relation-repository/multiple-relation-repository';
 export * from './relation-repository/single-relation-repository';
-export * from './relation-repository/belongs-to-array-repository';
+export * from './belongs-to-array/belongs-to-array-repository';
 export * from './repository';
 export * from './update-associations';
 export { snakeCase } from './utils';

package/lib/index.js

@@ -81,7 +81,7 @@ __reExport(src_exports, require("./relation-repository/belongs-to-repository"),
 __reExport(src_exports, require("./relation-repository/hasmany-repository"), module.exports);
 __reExport(src_exports, require("./relation-repository/multiple-relation-repository"), module.exports);
 __reExport(src_exports, require("./relation-repository/single-relation-repository"), module.exports);
-__reExport(src_exports, require("./relation-repository/belongs-to-array-repository"), module.exports);
+__reExport(src_exports, require("./belongs-to-array/belongs-to-array-repository"), module.exports);
 __reExport(src_exports, require("./repository"), module.exports);
 __reExport(src_exports, require("./update-associations"), module.exports);
 var import_utils = require("./utils");
@@ -133,7 +133,7 @@ __reExport(src_exports, require("./dialects"), module.exports);
   ...require("./relation-repository/hasmany-repository"),
   ...require("./relation-repository/multiple-relation-repository"),
   ...require("./relation-repository/single-relation-repository"),
-  ...require("./relation-repository/belongs-to-array-repository"),
+  ...require("./belongs-to-array/belongs-to-array-repository"),
   ...require("./repository"),
   ...require("./update-associations"),
   ...require("./value-parsers"),

package/lib/inherited-collection.js

@@ -81,6 +81,9 @@ const _InheritedCollection = class _InheritedCollection extends import_collectio
   }
   parentFields() {
     const fields = /* @__PURE__ */ new Map();
+    if (!this.parents) {
+      return fields;
+    }
     for (const parent of this.parents) {
       if (parent.isInherited()) {
         for (const [name, field] of parent.parentFields()) {

package/lib/interfaces/datetime-interface.d.ts

@@ -8,6 +8,29 @@
  */
 import { BaseInterface } from './base-interface';
 export declare class DatetimeInterface extends BaseInterface {
+    protected parseDateString(value: string): {
+        year: string;
+        month: string;
+        day: string;
+        hour: string;
+        minute: string;
+        second: string;
+    } | {
+        year: string;
+        month: string;
+        day: string;
+        hour?: undefined;
+        minute?: undefined;
+        second?: undefined;
+    };
+    protected formatDateTimeToISO(dateInfo: {
+        year: string;
+        month: string;
+        day: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+    }): string;
     toValue(value: any, ctx?: any): Promise<any>;
     toString(value: any, ctx?: any): any;
 }

package/lib/interfaces/datetime-interface.js

@@ -62,15 +62,39 @@ function resolveTimeZoneFromCtx(ctx) {
 }
 __name(resolveTimeZoneFromCtx, "resolveTimeZoneFromCtx");
 const _DatetimeInterface = class _DatetimeInterface extends import_base_interface.BaseInterface {
+  parseDateString(value) {
+    const dateOnlyMatch = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
+    const dateTimeMatch = /^(\d{4})(\d{2})(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$/.exec(value);
+    if (dateTimeMatch) {
+      const [_, year, month, day, hour, minute, second] = dateTimeMatch;
+      return { year, month, day, hour, minute, second };
+    }
+    if (dateOnlyMatch) {
+      const [_, year, month, day] = dateOnlyMatch;
+      return { year, month, day };
+    }
+    return null;
+  }
+  formatDateTimeToISO(dateInfo) {
+    const { year, month, day, hour = "00", minute = "00", second = "00" } = dateInfo;
+    const m = (0, import_dayjs.default)(`${year}-${month}-${day} ${hour}:${minute}:${second}.000`);
+    return m.toISOString();
+  }
   async toValue(value, ctx = {}) {
     if (!value) {
       return null;
     }
+    if (typeof value === "number") {
+      const valueStr = value.toString();
+      const dateOnlyMatch = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(valueStr);
+      if (dateOnlyMatch) {
+        value = valueStr;
+      }
+    }
     if (typeof value === "string") {
-      const match = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
-      if (match) {
-        const m = (0, import_dayjs.default)(`${match[1]}-${match[2]}-${match[3]} 00:00:00.000`);
-        return m.toISOString();
+      const dateInfo = this.parseDateString(value);
+      if (dateInfo) {
+        return this.formatDateTimeToISO(dateInfo);
       }
     }
     if (import_dayjs.default.isDayjs(value)) {

package/lib/interfaces/datetime-no-tz-interface.d.ts

@@ -1,5 +1,13 @@
 import { DatetimeInterface } from './datetime-interface';
 export declare class DatetimeNoTzInterface extends DatetimeInterface {
+    protected formatDateTimeToString(dateInfo: {
+        year: string;
+        month: string;
+        day: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+    }): string;
     toValue(value: any, ctx?: any): Promise<any>;
     toString(value: any, ctx?: any): any;
 }

package/lib/interfaces/datetime-no-tz-interface.js

@@ -55,14 +55,21 @@ function isNumeric(str) {
 }
 __name(isNumeric, "isNumeric");
 const _DatetimeNoTzInterface = class _DatetimeNoTzInterface extends import_datetime_interface.DatetimeInterface {
+  formatDateTimeToString(dateInfo) {
+    const { year, month, day, hour, minute, second } = dateInfo;
+    if (hour !== void 0 && minute !== void 0 && second !== void 0) {
+      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    }
+    return `${year}-${month}-${day}`;
+  }
   async toValue(value, ctx = {}) {
     if (!value) {
       return null;
     }
     if (typeof value === "string") {
-      const match = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
-      if (match) {
-        return `${match[1]}-${match[2]}-${match[3]}`;
+      const dateInfo = this.parseDateString(value);
+      if (dateInfo) {
+        return this.formatDateTimeToString(dateInfo);
       }
     }
     if (import_dayjs.default.isDayjs(value)) {

package/lib/interfaces/to-many-interface.js

@@ -38,7 +38,7 @@ const _ToManyInterface = class _ToManyInterface extends import_base_interface.Ba
     }
     str = `${str}`.trim();
     const items = str.split(",");
-    const { filterKey, targetCollection, transaction } = ctx;
+    const { filterKey, targetCollection, transaction, field } = ctx;
     const targetInstances = await targetCollection.repository.find({
       filter: {
         [filterKey]: items
@@ -51,7 +51,17 @@ const _ToManyInterface = class _ToManyInterface extends import_base_interface.Ba
       }
     });
     const primaryKeyAttribute = targetCollection.model.primaryKeyAttribute;
-    return targetInstances.map((targetInstance) => targetInstance[primaryKeyAttribute]);
+    const targetKey = field.options.targetKey;
+    const values = targetInstances.map((targetInstance) => {
+      const result = {
+        [targetKey]: targetInstance[targetKey]
+      };
+      if (targetKey !== primaryKeyAttribute) {
+        result[primaryKeyAttribute] = targetInstance[primaryKeyAttribute];
+      }
+      return result;
+    });
+    return values;
   }
 };
 __name(_ToManyInterface, "ToManyInterface");

package/lib/operators/boolean.js

@@ -31,17 +31,30 @@ __export(boolean_exports, {
 module.exports = __toCommonJS(boolean_exports);
 var import_sequelize = require("sequelize");
 var boolean_default = {
-  $isFalsy() {
+  $isFalsy(value) {
+    if (value === true || value === "true") {
+      return {
+        [import_sequelize.Op.or]: {
+          [import_sequelize.Op.is]: null,
+          [import_sequelize.Op.eq]: false
+        }
+      };
+    }
+    return {
+      [import_sequelize.Op.eq]: true
+    };
+  },
+  $isTruly(value) {
+    if (value === true || value === "true") {
+      return {
+        [import_sequelize.Op.eq]: true
+      };
+    }
     return {
       [import_sequelize.Op.or]: {
         [import_sequelize.Op.is]: null,
         [import_sequelize.Op.eq]: false
       }
     };
-  },
-  $isTruly() {
-    return {
-      [import_sequelize.Op.eq]: true
-    };
   }
 };

package/lib/operators/string.js

@@ -36,6 +36,46 @@ function escapeLike(value) {
   return value.replace(/[_%]/g, "\\$&");
 }
 __name(escapeLike, "escapeLike");
+const getFieldName = /* @__PURE__ */ __name((ctx) => {
+  const fullNameSplit = ctx.fullName.split(".");
+  const fieldName = ctx.fieldName;
+  let columnName = fieldName;
+  const associationPath = [];
+  if (fullNameSplit.length > 1) {
+    for (let i = 0; i < fullNameSplit.length - 1; i++) {
+      associationPath.push(fullNameSplit[i]);
+    }
+  }
+  const getModelFromAssociationPath = /* @__PURE__ */ __name(() => {
+    let model2 = ctx.model;
+    for (const association of associationPath) {
+      model2 = model2.associations[association].target;
+    }
+    return model2;
+  }, "getModelFromAssociationPath");
+  const model = getModelFromAssociationPath();
+  let columnPrefix = model.name;
+  if (model.rawAttributes[fieldName]) {
+    columnName = model.rawAttributes[fieldName].field || fieldName;
+  }
+  if (associationPath.length > 0) {
+    const association = associationPath.join("->");
+    columnPrefix = association;
+  }
+  columnName = `${columnPrefix}.${columnName}`;
+  return columnName;
+}, "getFieldName");
+function getFieldExpression(value, ctx, operator) {
+  if ((0, import_utils.isPg)(ctx)) {
+    const fieldName = getFieldName(ctx);
+    const queryInterface = ctx.db.sequelize.getQueryInterface();
+    const quotedField = queryInterface.quoteIdentifiers(fieldName);
+    return import_sequelize.Sequelize.literal(`CAST(${quotedField} AS TEXT) ${operator} ${ctx.db.sequelize.escape(value)}`);
+  }
+  const op = operator === "LIKE" ? import_sequelize.Op.like : operator === "NOT LIKE" ? import_sequelize.Op.notLike : operator === "ILIKE" ? import_sequelize.Op.like : operator === "NOT ILIKE" ? import_sequelize.Op.notLike : import_sequelize.Op.like;
+  return { [op]: value };
+}
+__name(getFieldExpression, "getFieldExpression");
 var string_default = {
   $includes(value, ctx) {
     if (value === null) {
@@ -44,16 +84,14 @@ var string_default = {
       };
     }
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(item)}%`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`%${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+      );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(value)}%`
-    };
+    return getFieldExpression(`%${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notIncludes(value, ctx) {
     if (value === null) {
@@ -62,67 +100,57 @@ var string_default = {
       };
     }
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(item)}%`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`%${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+      );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(value)}%`
-    };
+    return getFieldExpression(`%${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   },
   $startsWith(value, ctx) {
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `${escapeLike(item)}%`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+      );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `${escapeLike(value)}%`
-    };
+    return getFieldExpression(`${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notStartsWith(value, ctx) {
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `${escapeLike(item)}%`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`${escapeLike(item)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+      );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `${escapeLike(value)}%`
-    };
+    return getFieldExpression(`${escapeLike(value)}%`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   },
   $endWith(value, ctx) {
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(item)}`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`%${escapeLike(item)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE")
+      );
       return {
         [import_sequelize.Op.or]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.iLike : import_sequelize.Op.like]: `%${escapeLike(value)}`
-    };
+    return getFieldExpression(`%${escapeLike(value)}`, ctx, (0, import_utils.isPg)(ctx) ? "ILIKE" : "LIKE");
   },
   $notEndWith(value, ctx) {
     if (Array.isArray(value)) {
-      const conditions = value.map((item) => ({
-        [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(item)}`
-      }));
+      const conditions = value.map(
+        (item) => getFieldExpression(`%${escapeLike(item)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE")
+      );
       return {
         [import_sequelize.Op.and]: conditions
       };
     }
-    return {
-      [(0, import_utils.isPg)(ctx) ? import_sequelize.Op.notILike : import_sequelize.Op.notLike]: `%${escapeLike(value)}`
-    };
+    return getFieldExpression(`%${escapeLike(value)}`, ctx, (0, import_utils.isPg)(ctx) ? "NOT ILIKE" : "NOT LIKE");
   }
 };

package/lib/relation-repository/hasmany-repository.d.ts

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { AggregateOptions, DestroyOptions, FindOptions, TargetKey, TK } from '../repository';
-import { AssociatedOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { MultipleRelationRepository } from './multiple-relation-repository';
+import { AssociatedOptions } from './types';
 export declare class HasManyRepository extends MultipleRelationRepository {
     find(options?: FindOptions): Promise<any>;
     aggregate(options: AggregateOptions): Promise<any>;

package/lib/relation-repository/multiple-relation-repository.d.ts

@@ -6,24 +6,20 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { MultiAssociationAccessors, Transaction, Transactionable } from 'sequelize';
-import { CommonFindOptions, CountOptions, DestroyOptions, Filter, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { MultiAssociationAccessors, Transaction } from 'sequelize';
 import { RelationRepository } from './relation-repository';
-type FindAndCountOptions = CommonFindOptions;
-export interface AssociatedOptions extends Transactionable {
-    tk?: TK;
-}
+import { AssociatedOptions, CountOptions, DestroyOptions, Filter, FindOptions, TargetKey, UpdateOptions, FirstOrCreateOptions } from './types';
 export declare abstract class MultipleRelationRepository extends RelationRepository {
     targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
     find(options?: FindOptions): Promise<any>;
-    findAndCount(options?: FindAndCountOptions): Promise<[any[], number]>;
+    findAndCount(options?: FindOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;
-    findOne(options?: FindOneOptions): Promise<any>;
+    findOne(options?: FindOptions): Promise<any>;
     remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
     update(options?: UpdateOptions): Promise<any>;
-    destroy(options?: TK | DestroyOptions): Promise<boolean>;
+    destroy(options?: TargetKey | DestroyOptions): Promise<boolean>;
     protected destroyByFilter(filter: Filter, transaction?: Transaction): Promise<boolean>;
     protected filterHasInclude(filter: Filter, options?: any): boolean;
     protected accessors(): MultiAssociationAccessors;
+    updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
 }
-export {};

package/lib/relation-repository/multiple-relation-repository.js

@@ -191,6 +191,10 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
   accessors() {
     return super.accessors();
   }
+  async updateOrCreate(options) {
+    const result = await super.updateOrCreate(options);
+    return Array.isArray(result) ? result[0] : result;
+  }
 };
 __name(_MultipleRelationRepository, "MultipleRelationRepository");
 __decorateClass([
@@ -205,6 +209,9 @@ __decorateClass([
   (0, import_relation_repository.transaction)(),
   import_target_collection_decorator.default
 ], _MultipleRelationRepository.prototype, "update", 1);
+__decorateClass([
+  (0, import_relation_repository.transaction)()
+], _MultipleRelationRepository.prototype, "updateOrCreate", 1);
 let MultipleRelationRepository = _MultipleRelationRepository;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {