@nocobase/database 1.7.0-beta.9 → 1.8.0-beta.1

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

@@ -31,8 +31,8 @@ export declare class BelongsToArrayAssociation {
         targetKey: string;
     });
     get target(): import("sequelize/types").ModelStatic<Model<any, any>>;
-    generateInclude(): {
-        on: import("sequelize/types/utils").Literal;
+    generateInclude(parentAs?: string): {
+        on: void;
     };
     update(instance: Model, value: any, options?: UpdateAssociationOptions): Promise<void>;
 }

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

@@ -78,19 +78,18 @@ const _BelongsToArrayAssociation = class _BelongsToArrayAssociation {
   get target() {
     return this.db.getModel(this.targetName);
   }
-  generateInclude() {
-    if (this.db.sequelize.getDialect() !== "postgres") {
-      throw new Error("Filtering by many to many (array) associations is only supported on postgres");
-    }
+  generateInclude(parentAs) {
     const targetCollection = this.db.getCollection(this.targetName);
     const targetField = targetCollection.getField(this.targetKey);
     const sourceCollection = this.db.getCollection(this.source.name);
     const foreignField = sourceCollection.getField(this.foreignKey);
     const queryInterface = this.db.sequelize.getQueryInterface();
-    const left = queryInterface.quoteIdentifiers(`${this.as}.${targetField.columnName()}`);
-    const right = queryInterface.quoteIdentifiers(`${this.source.collection.name}.${foreignField.columnName()}`);
+    const asLeft = parentAs ? `${parentAs}->${this.as}` : this.as;
+    const asRight = parentAs || this.source.collection.name;
+    const left = queryInterface.quoteIdentifiers(`${asLeft}.${targetField.columnName()}`);
+    const right = queryInterface.quoteIdentifiers(`${asRight}.${foreignField.columnName()}`);
     return {
-      on: this.db.sequelize.literal(`${left}=any(${right})`)
+      on: this.db.queryInterface.generateJoinOnForJSONArray(left, right)
     };
   }
   async update(instance, value, options = {}) {

package/lib/cursor-builder.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 { Sequelize } from 'sequelize';
+import { FindOptions } from './repository';
+import { Model } from './model';
+import { Collection } from './collection';
+export declare class SmartCursorBuilder {
+    private sequelize;
+    private tableName;
+    private collection;
+    constructor(sequelize: Sequelize, tableName: string, collection: Collection);
+    /**
+     * 根据表结构自动选择最优游标策略
+     */
+    private getBestCursorStrategy;
+    /**
+     * Cursor-based pagination query function.
+     * Ideal for large datasets (e.g., millions of rows)
+     * Note:
+     *  1. does not support jumping to arbitrary pages (e.g., "Page 5")
+     *  2. Requires a stable, indexed sort field (e.g. ID, createdAt)
+     *  3. If custom orderBy is used, it must match the cursor field(s) and direction, otherwise results may be incorrect or unstable.
+     * @param options
+     */
+    chunk(options: FindOptions & {
+        chunkSize: number;
+        callback: (rows: Model[], options: FindOptions) => Promise<void>;
+        find: (options: FindOptions) => Promise<any[]>;
+        beforeFind?: (options: FindOptions) => Promise<void>;
+        afterFind?: (rows: Model[], options: FindOptions) => Promise<void>;
+    }): Promise<void>;
+}

package/lib/cursor-builder.js

@@ -0,0 +1,307 @@
+/**
+ * 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 __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) => {
+  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 __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 cursor_builder_exports = {};
+__export(cursor_builder_exports, {
+  SmartCursorBuilder: () => SmartCursorBuilder
+});
+module.exports = __toCommonJS(cursor_builder_exports);
+var import_sequelize = require("sequelize");
+var import_lodash = __toESM(require("lodash"));
+const _SmartCursorBuilder = class _SmartCursorBuilder {
+  sequelize;
+  tableName;
+  collection;
+  constructor(sequelize, tableName, collection) {
+    this.sequelize = sequelize;
+    this.tableName = tableName;
+    this.collection = collection;
+  }
+  /**
+   * 根据表结构自动选择最优游标策略
+   */
+  async getBestCursorStrategy() {
+    let indexInfoSql = "";
+    const dialect = this.sequelize.getDialect();
+    if (dialect === "postgres") {
+      indexInfoSql = `
+      SELECT 
+        t.relname AS table_name,
+        i.relname AS index_name,
+        a.attname AS column_name,
+        array_position(ix.indkey, a.attnum) + 1 AS seq_in_index,
+        CASE 
+          WHEN ix.indisprimary THEN 1
+          WHEN ix.indisunique THEN 2
+          ELSE 3
+        END AS index_type,
+        -- \u5224\u65AD\u7D22\u5F15\u6392\u5E8F\u65B9\u5411 (0=ASC, 1=DESC)
+        CASE WHEN (ix.indoption[array_position(ix.indkey, a.attnum) - 1] & 1) = 1 
+             THEN 'DESC' ELSE 'ASC' 
+        END AS direction
+      FROM 
+        pg_class t,
+        pg_class i,
+        pg_index ix,
+        pg_attribute a,
+        pg_namespace n
+      WHERE 
+        t.oid = ix.indrelid
+        AND i.oid = ix.indexrelid
+        AND a.attrelid = t.oid
+        AND t.relnamespace = n.oid
+        AND a.attnum = ANY(ix.indkey)
+        AND t.relkind = 'r'
+        AND n.nspname = current_schema()
+        AND t.relname = $1
+      ORDER BY 
+        i.relname, 
+        array_position(ix.indkey, a.attnum)
+    `;
+    } else if (dialect === "mariadb" || dialect === "mysql") {
+      indexInfoSql = `
+      SELECT 
+        i.TABLE_NAME, 
+        i.INDEX_NAME, 
+        i.COLUMN_NAME,
+        i.SEQ_IN_INDEX,
+        CASE 
+          WHEN i.INDEX_NAME = 'PRIMARY' THEN 1
+          WHEN i.NON_UNIQUE = 0 THEN 2
+          ELSE 3 
+        END as INDEX_TYPE
+      FROM 
+        information_schema.STATISTICS i
+      WHERE 
+        i.TABLE_SCHEMA = DATABASE() 
+        AND i.TABLE_NAME = ?
+      ORDER BY 
+        i.INDEX_NAME, 
+        i.SEQ_IN_INDEX;
+    `;
+    }
+    const indexRows = await this.sequelize.query(indexInfoSql, {
+      type: import_sequelize.QueryTypes.SELECT,
+      replacements: [this.tableName],
+      raw: true
+    });
+    const indexes = /* @__PURE__ */ new Map();
+    const indexDirections = /* @__PURE__ */ new Map();
+    if (!indexRows || indexRows.length === 0) {
+      if (Array.isArray(this.collection.filterTargetKey)) {
+        return new CompositeKeyCursorStrategy(this.collection.filterTargetKey);
+      }
+      return new SingleColumnCursorStrategy(this.collection.filterTargetKey);
+    }
+    for (const row of indexRows) {
+      const indexName = dialect === "postgres" ? row.index_name : row.INDEX_NAME;
+      const columnName = dialect === "postgres" ? row.column_name : row.COLUMN_NAME;
+      const indexType = dialect === "postgres" ? row.index_type : row.INDEX_TYPE;
+      if (dialect === "postgres" && row.direction) {
+        if (!indexDirections.has(indexName)) {
+          indexDirections.set(indexName, /* @__PURE__ */ new Map());
+        }
+        indexDirections.get(indexName).set(columnName, row.direction);
+      }
+      if (!indexes.has(indexName)) {
+        indexes.set(indexName, {
+          name: indexName,
+          columns: [],
+          isPrimary: dialect === "postgres" ? indexType === 1 : indexName === "PRIMARY",
+          isUnique: indexType < 3
+        });
+      }
+      const index = indexes.get(row.INDEX_NAME);
+      index.columns[row.SEQ_IN_INDEX - 1] = row.COLUMN_NAME;
+    }
+    for (const index of indexes.values()) {
+      if (index.isPrimary) {
+        if (index.columns.length === 1) {
+          return new SingleColumnCursorStrategy(index.columns[0]);
+        } else {
+          if (dialect === "postgres" && indexDirections.has(index.name)) {
+            const directions = index.columns.map((col) => indexDirections.get(index.name).get(col) || "ASC");
+            return new CompositeKeyCursorStrategy(index.columns, directions);
+          } else {
+            return new CompositeKeyCursorStrategy(index.columns);
+          }
+        }
+      }
+    }
+    let singleColumnUniqueIndex = null;
+    let multiColumnUniqueIndex = null;
+    for (const index of indexes.values()) {
+      if (index.isUnique && !index.isPrimary) {
+        if (index.columns.length === 1 && !singleColumnUniqueIndex) {
+          singleColumnUniqueIndex = index;
+        } else if (index.columns.length > 1 && !multiColumnUniqueIndex) {
+          multiColumnUniqueIndex = index;
+        }
+      }
+    }
+    if (singleColumnUniqueIndex) {
+      return new SingleColumnCursorStrategy(singleColumnUniqueIndex.columns[0]);
+    }
+    if (multiColumnUniqueIndex) {
+      return new CompositeKeyCursorStrategy(multiColumnUniqueIndex.columns);
+    }
+    let anyIndex = null;
+    for (const index of indexes.values()) {
+      if (index.columns.length > 0 && !index.isPrimary && !index.isUnique) {
+        anyIndex = index;
+        break;
+      }
+    }
+    if (anyIndex) {
+      if (anyIndex.columns.length === 1) {
+        return new SingleColumnCursorStrategy(anyIndex.columns[0]);
+      } else {
+        return new CompositeKeyCursorStrategy(anyIndex.columns);
+      }
+    }
+  }
+  /**
+   * Cursor-based pagination query function.
+   * Ideal for large datasets (e.g., millions of rows)
+   * Note:
+   *  1. does not support jumping to arbitrary pages (e.g., "Page 5")
+   *  2. Requires a stable, indexed sort field (e.g. ID, createdAt)
+   *  3. If custom orderBy is used, it must match the cursor field(s) and direction, otherwise results may be incorrect or unstable.
+   * @param options
+   */
+  async chunk(options) {
+    const cursorStrategy = await this.getBestCursorStrategy();
+    let cursorRecord = null;
+    let hasMoreData = true;
+    let isFirst = true;
+    options.order = cursorStrategy.buildSort();
+    options["parseSort"] = false;
+    while (hasMoreData) {
+      if (!isFirst) {
+        options.where = cursorStrategy.buildWhere(options.where, cursorRecord);
+      }
+      if (isFirst) {
+        isFirst = false;
+      }
+      options.limit = options.chunkSize || 1e3;
+      if (options.beforeFind) {
+        await options.beforeFind(options);
+      }
+      const records = await options.find(import_lodash.default.omit(options, "callback", "beforeFind", "afterFind", "chunkSize", "find"));
+      if (options.afterFind) {
+        await options.afterFind(records, options);
+      }
+      if (records.length === 0) {
+        hasMoreData = false;
+        continue;
+      }
+      await options.callback(records, options);
+      cursorRecord = records[records.length - 1];
+    }
+  }
+};
+__name(_SmartCursorBuilder, "SmartCursorBuilder");
+let SmartCursorBuilder = _SmartCursorBuilder;
+const _SingleColumnCursorStrategy = class _SingleColumnCursorStrategy {
+  columnName;
+  constructor(columnName) {
+    this.columnName = columnName;
+  }
+  buildSort() {
+    return [[this.columnName, "ASC"]];
+  }
+  buildWhere(baseWhere, record) {
+    if (!record) {
+      return baseWhere;
+    }
+    return { ...baseWhere, [this.columnName]: { [import_sequelize.Op.gt]: record[this.columnName] } };
+  }
+};
+__name(_SingleColumnCursorStrategy, "SingleColumnCursorStrategy");
+let SingleColumnCursorStrategy = _SingleColumnCursorStrategy;
+const _CompositeKeyCursorStrategy = class _CompositeKeyCursorStrategy {
+  columns;
+  directions;
+  constructor(columns, directions) {
+    this.columns = columns;
+    this.directions = directions || Array(columns.length).fill("ASC");
+  }
+  buildSort() {
+    const orderBy = [];
+    for (let i = 0; i < this.columns.length; i++) {
+      orderBy.push([this.columns[i], this.directions[i]]);
+    }
+    return orderBy;
+  }
+  buildWhere(baseWhere, record) {
+    if (!record) {
+      return baseWhere;
+    }
+    const whereConditions = [];
+    for (let i = 0; i < this.columns.length; i++) {
+      const column = this.columns[i];
+      if (i > 0) {
+        const equalConditions = {};
+        for (let j = 0; j < i; j++) {
+          equalConditions[this.columns[j]] = record[this.columns[j]];
+        }
+        whereConditions.push({
+          ...equalConditions,
+          [column]: {
+            [import_sequelize.Op.gt]: record[column]
+          }
+        });
+      } else {
+        whereConditions.push({
+          [column]: {
+            [import_sequelize.Op.gt]: record[column]
+          }
+        });
+      }
+    }
+    const cursorCondition = {
+      [import_sequelize.Op.or]: whereConditions
+    };
+    return baseWhere ? { [import_sequelize.Op.and]: [baseWhere, cursorCondition] } : cursorCondition;
+  }
+};
+__name(_CompositeKeyCursorStrategy, "CompositeKeyCursorStrategy");
+let CompositeKeyCursorStrategy = _CompositeKeyCursorStrategy;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SmartCursorBuilder
+});

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

@@ -6,9 +6,11 @@
  * 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 { DatabaseOptions } from '../database';
 import { BaseDialect } from './base-dialect';
 export declare class MariadbDialect extends BaseDialect {
     static dialectName: string;
+    getSequelizeOptions(options: DatabaseOptions): import("../database").IDatabaseOptions;
     getVersionGuard(): {
         sql: string;
         get: (v: string) => string;

package/lib/dialects/mariadb-dialect.js

@@ -34,6 +34,10 @@ __export(mariadb_dialect_exports, {
 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 };
+    return options;
+  }
   getVersionGuard() {
     return {
       sql: "select version() as version",

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

@@ -85,6 +85,25 @@ const queryParentSQL = /* @__PURE__ */ __name((options) => {
       )
       SELECT ${q(targetKeyField)} AS ${q(targetKey)}, ${q(foreignKeyField)} AS ${q(foreignKey)} FROM cte`;
 }, "queryParentSQL");
+const processIncludes = /* @__PURE__ */ __name((includes, model, parentAs = "") => {
+  includes.forEach((include, index) => {
+    const association = model.associations[include.association];
+    if (association == null ? void 0 : association.generateInclude) {
+      includes[index] = {
+        ...include,
+        ...association.generateInclude(parentAs)
+      };
+    }
+    if (include.include && Array.isArray(include.include) && include.include.length > 0) {
+      const nextModel = association == null ? void 0 : association.target;
+      if (!nextModel) {
+        return;
+      }
+      processIncludes(include.include, nextModel, parentAs ? `${parentAs}->${association.as}` : association.as);
+    }
+  });
+  return includes;
+}, "processIncludes");
 const _EagerLoadingTree = class _EagerLoadingTree {
   root;
   db;
@@ -208,22 +227,13 @@ const _EagerLoadingTree = class _EagerLoadingTree {
           if (!primaryKeyField) {
             throw new Error(`Model ${node.model.name} does not have primary key`);
           }
-          includeForFilter.forEach((include, index) => {
-            const association = node.model.associations[include.association];
-            if ((association == null ? void 0 : association.associationType) == "BelongsToArray") {
-              includeForFilter[index] = {
-                ...include,
-                ...association.generateInclude()
-              };
-            }
-          });
           const ids2 = (await node.model.findAll({
             ...this.rootQueryOptions,
             includeIgnoreAttributes: false,
             attributes: [primaryKeyField],
             group: `${node.model.name}.${primaryKeyField}`,
             transaction,
-            include: includeForFilter
+            include: processIncludes(includeForFilter, node.model)
           })).map((row) => {
             return { row, pk: row[primaryKeyField] };
           });

package/lib/fields/array-field.d.ts

@@ -10,7 +10,7 @@ import { DataTypes } from 'sequelize';
 import { BaseColumnFieldOptions, Field } from './field';
 export declare class ArrayField extends Field {
     get dataType(): DataTypes.AbstractDataTypeConstructor | DataTypes.ArrayDataType<any>;
-    sortValue: (model: any) => void;
+    sortValue: (instances: any) => void;
     bind(): void;
     unbind(): void;
 }

package/lib/fields/array-field.js

@@ -43,23 +43,28 @@ const _ArrayField = class _ArrayField extends import_field.Field {
     }
     return import_sequelize.DataTypes.JSON;
   }
-  sortValue = /* @__PURE__ */ __name((model) => {
-    let oldValue = model.get(this.options.name);
-    if (oldValue) {
-      if (typeof oldValue === "string") {
-        oldValue = JSON.parse(oldValue);
+  sortValue = /* @__PURE__ */ __name((instances) => {
+    instances = Array.isArray(instances) ? instances : [instances];
+    for (const instance of instances) {
+      let oldValue = instance.get(this.options.name);
+      if (oldValue) {
+        if (typeof oldValue === "string") {
+          oldValue = JSON.parse(oldValue);
+        }
+        const newValue = oldValue.sort();
+        instance.set(this.options.name, newValue);
       }
-      const newValue = oldValue.sort();
-      model.set(this.options.name, newValue);
     }
   }, "sortValue");
   bind() {
     super.bind();
     this.on("beforeSave", this.sortValue);
+    this.on("beforeBulkCreate", this.sortValue);
   }
   unbind() {
     super.unbind();
     this.off("beforeSave", this.sortValue);
+    this.off("beforeBulkCreate", this.sortValue);
   }
 };
 __name(_ArrayField, "ArrayField");

package/lib/fields/date-field.js

@@ -82,15 +82,18 @@ const _DateField = class _DateField extends import_field.Field {
       }
       return serverTimeZone;
     };
-    this.beforeSave = async (instance, options) => {
-      const value = instance.get(name);
-      if (!value && instance.isNewRecord && defaultToCurrentTime) {
-        instance.set(name, /* @__PURE__ */ new Date());
-        return;
-      }
-      if (onUpdateToCurrentTime) {
-        instance.set(name, /* @__PURE__ */ new Date());
-        return;
+    this.beforeSave = async (instances, options) => {
+      instances = Array.isArray(instances) ? instances : [instances];
+      for (const instance of instances) {
+        const value = instance.get(name);
+        if (!value && instance.isNewRecord && defaultToCurrentTime) {
+          instance.set(name, /* @__PURE__ */ new Date());
+          continue;
+        }
+        if (onUpdateToCurrentTime) {
+          instance.set(name, /* @__PURE__ */ new Date());
+          continue;
+        }
       }
     };
     if (this.options.defaultValue && this.database.isMySQLCompatibleDialect()) {
@@ -143,10 +146,12 @@ const _DateField = class _DateField extends import_field.Field {
       model.refreshAttributes();
     }
     this.on("beforeSave", this.beforeSave);
+    this.on("beforeBulkCreate", this.beforeSave);
   }
   unbind() {
     super.unbind();
     this.off("beforeSave", this.beforeSave);
+    this.off("beforeBulkCreate", this.beforeSave);
   }
 };
 __name(_DateField, "DateField");

package/lib/fields/datetime-no-tz-field.d.ts

@@ -13,7 +13,7 @@ declare class DatetimeNoTzTypeMySQL extends DataTypes.ABSTRACT {
 }
 export declare class DatetimeNoTzField extends Field {
     get dataType(): typeof DatetimeNoTzTypeMySQL;
-    init(): void;
+    beforeSave: (instances: any, options: any) => Promise<void>;
     additionalSequelizeOptions(): {};
     bind(): void;
     unbind(): void;

package/lib/fields/datetime-no-tz-field.js

@@ -61,58 +61,64 @@ const _DatetimeNoTzField = class _DatetimeNoTzField extends import_field.Field {
     if (this.database.isMySQLCompatibleDialect()) {
       return DatetimeNoTzTypeMySQL;
     }
-    return import_sequelize.DataTypes.STRING;
+    return import_sequelize.DataTypes.DATE;
   }
-  init() {
+  beforeSave = /* @__PURE__ */ __name(async (instances, options) => {
+    instances = Array.isArray(instances) ? instances : [instances];
     const { name, defaultToCurrentTime, onUpdateToCurrentTime } = this.options;
-    this.beforeSave = async (instance, options) => {
+    for (const instance of instances) {
       const value = instance.get(name);
       if (!value && instance.isNewRecord && defaultToCurrentTime) {
         instance.set(name, /* @__PURE__ */ new Date());
-        return;
+        continue;
       }
       if (onUpdateToCurrentTime) {
         instance.set(name, /* @__PURE__ */ new Date());
-        return;
+        continue;
       }
-    };
-  }
+    }
+  }, "beforeSave");
   additionalSequelizeOptions() {
     const { name } = this.options;
     const timezone = this.database.options.rawTimezone || "+00:00";
     const isPg = this.database.inDialect("postgres");
+    const isMySQLCompatibleDialect = this.database.isMySQLCompatibleDialect();
     return {
       get() {
         const val = this.getDataValue(name);
         if (val instanceof Date) {
-          if (isPg) {
-            return (0, import_moment.default)(val).format("YYYY-MM-DD HH:mm:ss");
-          }
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
+          const momentVal = (0, import_moment.default)(val);
           return momentVal.format("YYYY-MM-DD HH:mm:ss");
         }
         return val;
       },
       set(val) {
-        if (typeof val === "string" && isIso8601(val)) {
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
-          val = momentVal.format("YYYY-MM-DD HH:mm:ss");
+        if (val == null) {
+          return this.setDataValue(name, null);
+        }
+        const dateOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+        const momentVal = (0, import_moment.default)(val);
+        if (typeof val === "string" && isIso8601(val) || val instanceof Date) {
+          momentVal.utcOffset(timezone);
+          momentVal.utcOffset(-dateOffset, true);
         }
-        if (val && val instanceof Date) {
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
-          val = momentVal.format("YYYY-MM-DD HH:mm:ss");
+        if (isMySQLCompatibleDialect) {
+          momentVal.millisecond(0);
         }
-        return this.setDataValue(name, val);
+        const date = momentVal.toDate();
+        return this.setDataValue(name, date);
       }
     };
   }
   bind() {
     super.bind();
     this.on("beforeSave", this.beforeSave);
+    this.on("beforeBulkCreate", this.beforeSave);
   }
   unbind() {
     super.unbind();
     this.off("beforeSave", this.beforeSave);
+    this.off("beforeBulkCreate", this.beforeSave);
   }
 };
 __name(_DatetimeNoTzField, "DatetimeNoTzField");

package/lib/fields/encryption-field/encryption-field.js

@@ -93,11 +93,13 @@ const _EncryptionField = class _EncryptionField extends import_field.Field {
     super.bind();
     this.on("afterFind", this.findListener);
     this.on("beforeSave", this.writeListener);
+    this.on("beforeBulkCreate", this.writeListener);
   }
   unbind() {
     super.unbind();
     this.off("afterFind", this.findListener);
     this.off("beforeSave", this.writeListener);
+    this.off("beforeBulkCreate", this.writeListener);
   }
 };
 __name(_EncryptionField, "EncryptionField");