@tachybase/database 0.23.8

package/lib/fields/index.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fields_exports = {};
+module.exports = __toCommonJS(fields_exports);
+__reExport(fields_exports, require("./array-field"), module.exports);
+__reExport(fields_exports, require("./belongs-to-field"), module.exports);
+__reExport(fields_exports, require("./belongs-to-many-field"), module.exports);
+__reExport(fields_exports, require("./boolean-field"), module.exports);
+__reExport(fields_exports, require("./context-field"), module.exports);
+__reExport(fields_exports, require("./date-field"), module.exports);
+__reExport(fields_exports, require("./field"), module.exports);
+__reExport(fields_exports, require("./has-many-field"), module.exports);
+__reExport(fields_exports, require("./has-one-field"), module.exports);
+__reExport(fields_exports, require("./json-field"), module.exports);
+__reExport(fields_exports, require("./number-field"), module.exports);
+__reExport(fields_exports, require("./password-field"), module.exports);
+__reExport(fields_exports, require("./radio-field"), module.exports);
+__reExport(fields_exports, require("./relation-field"), module.exports);
+__reExport(fields_exports, require("./set-field"), module.exports);
+__reExport(fields_exports, require("./sort-field"), module.exports);
+__reExport(fields_exports, require("./string-field"), module.exports);
+__reExport(fields_exports, require("./text-field"), module.exports);
+__reExport(fields_exports, require("./time-field"), module.exports);
+__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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./array-field"),
+  ...require("./belongs-to-field"),
+  ...require("./belongs-to-many-field"),
+  ...require("./boolean-field"),
+  ...require("./context-field"),
+  ...require("./date-field"),
+  ...require("./field"),
+  ...require("./has-many-field"),
+  ...require("./has-one-field"),
+  ...require("./json-field"),
+  ...require("./number-field"),
+  ...require("./password-field"),
+  ...require("./radio-field"),
+  ...require("./relation-field"),
+  ...require("./set-field"),
+  ...require("./sort-field"),
+  ...require("./string-field"),
+  ...require("./text-field"),
+  ...require("./time-field"),
+  ...require("./uid-field"),
+  ...require("./uuid-field"),
+  ...require("./virtual-field"),
+  ...require("./nanoid-field")
+});

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

@@ -0,0 +1,14 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class JsonField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+}
+export interface JsonFieldOptions extends BaseColumnFieldOptions {
+    type: 'json';
+}
+export declare class JsonbField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+}
+export interface JsonbFieldOptions extends BaseColumnFieldOptions {
+    type: 'jsonb';
+}

package/lib/fields/json-field.js

@@ -0,0 +1,54 @@
+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 json_field_exports = {};
+__export(json_field_exports, {
+  JsonField: () => JsonField,
+  JsonbField: () => JsonbField
+});
+module.exports = __toCommonJS(json_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _JsonField = class _JsonField extends import_field.Field {
+  get dataType() {
+    const dialect = this.context.database.sequelize.getDialect();
+    const { jsonb } = this.options;
+    if (dialect === "postgres" && jsonb) {
+      return import_sequelize.DataTypes.JSONB;
+    }
+    return import_sequelize.DataTypes.JSON;
+  }
+};
+__name(_JsonField, "JsonField");
+let JsonField = _JsonField;
+const _JsonbField = class _JsonbField extends import_field.Field {
+  get dataType() {
+    const dialect = this.context.database.sequelize.getDialect();
+    if (dialect === "postgres") {
+      return import_sequelize.DataTypes.JSONB;
+    }
+    return import_sequelize.DataTypes.JSON;
+  }
+};
+__name(_JsonbField, "JsonbField");
+let JsonbField = _JsonbField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonField,
+  JsonbField
+});

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

@@ -0,0 +1,13 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class NanoidField extends Field {
+    get dataType(): DataTypes.StringDataTypeConstructor;
+    init(): void;
+    bind(): void;
+    unbind(): void;
+}
+export interface NanoidFieldOptions extends BaseColumnFieldOptions {
+    type: 'nanoid';
+    size?: number;
+    customAlphabet?: string;
+}

package/lib/fields/nanoid-field.js

@@ -0,0 +1,58 @@
+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 nanoid_field_exports = {};
+__export(nanoid_field_exports, {
+  NanoidField: () => NanoidField
+});
+module.exports = __toCommonJS(nanoid_field_exports);
+var import_nanoid = require("nanoid");
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const DEFAULT_SIZE = 12;
+const _NanoidField = class _NanoidField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.STRING;
+  }
+  init() {
+    const { name, size, customAlphabet: customAlphabetOptions } = this.options;
+    this.listener = async (instance) => {
+      const value = instance.get(name);
+      if (!value) {
+        const nanoIdFunc = customAlphabetOptions ? (0, import_nanoid.customAlphabet)(customAlphabetOptions) : import_nanoid.nanoid;
+        instance.set(name, nanoIdFunc(size || DEFAULT_SIZE));
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
+};
+__name(_NanoidField, "NanoidField");
+let NanoidField = _NanoidField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NanoidField
+});

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

@@ -0,0 +1,41 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+declare abstract class NumberField extends Field {
+}
+export declare class IntegerField extends NumberField {
+    get dataType(): DataTypes.IntegerDataTypeConstructor;
+}
+export interface IntegerFieldOptions extends BaseColumnFieldOptions {
+    type: 'integer';
+}
+export declare class BigIntField extends NumberField {
+    get dataType(): DataTypes.BigIntDataTypeConstructor;
+}
+export interface BigIntFieldOptions extends BaseColumnFieldOptions {
+    type: 'bigInt';
+}
+export declare class FloatField extends NumberField {
+    get dataType(): DataTypes.FloatDataTypeConstructor;
+}
+export interface FloatFieldOptions extends BaseColumnFieldOptions {
+    type: 'float';
+}
+export declare class DoubleField extends NumberField {
+    get dataType(): DataTypes.DoubleDataTypeConstructor;
+}
+export interface DoubleFieldOptions extends BaseColumnFieldOptions {
+    type: 'double';
+}
+export declare class RealField extends NumberField {
+    get dataType(): DataTypes.RealDataTypeConstructor;
+}
+export interface RealFieldOptions extends BaseColumnFieldOptions {
+    type: 'real';
+}
+export declare class DecimalField extends NumberField {
+    get dataType(): DataTypes.DecimalDataTypeConstructor;
+}
+export interface DecimalFieldOptions extends BaseColumnFieldOptions {
+    type: 'decimal';
+}
+export {};

package/lib/fields/number-field.js

@@ -0,0 +1,85 @@
+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 number_field_exports = {};
+__export(number_field_exports, {
+  BigIntField: () => BigIntField,
+  DecimalField: () => DecimalField,
+  DoubleField: () => DoubleField,
+  FloatField: () => FloatField,
+  IntegerField: () => IntegerField,
+  RealField: () => RealField
+});
+module.exports = __toCommonJS(number_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _NumberField = class _NumberField extends import_field.Field {
+};
+__name(_NumberField, "NumberField");
+let NumberField = _NumberField;
+const _IntegerField = class _IntegerField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.INTEGER;
+  }
+};
+__name(_IntegerField, "IntegerField");
+let IntegerField = _IntegerField;
+const _BigIntField = class _BigIntField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.BIGINT;
+  }
+};
+__name(_BigIntField, "BigIntField");
+let BigIntField = _BigIntField;
+const _FloatField = class _FloatField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.FLOAT;
+  }
+};
+__name(_FloatField, "FloatField");
+let FloatField = _FloatField;
+const _DoubleField = class _DoubleField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.DOUBLE;
+  }
+};
+__name(_DoubleField, "DoubleField");
+let DoubleField = _DoubleField;
+const _RealField = class _RealField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.REAL;
+  }
+};
+__name(_RealField, "RealField");
+let RealField = _RealField;
+const _DecimalField = class _DecimalField extends NumberField {
+  get dataType() {
+    return import_sequelize.DataTypes.DECIMAL;
+  }
+};
+__name(_DecimalField, "DecimalField");
+let DecimalField = _DecimalField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigIntField,
+  DecimalField,
+  DoubleField,
+  FloatField,
+  IntegerField,
+  RealField
+});

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

@@ -0,0 +1,21 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export interface PasswordFieldOptions extends BaseColumnFieldOptions {
+    type: 'password';
+    /**
+     * @default 64
+     */
+    length?: number;
+    /**
+     * @default 8
+     */
+    randomBytesSize?: number;
+}
+export declare class PasswordField extends Field {
+    get dataType(): DataTypes.StringDataTypeConstructor;
+    verify(password: string, hash: string): Promise<unknown>;
+    hash(password: string): Promise<unknown>;
+    init(): void;
+    bind(): void;
+    unbind(): void;
+}

package/lib/fields/password-field.js

@@ -0,0 +1,95 @@
+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 password_field_exports = {};
+__export(password_field_exports, {
+  PasswordField: () => PasswordField
+});
+module.exports = __toCommonJS(password_field_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _PasswordField = class _PasswordField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.STRING;
+  }
+  async verify(password, hash) {
+    password = password || "";
+    hash = hash || "";
+    const { length = 64, randomBytesSize = 8 } = this.options;
+    return new Promise((resolve, reject) => {
+      const salt = hash.substring(0, randomBytesSize * 2);
+      const key = hash.substring(randomBytesSize * 2);
+      import_crypto.default.scrypt(password, salt, length / 2 - randomBytesSize, (err, derivedKey) => {
+        if (err) reject(err);
+        resolve(key == derivedKey.toString("hex"));
+      });
+    });
+  }
+  async hash(password) {
+    const { length = 64, randomBytesSize = 8 } = this.options;
+    return new Promise((resolve, reject) => {
+      const salt = import_crypto.default.randomBytes(randomBytesSize).toString("hex");
+      import_crypto.default.scrypt(password, salt, length / 2 - randomBytesSize, (err, derivedKey) => {
+        if (err) reject(err);
+        resolve(salt + derivedKey.toString("hex"));
+      });
+    });
+  }
+  init() {
+    const { name } = this.options;
+    this.listener = async (model) => {
+      if (!model.changed(name)) {
+        return;
+      }
+      const value = model.get(name);
+      if (value) {
+        const hash = await this.hash(value);
+        model.set(name, hash);
+      } else {
+        model.set(name, model.previous(name));
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
+};
+__name(_PasswordField, "PasswordField");
+let PasswordField = _PasswordField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PasswordField
+});

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

@@ -0,0 +1,16 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export interface RadioFieldOptions extends BaseColumnFieldOptions {
+    type: 'radio';
+}
+/**
+ * 暂时只支持全局，不支持批量
+ */
+export declare class RadioField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+    listener: (model: any, { transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    bind(): void;
+    unbind(): void;
+}

package/lib/fields/radio-field.js

@@ -0,0 +1,66 @@
+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 radio_field_exports = {};
+__export(radio_field_exports, {
+  RadioField: () => RadioField
+});
+module.exports = __toCommonJS(radio_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _RadioField = class _RadioField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.BOOLEAN;
+  }
+  listener = /* @__PURE__ */ __name(async (model, { transaction }) => {
+    const { name } = this.options;
+    if (!model.changed(name)) {
+      return;
+    }
+    const value = model.get(name);
+    if (value) {
+      const M = this.collection.model;
+      await M.update(
+        { [name]: false },
+        {
+          where: {
+            [name]: true
+          },
+          transaction,
+          hooks: false
+        }
+      );
+    }
+  }, "listener");
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
+};
+__name(_RadioField, "RadioField");
+let RadioField = _RadioField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RadioField
+});

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

@@ -0,0 +1,21 @@
+import { BaseFieldOptions, Field } from './field';
+export type BaseRelationFieldOptions = BaseFieldOptions;
+export interface MultipleRelationFieldOptions extends BaseRelationFieldOptions {
+    sortBy?: string | string[];
+}
+export declare abstract class RelationField extends Field {
+    /**
+     * target relation name
+     */
+    get target(): any;
+    get foreignKey(): any;
+    get sourceKey(): any;
+    get targetKey(): any;
+    /**
+     * get target model from database by it's name
+     * @constructor
+     */
+    get TargetModel(): import("sequelize").ModelCtor<import("sequelize").Model<any, any>>;
+    keyPairsTypeMatched(type1: any, type2: any): boolean;
+    protected clearAccessors(): void;
+}

package/lib/fields/relation-field.js

@@ -0,0 +1,79 @@
+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 relation_field_exports = {};
+__export(relation_field_exports, {
+  RelationField: () => RelationField
+});
+module.exports = __toCommonJS(relation_field_exports);
+var import_field = require("./field");
+const _RelationField = class _RelationField extends import_field.Field {
+  /**
+   * target relation name
+   */
+  get target() {
+    const { target, name } = this.options;
+    return target || name;
+  }
+  get foreignKey() {
+    return this.options.foreignKey;
+  }
+  get sourceKey() {
+    return this.options.sourceKey || this.collection.model.primaryKeyAttribute;
+  }
+  get targetKey() {
+    return this.options.targetKey || this.TargetModel.primaryKeyAttribute;
+  }
+  /**
+   * get target model from database by it's name
+   * @constructor
+   */
+  get TargetModel() {
+    return this.context.database.sequelize.models[this.target];
+  }
+  keyPairsTypeMatched(type1, type2) {
+    type1 = type1.toLowerCase();
+    type2 = type2.toLowerCase();
+    const numberTypeGroups = ["integer", "bigint", "decimal", "float", "real", "double", "smallint", "tinyint"];
+    const stringTypeGroups = ["string", "char", "text"];
+    if (numberTypeGroups.includes(type1) && numberTypeGroups.includes(type2)) {
+      return true;
+    }
+    if (stringTypeGroups.includes(type1) && stringTypeGroups.includes(type2)) {
+      return true;
+    }
+    return type1 === type2;
+  }
+  clearAccessors() {
+    const { collection } = this.context;
+    const association = collection.model.associations[this.name];
+    if (!association) {
+      return;
+    }
+    const accessors = Object.values(association.accessors);
+    accessors.forEach((accessor) => {
+      delete collection.model.prototype[accessor];
+    });
+  }
+};
+__name(_RelationField, "RelationField");
+let RelationField = _RelationField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RelationField
+});

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

@@ -0,0 +1,10 @@
+import { ArrayField } from './array-field';
+import { BaseColumnFieldOptions } from './field';
+export interface SetFieldOptions extends BaseColumnFieldOptions {
+    type: 'set';
+}
+export declare class SetField extends ArrayField {
+    beforeSave: (model: any) => void;
+    bind(): void;
+    unbind(): void;
+}