@nocobase/database 1.4.0-alpha.20240906133133 → 1.4.0-alpha.20240910145333

package/lib/fields/unix-timestamp-field.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * 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 { DataTypes } from 'sequelize';
+import { DateField } from './date-field';
+import { BaseColumnFieldOptions } from './field';
+export declare class UnixTimestampField extends DateField {
+    get dataType(): DataTypes.BigIntDataTypeConstructor;
+    dateToValue(val: any): any;
+    additionalSequelizeOptions(): {
+        get(): any;
+        set(value: any): void;
+    };
+}
+export interface UnixTimestampFieldOptions extends BaseColumnFieldOptions {
+    type: 'unixTimestamp';
+}

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

@@ -0,0 +1,94 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unix_timestamp_field_exports = {};
+__export(unix_timestamp_field_exports, {
+  UnixTimestampField: () => UnixTimestampField
+});
+module.exports = __toCommonJS(unix_timestamp_field_exports);
+var import_sequelize = require("sequelize");
+var import_date_field = require("./date-field");
+const _UnixTimestampField = class _UnixTimestampField extends import_date_field.DateField {
+  get dataType() {
+    return import_sequelize.DataTypes.BIGINT;
+  }
+  dateToValue(val) {
+    var _a, _b, _c, _d, _e;
+    if (val === null || val === void 0) {
+      return val;
+    }
+    let { accuracy } = this.options;
+    if ((_c = (_b = (_a = this.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b["x-component-props"]) == null ? void 0 : _c.accuracy) {
+      accuracy = (_e = (_d = this.options) == null ? void 0 : _d.uiSchema["x-component-props"]) == null ? void 0 : _e.accuracy;
+    }
+    if (!accuracy) {
+      accuracy = "second";
+    }
+    let rationalNumber = 1e3;
+    if (accuracy === "millisecond") {
+      rationalNumber = 1;
+    }
+    return Math.floor(new Date(val).getTime() / rationalNumber);
+  }
+  additionalSequelizeOptions() {
+    var _a, _b, _c, _d, _e;
+    const { name } = this.options;
+    let { accuracy } = this.options;
+    if ((_c = (_b = (_a = this.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b["x-component-props"]) == null ? void 0 : _c.accuracy) {
+      accuracy = (_e = (_d = this.options) == null ? void 0 : _d.uiSchema["x-component-props"]) == null ? void 0 : _e.accuracy;
+    }
+    if (!accuracy) {
+      accuracy = "second";
+    }
+    let rationalNumber = 1e3;
+    if (accuracy === "millisecond") {
+      rationalNumber = 1;
+    }
+    return {
+      get() {
+        const value = this.getDataValue(name);
+        if (value === null || value === void 0) {
+          return value;
+        }
+        return new Date(value * rationalNumber);
+      },
+      set(value) {
+        if (value === null || value === void 0) {
+          this.setDataValue(name, value);
+        } else {
+          this.setDataValue(name, Math.floor(new Date(value).getTime() / rationalNumber));
+        }
+      }
+    };
+  }
+};
+__name(_UnixTimestampField, "UnixTimestampField");
+let UnixTimestampField = _UnixTimestampField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnixTimestampField
+});

package/lib/model.d.ts

@@ -20,6 +20,7 @@ export declare class Model<TModelAttributes extends {} = any, TCreationAttribute
     protected _previousDataValuesWithAssociations: {};
     get db(): Database;
     static sync(options: any): Promise<any>;
+    static callSetters(values: any, options: any): {};
     toChangedWithAssociations(): void;
     changedWithAssociations(key?: string, value?: any): boolean | unknown[] | this;
     clearChangedWithAssociations(): void;

package/lib/model.js

@@ -56,6 +56,18 @@ const _Model = class _Model extends import_sequelize.Model {
     const runner = new import_sync_runner.SyncRunner(this);
     return await runner.runSync(options);
   }
+  static callSetters(values, options) {
+    const result = {};
+    for (const key of Object.keys(values)) {
+      const field = this.collection.getField(key);
+      if (field && field.setter) {
+        result[key] = field.setter.call(field, values[key], options, values, key);
+      } else {
+        result[key] = values[key];
+      }
+    }
+    return result;
+  }
   // TODO
   toChangedWithAssociations() {
     this._changedWithAssociations = /* @__PURE__ */ new Set([...this._changedWithAssociations, ...this._changed]);

package/lib/operators/date.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 date_exports = {};
 __export(date_exports, {
@@ -32,116 +42,147 @@ __export(date_exports, {
 module.exports = __toCommonJS(date_exports);
 var import_utils = require("@nocobase/utils");
 var import_sequelize = require("sequelize");
+var import_moment = __toESM(require("moment"));
 function isDate(input) {
   return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
 }
 __name(isDate, "isDate");
-const toDate = /* @__PURE__ */ __name((date) => {
-  if (isDate(date)) {
-    return date;
+const toDate = /* @__PURE__ */ __name((date, options = {}) => {
+  const { ctx } = options;
+  const val = isDate(date) ? date : new Date(date);
+  const field = ctx.db.getFieldByPath(ctx.fieldPath);
+  if (!field) {
+    return val;
   }
-  return new Date(date);
+  if (field.constructor.name === "UnixTimestampField") {
+    return field.dateToValue(val);
+  }
+  if (field.constructor.name === "DatetimeNoTzField") {
+    return (0, import_moment.default)(val).utcOffset("+00:00").format("YYYY-MM-DD HH:mm:ss");
+  }
+  if (field.constructor.name === "DateOnlyField") {
+    return (0, import_moment.default)(val).format("YYYY-MM-DD HH:mm:ss");
+  }
+  return val;
 }, "toDate");
+function parseDateTimezone(ctx) {
+  const field = ctx.db.getFieldByPath(ctx.fieldPath);
+  if (!field) {
+    return ctx.db.options.timezone;
+  }
+  if (field.constructor.name === "DatetimeNoTzField") {
+    return "+00:00";
+  }
+  if (field.constructor.name === "DateOnlyField") {
+    return "+00:00";
+  }
+  return ctx.db.options.timezone;
+}
+__name(parseDateTimezone, "parseDateTimezone");
+function isDatetimeString(str) {
+  return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(str);
+}
+__name(isDatetimeString, "isDatetimeString");
 var date_default = {
   $dateOn(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.eq]: toDate(r)
+        [import_sequelize.Op.eq]: toDate(r, { ctx })
       };
     }
     if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0]) }, { [import_sequelize.Op.lt]: toDate(r[1]) }]
+        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0], { ctx }) }, { [import_sequelize.Op.lt]: toDate(r[1], { ctx }) }]
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateNotOn(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.ne]: toDate(r)
+        [import_sequelize.Op.ne]: toDate(r, { ctx })
       };
     }
     if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.or]: [{ [import_sequelize.Op.lt]: toDate(r[0]) }, { [import_sequelize.Op.gte]: toDate(r[1]) }]
+        [import_sequelize.Op.or]: [{ [import_sequelize.Op.lt]: toDate(r[0], { ctx }) }, { [import_sequelize.Op.gte]: toDate(r[1], { ctx }) }]
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateBefore(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.lt]: toDate(r)
+        [import_sequelize.Op.lt]: toDate(r, { ctx })
       };
     } else if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.lt]: toDate(r[0])
+        [import_sequelize.Op.lt]: toDate(r[0], { ctx })
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateNotBefore(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.gte]: toDate(r)
+        [import_sequelize.Op.gte]: toDate(r, { ctx })
       };
     } else if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.gte]: toDate(r[0])
+        [import_sequelize.Op.gte]: toDate(r[0], { ctx })
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateAfter(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.gt]: toDate(r)
+        [import_sequelize.Op.gt]: toDate(r, { ctx })
       };
     } else if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.gte]: toDate(r[1])
+        [import_sequelize.Op.gte]: toDate(r[1], { ctx })
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateNotAfter(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (typeof r === "string") {
       return {
-        [import_sequelize.Op.lte]: toDate(r)
+        [import_sequelize.Op.lte]: toDate(r, { ctx })
       };
     } else if (Array.isArray(r)) {
       return {
-        [import_sequelize.Op.lt]: toDate(r[1])
+        [import_sequelize.Op.lt]: toDate(r[1], { ctx })
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);
   },
   $dateBetween(value, ctx) {
     const r = (0, import_utils.parseDate)(value, {
-      timezone: ctx.db.options.timezone
+      timezone: parseDateTimezone(ctx)
     });
     if (r) {
       return {
-        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0]) }, { [import_sequelize.Op.lt]: toDate(r[1]) }]
+        [import_sequelize.Op.and]: [{ [import_sequelize.Op.gte]: toDate(r[0], { ctx }) }, { [import_sequelize.Op.lt]: toDate(r[1], { ctx }) }]
       };
     }
     throw new Error(`Invalid Date ${JSON.stringify(value)}`);

package/lib/options-parser.d.ts

@@ -26,6 +26,7 @@ export declare class OptionsParser {
     static appendInheritInspectAttribute(include: any, collection: any): any;
     isAssociation(key: string): boolean;
     isAssociationPath(path: string): boolean;
+    filterByTkToWhereOption(): {};
     toSequelizeParams(): any;
     /**
      * parser sort options

package/lib/options-parser.js

@@ -90,17 +90,34 @@ const _OptionsParser = class _OptionsParser {
   isAssociationPath(path) {
     return this.isAssociation(path.split(".")[0]);
   }
+  filterByTkToWhereOption() {
+    var _a;
+    const filterByTkOption = (_a = this.options) == null ? void 0 : _a.filterByTk;
+    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;
+    }
+    const filterTargetKey = this.context.targetKey || this.collection.filterTargetKey;
+    if (Array.isArray(filterTargetKey)) {
+      throw new Error("multi filter target key value must be object");
+    }
+    return {
+      [filterTargetKey]: filterByTkOption
+    };
+  }
   toSequelizeParams() {
     var _a, _b;
     const queryParams = this.filterParser.toSequelizeParams();
     if ((_a = this.options) == null ? void 0 : _a.filterByTk) {
+      const filterByTkWhere = this.filterByTkToWhereOption();
       queryParams.where = {
-        [import_sequelize.Op.and]: [
-          queryParams.where,
-          {
-            [this.context.targetKey || this.collection.filterTargetKey]: this.options.filterByTk
-          }
-        ]
+        [import_sequelize.Op.and]: [queryParams.where, filterByTkWhere]
       };
     }
     if ((_b = this.options) == null ? void 0 : _b.include) {
@@ -123,7 +140,7 @@ const _OptionsParser = class _OptionsParser {
       sort = sort.split(",");
     }
     let defaultSortField = this.model.primaryKeyAttribute;
-    if (!defaultSortField && this.collection.filterTargetKey) {
+    if (!defaultSortField && this.collection.filterTargetKey && !Array.isArray(this.collection.filterTargetKey)) {
       defaultSortField = this.collection.filterTargetKey;
     }
     if (defaultSortField && !((_b = this.options) == null ? void 0 : _b.group)) {

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

@@ -45,29 +45,26 @@ var import_relation_repository = require("./relation-repository");
 const _HasManyRepository = class _HasManyRepository extends import_multiple_relation_repository.MultipleRelationRepository {
   async find(options) {
     const targetRepository = this.targetCollection.repository;
-    const addFilter = {
-      [this.association.foreignKey]: this.sourceKeyValue
-    };
-    if (options == null ? void 0 : options.filterByTk) {
-      addFilter[this.associationField.targetKey] = options.filterByTk;
+    const targetFilterOptions = await this.targetRepositoryFilterOptionsBySourceValue();
+    const findOptionsOmit = ["where", "values", "attributes"];
+    if ((options == null ? void 0 : options.filterByTk) && !this.isMultiTargetKey(options.filterByTk)) {
+      targetFilterOptions[this.associationField.targetKey] = options.filterByTk;
+      findOptionsOmit.push("filterByTk");
     }
     const findOptions = {
-      ...(0, import_lodash.omit)(options, ["filterByTk", "where", "values", "attributes"]),
+      ...(0, import_lodash.omit)(options, findOptionsOmit),
       filter: {
-        $and: [options.filter || {}, addFilter]
+        $and: [(options == null ? void 0 : options.filter) || {}, targetFilterOptions]
       }
     };
     return await targetRepository.find(findOptions);
   }
   async aggregate(options) {
     const targetRepository = this.targetCollection.repository;
-    const addFilter = {
-      [this.association.foreignKey]: this.sourceKeyValue
-    };
     const aggOptions = {
       ...options,
       filter: {
-        $and: [options.filter || {}, addFilter]
+        $and: [options.filter || {}, await this.targetRepositoryFilterOptionsBySourceValue()]
       }
     };
     return await targetRepository.aggregate(aggOptions);

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

@@ -14,6 +14,7 @@ export interface AssociatedOptions extends Transactionable {
     tk?: TK;
 }
 export declare abstract class MultipleRelationRepository extends RelationRepository {
+    targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
     find(options?: FindOptions): Promise<any>;
     findAndCount(options?: FindAndCountOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;

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

@@ -55,6 +55,16 @@ var import_update_associations = require("../update-associations");
 var import_update_guard = require("../update-guard");
 var import_relation_repository = require("./relation-repository");
 const _MultipleRelationRepository = class _MultipleRelationRepository extends import_relation_repository.RelationRepository {
+  async targetRepositoryFilterOptionsBySourceValue() {
+    let filterForeignKeyValue = this.sourceKeyValue;
+    if (this.isMultiTargetKey()) {
+      const sourceModel = await this.getSourceModel();
+      filterForeignKeyValue = sourceModel.get(this.association.sourceKey);
+    }
+    return {
+      [this.association.foreignKey]: filterForeignKeyValue
+    };
+  }
   async find(options) {
     const targetRepository = this.targetCollection.repository;
     const association = this.association;
@@ -68,9 +78,7 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
     const appendFilter = {
       isPivotFilter: true,
       association: pivotAssoc,
-      where: {
-        [association.foreignKey]: this.sourceKeyValue
-      }
+      where: await this.targetRepositoryFilterOptionsBySourceValue()
     };
     return targetRepository.find({
       include: [appendFilter],

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

@@ -11,7 +11,7 @@ import { Collection } from '../collection';
 import Database from '../database';
 import { RelationField } from '../fields/relation-field';
 import { Model } from '../model';
-import { CreateOptions, Filter, FindOptions } from '../repository';
+import { CreateOptions, Filter, FindOptions, TargetKey } from '../repository';
 export declare const transaction: (transactionInjector?: any) => (target: any, name: any, descriptor: any) => any;
 export declare abstract class RelationRepository {
     sourceCollection: Collection;
@@ -20,11 +20,14 @@ export declare abstract class RelationRepository {
     targetCollection: Collection;
     associationName: string;
     associationField: RelationField;
-    sourceKeyValue: string | number;
+    sourceKeyValue: TargetKey;
     sourceInstance: Model;
     db: Database;
     database: Database;
-    constructor(sourceCollection: Collection, association: string, sourceKeyValue: string | number);
+    constructor(sourceCollection: Collection, association: string, sourceKeyValue: TargetKey);
+    decodeMultiTargetKey(str: string): any;
+    setSourceKeyValue(sourceKeyValue: TargetKey): void;
+    isMultiTargetKey(value?: any): boolean;
     get collection(): Collection<any, any>;
     abstract find(options?: FindOptions): Promise<any>;
     chunk(options: FindOptions & {

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

@@ -73,13 +73,27 @@ const _RelationRepository = class _RelationRepository {
     this.db = sourceCollection.context.database;
     this.database = this.db;
     this.sourceCollection = sourceCollection;
-    this.sourceKeyValue = sourceKeyValue;
+    this.setSourceKeyValue(sourceKeyValue);
     this.associationName = association;
     this.association = this.sourceCollection.model.associations[association];
     this.associationField = this.sourceCollection.getField(association);
     this.targetModel = this.association.target;
     this.targetCollection = this.sourceCollection.context.database.modelCollection.get(this.targetModel);
   }
+  decodeMultiTargetKey(str) {
+    try {
+      const decoded = decodeURIComponent(str);
+      return JSON.parse(decoded);
+    } catch (e) {
+      return false;
+    }
+  }
+  setSourceKeyValue(sourceKeyValue) {
+    this.sourceKeyValue = typeof sourceKeyValue === "string" ? this.decodeMultiTargetKey(sourceKeyValue) || sourceKeyValue : sourceKeyValue;
+  }
+  isMultiTargetKey(value) {
+    return import_lodash.default.isPlainObject(value || this.sourceKeyValue);
+  }
   get collection() {
     return this.db.getCollection(this.targetModel.name);
   }
@@ -147,7 +161,13 @@ const _RelationRepository = class _RelationRepository {
   }
   async getSourceModel(transaction2) {
     if (!this.sourceInstance) {
-      this.sourceInstance = await this.sourceCollection.model.findOne({
+      this.sourceInstance = this.isMultiTargetKey() ? await this.sourceCollection.repository.findOne({
+        filter: {
+          // @ts-ignore
+          ...this.sourceKeyValue
+        },
+        transaction: transaction2
+      }) : await this.sourceCollection.model.findOne({
         where: {
           [this.associationField.sourceKey]: this.sourceKeyValue
         },

package/lib/repository.d.ts

@@ -26,7 +26,9 @@ export { Transactionable } from 'sequelize';
 export interface FilterAble {
     filter: Filter;
 }
-export type TargetKey = string | number;
+export type BaseTargetKey = string | number;
+export type MultiTargetKey = Record<string, BaseTargetKey>;
+export type TargetKey = BaseTargetKey | MultiTargetKey;
 export type TK = TargetKey | TargetKey[];
 type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
 type Operators = keyof typeof operators & keyof WhereOperators;
@@ -116,7 +118,7 @@ declare class RelationRepositoryBuilder<R extends RelationRepository> {
         BelongsToArray: typeof BelongsToArrayRepository;
     };
     constructor(collection: Collection, associationName: string);
-    of(id: string | number): R;
+    of(id: TargetKey): R;
     protected builder(): {
         HasOne: typeof HasOneRepository;
         BelongsTo: typeof BelongsToRepository;
@@ -171,6 +173,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      *
      */
     findById(id: string | number): Promise<Model<any, any>>;
+    findByTargetKey(targetKey: TargetKey): Promise<any>;
     /**
      * Find one record from database
      *

package/lib/repository.js

@@ -175,13 +175,11 @@ const _Repository = class _Repository {
       };
     }
     if (countOptions == null ? void 0 : countOptions.filterByTk) {
+      const optionParser = new import_options_parser.OptionsParser(options, {
+        collection: this.collection
+      });
       options["where"] = {
-        [import_sequelize.Op.and]: [
-          options["where"] || {},
-          {
-            [this.collection.filterTargetKey]: options.filterByTk
-          }
-        ]
+        [import_sequelize.Op.and]: [options["where"] || {}, optionParser.filterByTkToWhereOption()]
       };
     }
     const queryOptions = {
@@ -191,11 +189,10 @@ const _Repository = class _Repository {
     if (((_a = queryOptions.include) == null ? void 0 : _a.length) === 0) {
       delete queryOptions.include;
     }
-    const count = await this.collection.model.count({
+    return await this.collection.model.count({
       ...queryOptions,
       transaction: transaction2
     });
-    return count;
   }
   async aggregate(options) {
     var _a;
@@ -325,6 +322,9 @@ const _Repository = class _Repository {
   findById(id) {
     return this.collection.model.findByPk(id);
   }
+  findByTargetKey(targetKey) {
+    return this.findOne({ filterByTk: targetKey });
+  }
   /**
    * Find one record from database
    *
@@ -374,7 +374,7 @@ const _Repository = class _Repository {
       action: "create",
       underscored: this.collection.options.underscored
     });
-    const values = guard.sanitize(options.values || {});
+    const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
     const instance = await this.model.create(values, {
       ...options,
       transaction: transaction2
@@ -418,7 +418,7 @@ const _Repository = class _Repository {
     }
     const transaction2 = await this.getTransaction(options);
     const guard = import_update_guard.UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
-    const values = guard.sanitize(options.values);
+    const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
     if (options.individualHooks === false) {
       const { model: Model2 } = this.collection;
       const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;
@@ -501,15 +501,26 @@ const _Repository = class _Repository {
       }
     }
     if (filterByTk && !options.filter) {
-      return await this.model.destroy({
+      const where = [];
+      for (const tk of filterByTk) {
+        const optionParser = new import_options_parser.OptionsParser(
+          {
+            filterByTk: tk
+          },
+          {
+            collection: this.collection
+          }
+        );
+        where.push(optionParser.filterByTkToWhereOption());
+      }
+      const destroyOptions = {
         ...options,
         where: {
-          [modelFilterKey]: {
-            [import_sequelize.Op.in]: filterByTk
-          }
+          [import_sequelize.Op.or]: where
         },
         transaction: transaction2
-      });
+      };
+      return await this.model.destroy(destroyOptions);
     }
     if (options.filter && (0, import_utils.isValidFilter)(options.filter)) {
       if (this.collection.model.primaryKeyAttributes.length !== 1 && !import_lodash.default.get(this.collection.options, "filterTargetKey")) {