@nocobase/database 2.0.0-alpha.8 → 2.1.0-alpha.1

package/lib/belongs-to-array/belongs-to-array-repository.d.ts

@@ -12,7 +12,6 @@ import { FindOptions } from '../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;
@@ -35,7 +34,6 @@ export declare class BelongsToArrayAssociation {
     generateInclude(parentAs?: string): {
         on: void;
     };
-    update(instance: Model, value: any, options?: UpdateAssociationOptions): Promise<void>;
 }
 export declare class BelongsToArrayRepository extends MultipleRelationRepository {
     private belongsToArrayAssociation;

package/lib/belongs-to-array/belongs-to-array-repository.js

@@ -94,19 +94,6 @@ const _BelongsToArrayAssociation = class _BelongsToArrayAssociation {
       on: this.db.queryInterface.generateJoinOnForJSONArray(left, 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;

package/lib/collection.d.ts

@@ -93,9 +93,6 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     validate(options: {
         values: Record<string, any> | Record<string, any>[];
         operation: 'create' | 'update';
-        context: {
-            t: Function;
-        };
     }): void;
     isMultiFilterTargetKey(): boolean;
     tableName(): any;
@@ -129,6 +126,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     updateOptions(options: CollectionOptions, mergeOptions?: any): this;
     setSortable(sortable: any): void;
     updateField(name: string, options: FieldOptions): void;
+    private normalizeFieldName;
     addIndex(index: string | string[] | {
         fields: string[];
         unique?: boolean;

package/lib/collection.js

@@ -58,6 +58,7 @@ var import_model = require("./model");
 var import_repository = require("./repository");
 var import_utils = require("./utils");
 var import_field_validation = require("./utils/field-validation");
+var import_joi = __toESM(require("joi"));
 function EnsureAtomicity(target, propertyKey, descriptor) {
   const originalMethod = descriptor.value;
   descriptor.value = function(...args) {
@@ -161,50 +162,33 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     }
   }
   validate(options) {
-    const { values: updateValues, context, operation } = options;
+    const { values: updateValues, operation } = options;
     if (!updateValues) {
       return;
     }
     const values = Array.isArray(updateValues) ? updateValues : [updateValues];
-    const { t } = context || { t: /* @__PURE__ */ __name((key, options2) => key, "t") };
-    const unwrapTplLabel = /* @__PURE__ */ __name((label) => {
-      if (typeof label !== "string") return label;
-      const m = label.match(/^[\s\t]*\{\{\s*t\(\s*(['"])(.*?)\1(?:\s*,[\s\S]*)?\)\s*\}\}[\s\t]*$/);
-      return m ? m[2] : label;
-    }, "unwrapTplLabel");
     const helper = /* @__PURE__ */ __name((field, value) => {
-      var _a, _b, _c;
+      var _a, _b;
       const val = value[field.name];
       if (!field.options.validation) {
         return;
       }
-      const fieldLabel = unwrapTplLabel(((_a = field.options.uiSchema) == null ? void 0 : _a.title) || field.name);
       if (field instanceof import_fields.RelationField) {
-        if ((_b = field.options) == null ? void 0 : _b.validation.rules) {
-          const isRequired = (_c = field.options) == null ? void 0 : _c.validation.rules.some((rule) => rule.name === "required");
-          if (isRequired && !val) {
-            throw new Error(
-              t("{{#label}} is required", {
-                ns: "client",
-                "#label": `${t("Collection", { ns: "client" })}: ${this.name}, ${t("Field", { ns: "client" })}: ${t(
-                  fieldLabel,
-                  { ns: "client" }
-                )}`
-              })
-            );
+        const rules = ((_b = (_a = field.options) == null ? void 0 : _a.validation) == null ? void 0 : _b.rules) || [];
+        const required = rules.some((rule) => rule.name === "required");
+        if (required) {
+          const { error: error2 } = import_joi.default.any().empty(null).required().label(`${this.name}.${field.name}`).validate(val);
+          if (error2) {
+            throw error2;
           }
         }
         return;
       }
       const joiSchema = (0, import_field_validation.buildJoiSchema)(field.options.validation, {
-        label: `${t("Collection", { ns: "client" })}: ${this.name}, ${t("Field", { ns: "client" })}: ${t(fieldLabel, {
-          ns: "client"
-        })}`,
+        label: `${this.name}.${field.name}`,
         value: val
       });
-      const { error } = joiSchema.validate(val, {
-        messages: (0, import_field_validation.getJoiErrorMessage)(t)
-      });
+      const { error } = joiSchema.validate(val);
       if (error) {
         throw error;
       }
@@ -311,6 +295,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     this.model.options.modelName = this.options.name;
     if (!autoGenId) {
       this.model.removeAttribute("id");
+      this.model.autoIncrementAttribute = null;
     }
     this.model.database = this.context.database;
     this.model.collection = this;
@@ -613,6 +598,12 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     }
     this.setField(options.name || name, options);
   }
+  normalizeFieldName(val) {
+    if (!this.options.underscored) {
+      return val;
+    }
+    return Array.isArray(val) ? val.map((v) => (0, import_utils.snakeCase)(v)) : (0, import_utils.snakeCase)(val);
+  }
   addIndex(index) {
     if (!index) {
       return;
@@ -642,7 +633,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       return;
     }
     for (const item of indexes) {
-      if (import_lodash.default.isEqual(item.fields, indexName)) {
+      if (import_lodash.default.isEqual(this.normalizeFieldName(item.fields), this.normalizeFieldName(indexName))) {
         return;
       }
       const name2 = item.fields.join(",");
@@ -678,11 +669,21 @@ const _Collection = class _Collection extends import_events.EventEmitter {
    */
   refreshIndexes() {
     const indexes = this.model._indexes;
+    const attributes = {};
+    for (const [name, field] of Object.entries(this.model.getAttributes())) {
+      attributes[this.normalizeFieldName(name)] = field;
+    }
     this.model._indexes = import_lodash.default.uniqBy(
       indexes.filter((item) => {
-        return item.fields.every((field) => this.model.rawAttributes[field]);
+        return item.fields.every((field) => {
+          const name = this.normalizeFieldName(field);
+          return attributes[name];
+        });
       }).map((item) => {
-        item.fields = item.fields.map((field) => this.model.rawAttributes[field].field);
+        item.fields = item.fields.map((field) => {
+          const name = this.normalizeFieldName(field);
+          return attributes[name].field;
+        });
         return item;
       }),
       "name"

package/lib/database.d.ts

@@ -215,6 +215,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     private registerCollectionType;
     quoteIdentifier(identifier: string): string;
     quoteTable(tableName: string): string;
+    private runSQLWithSchema;
     runSQL(sql: string, options?: RunSQLOptions): Promise<any>;
 }
 export declare function extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): {

package/lib/database.js

@@ -287,8 +287,8 @@ const _Database = class _Database extends import_events.EventEmitter {
    */
   initListener() {
     this.on("afterConnect", async (client) => {
-      if (this.inDialect("postgres")) {
-        await client.query("SET search_path = public");
+      if (this.isPostgresCompatibleDialect()) {
+        await client.query("SET search_path TO public");
       }
     });
     this.on("beforeDefine", (model, options) => {
@@ -431,18 +431,14 @@ const _Database = class _Database extends import_events.EventEmitter {
    */
   collection(options) {
     options = import_lodash.default.cloneDeep(options);
-    if (typeof options.underscored !== "boolean") {
-      if (this.options.underscored) {
-        options.underscored = true;
-      }
-    }
+    options.underscored = options.underscored ?? this.options.underscored;
     this.logger.trace(`beforeDefineCollection: ${(0, import_safe_json_stringify.default)(options)}`, {
       databaseInstanceId: this.instanceId
     });
     this.emit("beforeDefineCollection", options);
     const collection = this.collectionFactory.createCollection(options);
     this.collections.set(collection.name, collection);
-    this.emit("afterDefineCollection", collection);
+    this.emit("afterDefineCollection", collection, { fieldModels: options.fieldModels });
     return collection;
   }
   getTablePrefix() {
@@ -491,6 +487,9 @@ const _Database = class _Database extends import_events.EventEmitter {
   }
   removeCollection(name) {
     const collection = this.collections.get(name);
+    if (!collection) {
+      return;
+    }
     this.emit("beforeRemoveCollection", collection);
     collection.resetFields();
     const result = this.collections.delete(name);
@@ -791,18 +790,28 @@ const _Database = class _Database extends import_events.EventEmitter {
   quoteTable(tableName) {
     return this.sequelize.getQueryInterface().quoteIdentifiers(tableName);
   }
+  async runSQLWithSchema(finalSQL, bind, transaction) {
+    if (!this.options.schema || !this.isPostgresCompatibleDialect()) {
+      return this.sequelize.query(finalSQL, { bind, transaction });
+    }
+    const execute = /* @__PURE__ */ __name(async (t) => {
+      await this.sequelize.query(`SET LOCAL search_path TO ${this.options.schema}`, { transaction: t });
+      return this.sequelize.query(finalSQL, { bind, transaction: t });
+    }, "execute");
+    return transaction ? execute(transaction) : this.sequelize.transaction(execute);
+  }
   async runSQL(sql, options = {}) {
     const { filter, bind, type, transaction } = options;
     let finalSQL = sql;
     if (!finalSQL.replace(/\s+/g, " ").trim()) {
       throw new Error("SQL cannot be empty");
     }
+    const queryGenerator = this.sequelize.getQueryInterface().queryGenerator;
     if (filter) {
       let where = {};
       const tmpCollection = new import_collection.Collection({ name: "tmp", underscored: false }, { database: this });
       const r = tmpCollection.repository;
       where = r.buildQueryOptions({ filter }).where;
-      const queryGenerator = this.sequelize.getQueryInterface().queryGenerator;
       const wSQL = queryGenerator.getWhereConditions(where, null, null, { bindParam: true });
       if (wSQL) {
         let normalizedSQL = sql.replace(/\s+/g, " ").trim();
@@ -813,7 +822,7 @@ const _Database = class _Database extends import_events.EventEmitter {
       }
     }
     this.logger.debug("runSQL", { finalSQL });
-    const result = await this.sequelize.query(finalSQL, { bind, transaction });
+    const result = await this.runSQLWithSchema(finalSQL, bind, transaction);
     let data = result[0];
     if (type === "selectVar") {
       if (Array.isArray(data)) {

package/lib/dialects/mariadb-dialect.js

@@ -35,7 +35,12 @@ module.exports = __toCommonJS(mariadb_dialect_exports);
 var import_base_dialect = require("./base-dialect");
 const _MariadbDialect = class _MariadbDialect extends import_base_dialect.BaseDialect {
   getSequelizeOptions(options) {
-    options.dialectOptions = { ...options.dialectOptions || {}, supportBigNumbers: true, bigNumberStrings: true };
+    options.dialectOptions = {
+      ...options.dialectOptions || {},
+      multipleStatements: true,
+      supportBigNumbers: true,
+      bigNumberStrings: true
+    };
     return options;
   }
   getVersionGuard() {

package/lib/dialects/postgres-dialect.js

@@ -52,9 +52,6 @@ const _PostgresDialect = class _PostgresDialect extends import_base_dialect.Base
     if (!options.hooks["afterConnect"]) {
       options.hooks["afterConnect"] = [];
     }
-    options.hooks["afterConnect"].push(async (connection) => {
-      await connection.query("SET search_path TO public;");
-    });
     return options;
   }
   getVersionGuard() {

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

@@ -78,7 +78,7 @@ const queryParentSQL = /* @__PURE__ */ __name((options) => {
   return `WITH RECURSIVE cte AS (
       SELECT ${q(targetKeyField)}, ${q(foreignKeyField)}
       FROM ${tableName}
-      WHERE ${q(targetKeyField)} IN (${nodeIds.join(",")})
+      WHERE ${q(targetKeyField)} IN ('${nodeIds.join("','")}')
       UNION ALL
       SELECT t.${q(targetKeyField)}, t.${q(foreignKeyField)}
       FROM ${tableName} AS t
@@ -215,7 +215,8 @@ const _EagerLoadingTree = class _EagerLoadingTree {
             attributes: [primaryKeyField],
             group: `${node.model.name}.${primaryKeyField}`,
             transaction,
-            include: (0, import_utils.processIncludes)(includeForFilter, node.model)
+            include: (0, import_utils.processIncludes)(includeForFilter, node.model),
+            raw: true
           })).map((row) => {
             return { row, pk: row[primaryKeyField] };
           });

package/lib/fields/field.js

@@ -131,12 +131,16 @@ const _Field = class _Field {
     Object.assign(this.options, obj);
   }
   bind() {
+    var _a;
     const { model } = this.context.collection;
     model.rawAttributes[this.name] = this.toSequelize();
     model.refreshAttributes();
     if (this.options.index) {
       this.context.collection.addIndex([this.name]);
     }
+    if (((_a = this.options) == null ? void 0 : _a.autoIncrement) === true && !model.autoIncrementAttribute) {
+      model._findAutoIncrementAttribute();
+    }
   }
   unbind() {
     const { model } = this.context.collection;

package/lib/fields/index.d.ts

@@ -27,7 +27,6 @@ import { UidFieldOptions } from './uid-field';
 import { UUIDFieldOptions } from './uuid-field';
 import { VirtualFieldOptions } from './virtual-field';
 import { NanoidFieldOptions } from './nanoid-field';
-import { EncryptionField } from './encryption-field';
 import { UnixTimestampFieldOptions } from './unix-timestamp-field';
 import { DateOnlyFieldOptions } from './date-only-field';
 import { DatetimeNoTzFieldOptions } from './datetime-no-tz-field';
@@ -59,7 +58,6 @@ export * from './uid-field';
 export * from './uuid-field';
 export * from './virtual-field';
 export * from './nanoid-field';
-export * from './encryption-field';
 export * from './unix-timestamp-field';
 export * from './snowflake-id-field';
-export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | DatetimeTzFieldOptions | DatetimeNoTzFieldOptions | DateOnlyFieldOptions | UnixTimestampFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions | EncryptionField | SnowflakeIdFieldOptions;
+export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | DatetimeTzFieldOptions | DatetimeNoTzFieldOptions | DateOnlyFieldOptions | UnixTimestampFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions | SnowflakeIdFieldOptions;

package/lib/fields/index.js

@@ -49,7 +49,6 @@ __reExport(fields_exports, require("./uid-field"), module.exports);
 __reExport(fields_exports, require("./uuid-field"), module.exports);
 __reExport(fields_exports, require("./virtual-field"), module.exports);
 __reExport(fields_exports, require("./nanoid-field"), module.exports);
-__reExport(fields_exports, require("./encryption-field"), module.exports);
 __reExport(fields_exports, require("./unix-timestamp-field"), module.exports);
 __reExport(fields_exports, require("./snowflake-id-field"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
@@ -80,7 +79,6 @@ __reExport(fields_exports, require("./snowflake-id-field"), module.exports);
   ...require("./uuid-field"),
   ...require("./virtual-field"),
   ...require("./nanoid-field"),
-  ...require("./encryption-field"),
   ...require("./unix-timestamp-field"),
   ...require("./snowflake-id-field")
 });

package/lib/fields/snowflake-id-field.js

@@ -49,9 +49,17 @@ const _SnowflakeIdField = class _SnowflakeIdField extends import_field.Field {
     }
   }
   init() {
-    const { name } = this.options;
-    this.listener = (instance) => this.setId(name, instance);
+    const { name, autoFill } = this.options;
+    this.listener = (instance) => {
+      if (autoFill === false) {
+        return;
+      }
+      this.setId(name, instance);
+    };
     this.bulkListener = async (instances) => {
+      if (autoFill === false) {
+        return;
+      }
       for (const instance of instances) {
         this.setId(name, instance);
       }

package/lib/index.d.ts

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export { BaseError, BelongsToGetAssociationMixin, DataTypes, fn, HasManyCountAssociationsMixin, HasManyCreateAssociationMixin, HasManyGetAssociationsMixin, literal, ModelStatic, Op, SyncOptions, Transaction, UniqueConstraintError, ValidationError, ValidationErrorItem, where, } from 'sequelize';
+export { ValidationError as JoiValidationError } from 'joi';
 export * from './belongs-to-array/belongs-to-array-repository';
 export * from './collection';
 export * from './collection-group-manager';
@@ -35,11 +36,12 @@ export * from './repository';
 export * from './relation-repository/relation-repository';
 export { default as sqlParser, SQLParserTypes } from './sql-parser';
 export * from './update-associations';
-export { snakeCase } from './utils';
+export { snakeCase, extractTypeFromDefinition } from './utils';
 export * from './value-parsers';
 export * from './view-collection';
 export { default as fieldTypeMap } from './view/field-type-map';
 export * from './view/view-inference';
 export * from './update-guard';
+export { TableInfo } from './query-interface/query-interface';
 export { default as operators } from './operators';
 export { filterIncludes, mergeIncludes } from './utils/filter-include';

package/lib/index.js

@@ -44,15 +44,18 @@ __export(src_exports, {
   HasManyCountAssociationsMixin: () => import_sequelize.HasManyCountAssociationsMixin,
   HasManyCreateAssociationMixin: () => import_sequelize.HasManyCreateAssociationMixin,
   HasManyGetAssociationsMixin: () => import_sequelize.HasManyGetAssociationsMixin,
+  JoiValidationError: () => import_joi.ValidationError,
   ModelStatic: () => import_sequelize.ModelStatic,
   Op: () => import_sequelize.Op,
   SQLParserTypes: () => import_sql_parser.SQLParserTypes,
   SyncOptions: () => import_sequelize.SyncOptions,
+  TableInfo: () => import_query_interface.TableInfo,
   Transaction: () => import_sequelize.Transaction,
   UniqueConstraintError: () => import_sequelize.UniqueConstraintError,
   ValidationError: () => import_sequelize.ValidationError,
   ValidationErrorItem: () => import_sequelize.ValidationErrorItem,
   default: () => import_database.Database,
+  extractTypeFromDefinition: () => import_utils.extractTypeFromDefinition,
   fieldTypeMap: () => import_field_type_map.default,
   filterIncludes: () => import_filter_include.filterIncludes,
   fn: () => import_sequelize.fn,
@@ -65,6 +68,7 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_sequelize = require("sequelize");
+var import_joi = require("joi");
 __reExport(src_exports, require("./belongs-to-array/belongs-to-array-repository"), module.exports);
 __reExport(src_exports, require("./collection"), module.exports);
 __reExport(src_exports, require("./collection-group-manager"), module.exports);
@@ -99,6 +103,7 @@ __reExport(src_exports, require("./view-collection"), module.exports);
 var import_field_type_map = __toESM(require("./view/field-type-map"));
 __reExport(src_exports, require("./view/view-inference"), module.exports);
 __reExport(src_exports, require("./update-guard"), module.exports);
+var import_query_interface = require("./query-interface/query-interface");
 var import_operators = __toESM(require("./operators"));
 var import_filter_include = require("./utils/filter-include");
 // Annotate the CommonJS export names for ESM import in node:
@@ -110,14 +115,17 @@ var import_filter_include = require("./utils/filter-include");
   HasManyCountAssociationsMixin,
   HasManyCreateAssociationMixin,
   HasManyGetAssociationsMixin,
+  JoiValidationError,
   ModelStatic,
   Op,
   SQLParserTypes,
   SyncOptions,
+  TableInfo,
   Transaction,
   UniqueConstraintError,
   ValidationError,
   ValidationErrorItem,
+  extractTypeFromDefinition,
   fieldTypeMap,
   filterIncludes,
   fn,

package/lib/interfaces/time-interface.js

@@ -47,7 +47,7 @@ import_dayjs.default.extend(import_utc.default);
 const _TimeInterface = class _TimeInterface extends import_base_interface.BaseInterface {
   toValue(value, ctx) {
     if (this.validate(value)) {
-      const result = import_dayjs.default.utc(value).format("HH:mm:ss");
+      const result = (0, import_dayjs.default)(value).format("HH:mm:ss");
       return result;
     }
     return value;

package/lib/operators/date.js

@@ -95,9 +95,6 @@ var date_default = {
       };
     }
     if (Array.isArray(r)) {
-      console.log(11111111, {
-        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0], { ctx }) }, { [import_sequelize.Op.lt]: toDate(r[1], { ctx }) }]
-      });
       return {
         [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0], { ctx }) }, { [import_sequelize.Op.lt]: toDate(r[1], { ctx }) }]
       };

package/lib/{fields/encryption-field/index.d.ts → operators/in.d.ts}

@@ -6,6 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export * from './encryption-field';
-export * from './utils';
-export * from './errors/EncryptionError';
+declare const _default: Record<string, any>;
+export default _default;

package/lib/{fields/encryption-field/errors/EncryptionError.js → operators/in.js}

@@ -11,7 +11,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -25,20 +24,17 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var EncryptionError_exports = {};
-__export(EncryptionError_exports, {
-  EncryptionError: () => EncryptionError
+var in_exports = {};
+__export(in_exports, {
+  default: () => in_default
 });
-module.exports = __toCommonJS(EncryptionError_exports);
-const _EncryptionError = class _EncryptionError extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "EncryptionError";
+module.exports = __toCommonJS(in_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var in_default = {
+  $in(val, ctx) {
+    return {
+      [import_sequelize.Op.in]: val == null ? [] : (0, import_lodash.castArray)(val)
+    };
   }
 };
-__name(_EncryptionError, "EncryptionError");
-let EncryptionError = _EncryptionError;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EncryptionError
-});

package/lib/operators/index.js

@@ -46,6 +46,7 @@ var import_empty = __toESM(require("./empty"));
 var import_string = __toESM(require("./string"));
 var import_eq = __toESM(require("./eq"));
 var import_ne = __toESM(require("./ne"));
+var import_in = __toESM(require("./in"));
 var import_notIn = __toESM(require("./notIn"));
 var import_boolean = __toESM(require("./boolean"));
 var import_child_collection = __toESM(require("./child-collection"));
@@ -57,6 +58,7 @@ var operators_default = {
   ...import_string.default,
   ...import_eq.default,
   ...import_ne.default,
+  ...import_in.default,
   ...import_notIn.default,
   ...import_boolean.default,
   ...import_child_collection.default

package/lib/options-parser.d.ts

@@ -26,7 +26,9 @@ export declare class OptionsParser {
     static appendInheritInspectAttribute(include: any, collection: any): any;
     isAssociation(key: string): boolean;
     isAssociationPath(path: string): boolean;
-    filterByTkToWhereOption(): {};
+    filterByTkToWhereOption(): string | number | import("./repository").TargetKey[] | {
+        [x: string]: import("./repository").TK;
+    };
     toSequelizeParams(options?: {
         parseSort?: boolean;
     }): any;

package/lib/options-parser.js

@@ -41,9 +41,9 @@ __export(options_parser_exports, {
 });
 module.exports = __toCommonJS(options_parser_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_qs = __toESM(require("qs"));
 var import_sequelize = require("sequelize");
 var import_filter_parser = __toESM(require("./filter-parser"));
-var import_qs = __toESM(require("qs"));
 const debug = require("debug")("noco-database");
 const _OptionsParser = class _OptionsParser {
   options;
@@ -96,14 +96,21 @@ const _OptionsParser = class _OptionsParser {
     if (!filterByTkOption) {
       return {};
     }
-    if (import_lodash.default.isPlainObject(this.options.filterByTk)) {
-      const where = {};
-      for (const [key, value] of Object.entries(filterByTkOption)) {
-        where[key] = value;
-      }
-      return where;
+    if (Array.isArray(filterByTkOption) && filterByTkOption.length === 0) {
+      return {};
     }
     const filterTargetKey = this.context.targetKey || this.collection.filterTargetKey;
+    if (Array.isArray(filterByTkOption) && Array.isArray(filterTargetKey)) {
+      if (!filterByTkOption.every(import_lodash.default.isPlainObject)) {
+        throw new Error("filterByTk array item must be plain object");
+      }
+      return {
+        [import_sequelize.Op.or]: filterByTkOption
+      };
+    }
+    if (import_lodash.default.isPlainObject(filterByTkOption)) {
+      return filterByTkOption;
+    }
     if (Array.isArray(filterTargetKey)) {
       throw new Error("multi filter target key value must be object");
     }

package/lib/relation-repository/belongs-to-many-repository.js

@@ -88,8 +88,7 @@ const _BelongsToManyRepository = class _BelongsToManyRepository extends import_m
     };
     this.collection.validate({
       values,
-      operation: "create",
-      context: options.context
+      operation: "create"
     });
     const instance = await sourceModel[createAccessor](values, createOptions);
     await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });

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

@@ -11,6 +11,7 @@ import { RelationRepository } from './relation-repository';
 import { AssociatedOptions, CountOptions, DestroyOptions, Filter, FindOptions, TargetKey, UpdateOptions, FirstOrCreateOptions } from './types';
 export declare abstract class MultipleRelationRepository extends RelationRepository {
     targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
+    private normalizeScope;
     find(options?: FindOptions): Promise<any>;
     findAndCount(options?: FindOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;

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

@@ -65,6 +65,16 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
       [this.association.foreignKey]: filterForeignKeyValue
     };
   }
+  normalizeScope(scope, model) {
+    const result = {};
+    for (const [key, value] of Object.entries(scope)) {
+      const attr = model.getAttributes()[key];
+      if (attr == null ? void 0 : attr.field) {
+        result[attr.field] = value;
+      }
+    }
+    return result;
+  }
   async find(options) {
     const targetRepository = this.targetCollection.repository;
     const association = this.association;
@@ -74,6 +84,9 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
       sourceKey: association.targetKey,
       realAs: association.through.model.name
     };
+    if (association.through.scope) {
+      oneFromTargetOptions["scope"] = this.normalizeScope(association.through.scope, association.through.model);
+    }
     const pivotAssoc = new import_sequelize.HasOne(association.target, association.through.model, oneFromTargetOptions);
     const appendFilter = {
       isPivotFilter: true,