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

package/lib/fields/nanoid-field.js

@@ -40,21 +40,28 @@ const _NanoidField = class _NanoidField extends import_field.Field {
   }
   init() {
     const { name, size, customAlphabet: customAlphabetOptions, autoFill } = this.options;
-    this.listener = async (instance) => {
-      const value = instance.get(name);
-      if (!value && autoFill !== false) {
-        const nanoIdFunc = customAlphabetOptions ? (0, import_nanoid.customAlphabet)(customAlphabetOptions) : import_nanoid.nanoid;
-        instance.set(name, nanoIdFunc(size || DEFAULT_SIZE));
+    this.listener = async (instances) => {
+      instances = Array.isArray(instances) ? instances : [instances];
+      for (const instance of instances) {
+        const value = instance.get(name);
+        if (!value && autoFill !== false) {
+          const nanoIdFunc = customAlphabetOptions ? (0, import_nanoid.customAlphabet)(customAlphabetOptions) : import_nanoid.nanoid;
+          instance.set(name, nanoIdFunc(size || DEFAULT_SIZE));
+        }
       }
     };
   }
   bind() {
     super.bind();
     this.on("beforeValidate", this.listener);
+    this.on("beforeBulkCreate", this.listener);
+    this.on("beforeCreate", this.listener);
   }
   unbind() {
     super.unbind();
     this.off("beforeValidate", this.listener);
+    this.off("beforeBulkCreate", this.listener);
+    this.off("beforeCreate", this.listener);
   }
 };
 __name(_NanoidField, "NanoidField");

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

@@ -11,7 +11,7 @@ export interface SetFieldOptions extends Omit<ArrayFieldOptions, 'type'> {
     type: 'set';
 }
 export declare class SetField extends ArrayField {
-    beforeSave: (model: any) => void;
+    beforeSave: (instances: any) => void;
     bind(): void;
     unbind(): void;
 }

package/lib/fields/set-field.js

@@ -32,19 +32,24 @@ __export(set_field_exports, {
 module.exports = __toCommonJS(set_field_exports);
 var import_array_field = require("./array-field");
 const _SetField = class _SetField extends import_array_field.ArrayField {
-  beforeSave = /* @__PURE__ */ __name((model) => {
-    const oldValue = model.get(this.options.name);
-    if (oldValue) {
-      model.set(this.options.name, [...new Set(oldValue)]);
+  beforeSave = /* @__PURE__ */ __name((instances) => {
+    instances = Array.isArray(instances) ? instances : [instances];
+    for (const instance of instances) {
+      const oldValue = instance.get(this.options.name);
+      if (oldValue) {
+        instance.set(this.options.name, [...new Set(oldValue)]);
+      }
     }
   }, "beforeSave");
   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(_SetField, "SetField");

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

@@ -10,8 +10,12 @@ import { DataTypes } from 'sequelize';
 import { BaseColumnFieldOptions, Field } from './field';
 export declare class StringField extends Field {
     get dataType(): DataTypes.StringDataTypeConstructor | DataTypes.StringDataType;
+    additionalSequelizeOptions(): {
+        set(value: any): void;
+    };
 }
 export interface StringFieldOptions extends BaseColumnFieldOptions {
     type: 'string';
     length?: number;
+    trim?: boolean;
 }

package/lib/fields/string-field.js

@@ -39,6 +39,24 @@ const _StringField = class _StringField extends import_field.Field {
     }
     return import_sequelize.DataTypes.STRING;
   }
+  additionalSequelizeOptions() {
+    const { name, trim, unique } = this.options;
+    return {
+      set(value) {
+        if (unique && value === "") {
+          value = null;
+        }
+        if (value == null) {
+          this.setDataValue(name, null);
+          return;
+        }
+        if (typeof value !== "string") {
+          value = value.toString();
+        }
+        this.setDataValue(name, trim ? value.trim() : value);
+      }
+    };
+  }
 };
 __name(_StringField, "StringField");
 let StringField = _StringField;

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

@@ -11,8 +11,12 @@ import { BaseColumnFieldOptions, Field } from './field';
 export declare class TextField extends Field {
     get dataType(): DataTypes.TextDataTypeConstructor | DataTypes.TextDataType;
     init(): void;
+    additionalSequelizeOptions(): {
+        set(value: any): void;
+    };
 }
 export interface TextFieldOptions extends BaseColumnFieldOptions {
     type: 'text';
     length?: 'tiny' | 'medium' | 'long';
+    trim?: boolean;
 }

package/lib/fields/text-field.js

@@ -44,6 +44,24 @@ const _TextField = class _TextField extends import_field.Field {
       this.options.defaultValue = null;
     }
   }
+  additionalSequelizeOptions() {
+    const { name, trim, unique } = this.options;
+    return {
+      set(value) {
+        if (unique && value === "") {
+          value = null;
+        }
+        if (value == null) {
+          this.setDataValue(name, null);
+          return;
+        }
+        if (typeof value !== "string") {
+          value = value.toString();
+        }
+        this.setDataValue(name, trim ? value.trim() : value);
+      }
+    };
+  }
 };
 __name(_TextField, "TextField");
 let TextField = _TextField;

package/lib/fields/uuid-field.js

@@ -39,20 +39,27 @@ const _UuidField = class _UuidField extends import_field.Field {
   }
   init() {
     const { name, autoFill } = this.options;
-    this.listener = async (instance) => {
-      const value = instance.get(name);
-      if (!value && autoFill !== false) {
-        instance.set(name, (0, import_uuid.v4)());
+    this.listener = async (instances) => {
+      instances = Array.isArray(instances) ? instances : [instances];
+      for (const instance of instances) {
+        const value = instance.get(name);
+        if (!value && autoFill !== false) {
+          instance.set(name, (0, import_uuid.v4)());
+        }
       }
     };
   }
   bind() {
     super.bind();
     this.on("beforeValidate", this.listener);
+    this.on("beforeBulkCreate", this.listener);
+    this.on("beforeCreate", this.listener);
   }
   unbind() {
     super.unbind();
     this.off("beforeValidate", this.listener);
+    this.off("beforeBulkCreate", this.listener);
+    this.off("beforeCreate", this.listener);
   }
 };
 __name(_UuidField, "UuidField");

package/lib/index.d.ts

@@ -39,3 +39,4 @@ 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';

package/lib/index.js

@@ -94,6 +94,7 @@ __reExport(src_exports, require("./value-parsers"), module.exports);
 __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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseError,
@@ -143,5 +144,6 @@ __reExport(src_exports, require("./view/view-inference"), module.exports);
   ...require("./update-associations"),
   ...require("./value-parsers"),
   ...require("./view-collection"),
-  ...require("./view/view-inference")
+  ...require("./view/view-inference"),
+  ...require("./update-guard")
 });

package/lib/interfaces/index.d.ts

@@ -14,3 +14,4 @@ export * from './datetime-interface';
 export * from './datetime-no-tz-interface';
 export * from './boolean-interface';
 export * from './date-interface';
+export * from './time-interface';

package/lib/interfaces/index.js

@@ -31,6 +31,7 @@ __reExport(interfaces_exports, require("./datetime-interface"), module.exports);
 __reExport(interfaces_exports, require("./datetime-no-tz-interface"), module.exports);
 __reExport(interfaces_exports, require("./boolean-interface"), module.exports);
 __reExport(interfaces_exports, require("./date-interface"), module.exports);
+__reExport(interfaces_exports, require("./time-interface"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./base-interface"),
@@ -40,5 +41,6 @@ __reExport(interfaces_exports, require("./date-interface"), module.exports);
   ...require("./datetime-interface"),
   ...require("./datetime-no-tz-interface"),
   ...require("./boolean-interface"),
-  ...require("./date-interface")
+  ...require("./date-interface"),
+  ...require("./time-interface")
 });

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

@@ -0,0 +1,13 @@
+/**
+ * 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 { BaseInterface } from './base-interface';
+export declare class InputInterface extends BaseInterface {
+    toValue(value: any): any;
+    validate(value: any): boolean;
+}

package/lib/interfaces/input-interface.js

@@ -0,0 +1,64 @@
+/**
+ * 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 input_interface_exports = {};
+__export(input_interface_exports, {
+  InputInterface: () => InputInterface
+});
+module.exports = __toCommonJS(input_interface_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_base_interface = require("./base-interface");
+const _InputInterface = class _InputInterface extends import_base_interface.BaseInterface {
+  toValue(value) {
+    if (value === null || value === void 0 || typeof value === "string") {
+      return value;
+    }
+    if (this.validate(value)) {
+      return value.toString();
+    }
+    throw new Error("Invalid value, expected string");
+  }
+  validate(value) {
+    return import_lodash.default.isString(value) || import_lodash.default.isNumber(value);
+  }
+};
+__name(_InputInterface, "InputInterface");
+let InputInterface = _InputInterface;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InputInterface
+});

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

@@ -0,0 +1,13 @@
+/**
+ * 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 { BaseInterface } from './base-interface';
+export declare class TimeInterface extends BaseInterface {
+    toValue(value: any, ctx?: any): any;
+    validate(value: any): boolean;
+}

package/lib/interfaces/time-interface.js

@@ -0,0 +1,65 @@
+/**
+ * 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 time_interface_exports = {};
+__export(time_interface_exports, {
+  TimeInterface: () => TimeInterface
+});
+module.exports = __toCommonJS(time_interface_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+var import_base_interface = require("./base-interface");
+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");
+      return result;
+    }
+    return value;
+  }
+  validate(value) {
+    const result = (0, import_dayjs.default)(value).isValid();
+    return result;
+  }
+};
+__name(_TimeInterface, "TimeInterface");
+let TimeInterface = _TimeInterface;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeInterface
+});

package/lib/interfaces/utils.js

@@ -39,6 +39,7 @@ var import_one_to_many_interface = require("./one-to-many-interface");
 var import_integer_interface = require("./integer-interface");
 var import_number_interface = require("./number-interface");
 var import_json_interface = require("./json-interface");
+var import_input_interface = require("./input-interface");
 const interfaces = {
   integer: import_integer_interface.IntegerInterface,
   number: import_number_interface.NumberInterface,
@@ -62,7 +63,9 @@ const interfaces = {
   obo: import_one_belongs_to_one_interface.OneBelongsToOneInterface,
   o2m: import_one_to_many_interface.OneToManyInterface,
   m2o: import_many_to_one_interface.ManyToOneInterface,
-  m2m: import_many_to_many_interface.ManyToManyInterface
+  m2m: import_many_to_many_interface.ManyToManyInterface,
+  time: import_index.TimeInterface,
+  input: import_input_interface.InputInterface
 };
 function registerInterfaces(db) {
   for (const [interfaceName, type] of Object.entries(interfaces)) {

package/lib/options-parser.d.ts

@@ -27,7 +27,9 @@ export declare class OptionsParser {
     isAssociation(key: string): boolean;
     isAssociationPath(path: string): boolean;
     filterByTkToWhereOption(): {};
-    toSequelizeParams(): any;
+    toSequelizeParams(options?: {
+        parseSort?: boolean;
+    }): any;
     /**
      * parser sort options
      * @param filterParams

package/lib/options-parser.js

@@ -111,7 +111,7 @@ const _OptionsParser = class _OptionsParser {
       [filterTargetKey]: filterByTkOption
     };
   }
-  toSequelizeParams() {
+  toSequelizeParams(options = { parseSort: true }) {
     var _a, _b;
     const queryParams = this.filterParser.toSequelizeParams();
     if ((_a = this.options) == null ? void 0 : _a.filterByTk) {
@@ -126,7 +126,8 @@ const _OptionsParser = class _OptionsParser {
       }
       queryParams.include.push(...import_lodash.default.castArray(this.options.include));
     }
-    return this.parseSort(this.parseFields(queryParams));
+    const fields = this.parseFields(queryParams);
+    return options.parseSort ? this.parseSort(fields) : fields;
   }
   /**
    * parser sort options

package/lib/query-interface/mysql-query-interface.d.ts

@@ -41,4 +41,5 @@ export default class MysqlQueryInterface extends QueryInterface {
         currentVal: number;
         transaction?: Transaction;
     }): Promise<void>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/mysql-query-interface.js

@@ -129,6 +129,9 @@ const _MysqlQueryInterface = class _MysqlQueryInterface extends import_query_int
       await this.db.sequelize.query(sql, { transaction });
     }
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`JSON_CONTAINS(${right}, JSON_ARRAY(${left}))`);
+  }
 };
 __name(_MysqlQueryInterface, "MysqlQueryInterface");
 let MysqlQueryInterface = _MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -38,4 +38,5 @@ export default class PostgresQueryInterface extends QueryInterface {
         };
     }>;
     showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/postgres-query-interface.js

@@ -202,6 +202,9 @@ $BODY$
     );
     return res[0]["show_create_table"];
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`${left}=any(${right})`);
+  }
 };
 __name(_PostgresQueryInterface, "PostgresQueryInterface");
 let PostgresQueryInterface = _PostgresQueryInterface;

package/lib/query-interface/query-interface.d.ts

@@ -49,4 +49,5 @@ export default abstract class QueryInterface {
         transaction?: Transaction;
     }): Promise<void>;
     quoteIdentifier(identifier: string): any;
+    generateJoinOnForJSONArray(left: string, right: string): void;
 }

package/lib/query-interface/query-interface.js

@@ -57,6 +57,10 @@ const _QueryInterface = class _QueryInterface {
   quoteIdentifier(identifier) {
     return this.db.sequelize.getQueryInterface().queryGenerator.quoteIdentifier(identifier);
   }
+  generateJoinOnForJSONArray(left, right) {
+    const dialect = this.db.sequelize.getDialect();
+    throw new Error(`Filtering by many to many (array) associations is not supported on ${dialect}`);
+  }
 };
 __name(_QueryInterface, "QueryInterface");
 let QueryInterface = _QueryInterface;

package/lib/query-interface/sqlite-query-interface.d.ts

@@ -41,4 +41,5 @@ export default class SqliteQueryInterface extends QueryInterface {
         currentVal: number;
         transaction?: Transaction;
     }): Promise<void>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/sqlite-query-interface.js

@@ -136,6 +136,9 @@ const _SqliteQueryInterface = class _SqliteQueryInterface extends import_query_i
                  WHERE name = '${tableName}';`;
     await this.db.sequelize.query(sql, { transaction });
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`${left} in (SELECT value from json_each(${right}))`);
+  }
 };
 __name(_SqliteQueryInterface, "SqliteQueryInterface");
 let SqliteQueryInterface = _SqliteQueryInterface;

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

@@ -80,7 +80,13 @@ const _HasManyRepository = class _HasManyRepository extends import_multiple_rela
     if (options && options["filter"]) {
       const filterResult = this.parseFilter(options["filter"], options);
       if (filterResult.include && filterResult.include.length > 0) {
-        return await this.destroyByFilter(options["filter"], transaction2);
+        return await this.destroyByFilter(
+          {
+            filter: options["filter"],
+            filterByTk: options["filterByTk"]
+          },
+          transaction2
+        );
       }
       where.push(filterResult.where);
     }

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

@@ -18,7 +18,10 @@ export declare abstract class MultipleRelationRepository extends RelationReposit
     remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
     update(options?: UpdateOptions): Promise<any>;
     destroy(options?: TargetKey | DestroyOptions): Promise<boolean>;
-    protected destroyByFilter(filter: Filter, transaction?: Transaction): Promise<boolean>;
+    protected destroyByFilter(options: {
+        filter?: Filter;
+        filterByTk?: TargetKey | TargetKey[];
+    }, transaction?: Transaction): Promise<boolean>;
     protected filterHasInclude(filter: Filter, options?: any): boolean;
     protected accessors(): MultiAssociationAccessors;
     updateOrCreate(options: FirstOrCreateOptions): Promise<any>;

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

@@ -174,9 +174,9 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
   async destroy(options) {
     return false;
   }
-  async destroyByFilter(filter, transaction2) {
+  async destroyByFilter(options, transaction2) {
     const instances = await this.find({
-      filter,
+      ...options,
       transaction: transaction2
     });
     return await this.destroy({

package/lib/repository.d.ts

@@ -20,6 +20,7 @@ import { HasManyRepository } from './relation-repository/hasmany-repository';
 import { HasOneRepository } from './relation-repository/hasone-repository';
 import { RelationRepository } from './relation-repository/relation-repository';
 import { valuesToFilter } from './utils/filter-utils';
+import { SmartCursorBuilder } from './cursor-builder';
 interface CreateManyOptions extends BulkCreateOptions {
     records: Values[];
 }
@@ -145,6 +146,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
     database: Database;
     collection: Collection;
     model: ModelStatic<Model>;
+    cursorBuilder: SmartCursorBuilder;
     constructor(collection: Collection);
     static valuesToFilter: typeof valuesToFilter;
     /**
@@ -157,6 +159,25 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
     chunk(options: FindOptions & {
         chunkSize: number;
         callback: (rows: Model[], options: FindOptions) => Promise<void>;
+        beforeFind?: (options: FindOptions) => Promise<void>;
+        afterFind?: (rows: Model[], options: FindOptions & {
+            offset: number;
+        }) => Promise<void>;
+    }): Promise<void>;
+    /**
+     * 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
+     */
+    chunkWithCursor(options: FindOptions & {
+        chunkSize: number;
+        callback: (rows: Model[], options: FindOptions) => Promise<void>;
+        beforeFind?: (options: FindOptions) => Promise<void>;
+        afterFind?: (rows: Model[], options: FindOptions) => Promise<void>;
     }): Promise<void>;
     /**
      * find