@tachybase/database 0.23.8

package/lib/errors/identifier-error.js

@@ -0,0 +1,35 @@
+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 identifier_error_exports = {};
+__export(identifier_error_exports, {
+  IdentifierError: () => IdentifierError
+});
+module.exports = __toCommonJS(identifier_error_exports);
+const _IdentifierError = class _IdentifierError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IdentifierError";
+  }
+};
+__name(_IdentifierError, "IdentifierError");
+let IdentifierError = _IdentifierError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IdentifierError
+});

package/lib/errors/zero-column-table-error.d.ts

@@ -0,0 +1,2 @@
+export declare class ZeroColumnTableError extends Error {
+}

package/lib/errors/zero-column-table-error.js

@@ -0,0 +1,31 @@
+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 zero_column_table_error_exports = {};
+__export(zero_column_table_error_exports, {
+  ZeroColumnTableError: () => ZeroColumnTableError
+});
+module.exports = __toCommonJS(zero_column_table_error_exports);
+const _ZeroColumnTableError = class _ZeroColumnTableError extends Error {
+};
+__name(_ZeroColumnTableError, "ZeroColumnTableError");
+let ZeroColumnTableError = _ZeroColumnTableError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZeroColumnTableError
+});

package/lib/features/references-map.d.ts

@@ -0,0 +1,18 @@
+export type ReferencePriority = 'default' | 'user';
+export interface Reference {
+    sourceCollectionName: string;
+    sourceField: string;
+    targetField: string;
+    targetCollectionName: string;
+    onDelete: string;
+    priority: ReferencePriority;
+}
+export declare function buildReference(options: Partial<Reference>): Reference;
+declare class ReferencesMap {
+    protected map: Map<string, Reference[]>;
+    addReference(reference: Reference): void;
+    getReferences(collectionName: any): Reference[];
+    existReference(reference: Reference): Reference;
+    removeReference(reference: Reference): void;
+}
+export default ReferencesMap;

package/lib/features/references-map.js

@@ -0,0 +1,109 @@
+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 references_map_exports = {};
+__export(references_map_exports, {
+  buildReference: () => buildReference,
+  default: () => references_map_default
+});
+module.exports = __toCommonJS(references_map_exports);
+const DEFAULT_ON_DELETE = "NO ACTION";
+function buildReference(options) {
+  const { sourceCollectionName, sourceField, targetField, targetCollectionName, onDelete, priority } = options;
+  return {
+    sourceCollectionName,
+    sourceField,
+    targetField,
+    targetCollectionName,
+    onDelete: (onDelete || DEFAULT_ON_DELETE).toUpperCase(),
+    priority: assignPriority(priority, onDelete)
+  };
+}
+__name(buildReference, "buildReference");
+function assignPriority(priority, onDelete) {
+  if (priority) {
+    return priority;
+  }
+  return onDelete ? "user" : "default";
+}
+__name(assignPriority, "assignPriority");
+const PRIORITY_MAP = {
+  default: 1,
+  user: 2
+};
+const _ReferencesMap = class _ReferencesMap {
+  map = /* @__PURE__ */ new Map();
+  addReference(reference) {
+    const existReference = this.existReference(reference);
+    if (existReference && existReference.onDelete !== reference.onDelete) {
+      const existPriority = PRIORITY_MAP[existReference.priority];
+      const newPriority = PRIORITY_MAP[reference.priority];
+      if (newPriority > existPriority) {
+        existReference.onDelete = reference.onDelete;
+        existReference.priority = reference.priority;
+      } else if (newPriority === existPriority && newPriority === PRIORITY_MAP["user"]) {
+        if (existReference.onDelete === "SET NULL" && reference.onDelete === "CASCADE") {
+          existReference.onDelete = reference.onDelete;
+        } else {
+          console.error(
+            new Error(
+              `On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(
+                reference
+              )}`
+            )
+          );
+        }
+      }
+    }
+    if (!existReference) {
+      this.map.set(reference.targetCollectionName, [
+        ...this.map.get(reference.targetCollectionName) || [],
+        reference
+      ]);
+    }
+  }
+  getReferences(collectionName) {
+    return this.map.get(collectionName);
+  }
+  existReference(reference) {
+    const references = this.map.get(reference.targetCollectionName);
+    if (!references) {
+      return null;
+    }
+    const keys = Object.keys(reference).filter((k) => k !== "onDelete" && k !== "priority");
+    return references.find((ref) => keys.every((key) => ref[key] === reference[key]));
+  }
+  removeReference(reference) {
+    const references = this.map.get(reference.targetCollectionName);
+    if (!references) {
+      return;
+    }
+    const keys = ["sourceCollectionName", "sourceField", "targetField", "targetCollectionName"];
+    this.map.set(
+      reference.targetCollectionName,
+      references.filter((ref) => !keys.every((key) => ref[key] === reference[key]))
+    );
+  }
+};
+__name(_ReferencesMap, "ReferencesMap");
+let ReferencesMap = _ReferencesMap;
+var references_map_default = ReferencesMap;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildReference
+});

package/lib/features/referential-integrity-check.d.ts

@@ -0,0 +1,8 @@
+import { Model, Transactionable } from 'sequelize';
+import Database from '../database';
+interface ReferentialIntegrityCheckOptions extends Transactionable {
+    db: Database;
+    referencedInstance: Model;
+}
+export declare function referentialIntegrityCheck(options: ReferentialIntegrityCheckOptions): Promise<void>;
+export {};

package/lib/features/referential-integrity-check.js

@@ -0,0 +1,83 @@
+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 referential_integrity_check_exports = {};
+__export(referential_integrity_check_exports, {
+  referentialIntegrityCheck: () => referentialIntegrityCheck
+});
+module.exports = __toCommonJS(referential_integrity_check_exports);
+async function referentialIntegrityCheck(options) {
+  const { referencedInstance, db, transaction } = options;
+  const collection = db.modelCollection.get(referencedInstance.constructor);
+  const collectionName = collection.name;
+  const references = db.referenceMap.getReferences(collectionName);
+  if (!references) {
+    return;
+  }
+  for (const reference of references) {
+    const { sourceCollectionName, sourceField, targetField, onDelete } = reference;
+    if (onDelete === "NO ACTION") {
+      continue;
+    }
+    const sourceCollection = db.collections.get(sourceCollectionName);
+    const sourceRepository = sourceCollection.repository;
+    if (sourceCollection.isView()) {
+      continue;
+    }
+    const filter = {
+      [sourceField]: referencedInstance[targetField]
+    };
+    const referencingExists = await sourceRepository.count({
+      filter,
+      transaction
+    });
+    if (!referencingExists) {
+      continue;
+    }
+    if (onDelete === "RESTRICT") {
+      const data = await sourceRepository.find({ filter });
+      const transData = data.map((item) => `id:${item.id} \u6570\u636E:${item[sourceCollection.options.titleField]}`).join(",");
+      const error = new Error(
+        `\u8FD9\u6761\u65E0\u6CD5\u5220\u9664\uFF0C\u8FD8\u6709\u5B58\u5728\u7684\u4F7F\u7528\u5B83\u7684\u6570\u636E\uFF0C\u8FD9\u6761\u6570\u636E\u4E3A 
+        ${sourceCollection.options.title || sourceCollectionName} \u7684\uFF1A${transData}`
+      );
+      throw error;
+    }
+    if (onDelete === "CASCADE") {
+      await sourceRepository.destroy({
+        filter,
+        transaction
+      });
+    }
+    if (onDelete === "SET NULL") {
+      await sourceRepository.update({
+        filter,
+        values: {
+          [sourceField]: null
+        },
+        hooks: false,
+        transaction
+      });
+    }
+  }
+}
+__name(referentialIntegrityCheck, "referentialIntegrityCheck");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  referentialIntegrityCheck
+});

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

@@ -0,0 +1,28 @@
+import { Transactionable } from 'sequelize';
+import { Collection } from '../collection';
+export declare class ArrayFieldRepository {
+    protected collection: Collection;
+    protected fieldName: string;
+    protected targetValue: string | number;
+    constructor(collection: Collection, fieldName: string, targetValue: string | number);
+    get(options?: Transactionable): Promise<any>;
+    find(options?: Transactionable): Promise<any>;
+    set(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    protected emitAfterSave(instance: any, options: any): Promise<void>;
+    toggle(options: Transactionable & {
+        value: string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    add(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    remove(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    protected getInstance(options: Transactionable): Promise<any>;
+}

package/lib/field-repository/array-field-repository.js

@@ -0,0 +1,197 @@
+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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var array_field_repository_exports = {};
+__export(array_field_repository_exports, {
+  ArrayFieldRepository: () => ArrayFieldRepository
+});
+module.exports = __toCommonJS(array_field_repository_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_transaction_decorator = require("../decorators/transaction-decorator");
+var import_fields = require("../fields");
+var _remove_dec, _add_dec, _toggle_dec, _set_dec, _find_dec, _get_dec, _init;
+const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
+  return this.collection.model.sequelize.transaction();
+});
+_get_dec = [transaction()], _find_dec = [transaction()], _set_dec = [transaction((args, transaction2) => {
+  return {
+    values: args[0],
+    transaction: transaction2
+  };
+})], _toggle_dec = [transaction((args, transaction2) => {
+  return {
+    value: args[0],
+    transaction: transaction2
+  };
+})], _add_dec = [transaction((args, transaction2) => {
+  return {
+    values: args[0],
+    transaction: transaction2
+  };
+})], _remove_dec = [transaction((args, transaction2) => {
+  return {
+    values: args[0],
+    transaction: transaction2
+  };
+})];
+const _ArrayFieldRepository = class _ArrayFieldRepository {
+  constructor(collection, fieldName, targetValue) {
+    this.collection = collection;
+    this.fieldName = fieldName;
+    this.targetValue = targetValue;
+    __runInitializers(_init, 5, this);
+    const field = collection.getField(fieldName);
+    if (!(field instanceof import_fields.ArrayField)) {
+      throw new Error("Field must be of type Array");
+    }
+  }
+  async get(options) {
+    const instance = await this.getInstance(options);
+    return instance.get(this.fieldName);
+  }
+  async find(options) {
+    return await this.get(options);
+  }
+  async set(options) {
+    const { transaction: transaction2 } = options;
+    const instance = await this.getInstance({
+      transaction: transaction2
+    });
+    instance.set(this.fieldName, import_lodash.default.castArray(options.values));
+    await instance.save({ transaction: transaction2 });
+    if (options.hooks !== false) {
+      await this.emitAfterSave(instance, options);
+    }
+  }
+  async emitAfterSave(instance, options) {
+    await this.collection.db.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, {
+      ...options
+    });
+    instance.clearChangedWithAssociations();
+  }
+  async toggle(options) {
+    const { transaction: transaction2 } = options;
+    const instance = await this.getInstance({
+      transaction: transaction2
+    });
+    const oldValue = instance.get(this.fieldName) || [];
+    const newValue = oldValue.includes(options.value) ? import_lodash.default.without(oldValue, options.value) : [...oldValue, options.value];
+    instance.set(this.fieldName, newValue);
+    await instance.save({ transaction: transaction2 });
+    if (options.hooks !== false) {
+      await this.emitAfterSave(instance, options);
+    }
+  }
+  async add(options) {
+    const { transaction: transaction2 } = options;
+    const instance = await this.getInstance({
+      transaction: transaction2
+    });
+    const oldValue = instance.get(this.fieldName) || [];
+    const newValue = [...oldValue, ...import_lodash.default.castArray(options.values)];
+    instance.set(this.fieldName, newValue);
+    await instance.save({ transaction: transaction2 });
+    if (options.hooks !== false) {
+      await this.emitAfterSave(instance, options);
+    }
+  }
+  async remove(options) {
+    const { transaction: transaction2 } = options;
+    const instance = await this.getInstance({
+      transaction: transaction2
+    });
+    const oldValue = instance.get(this.fieldName) || [];
+    instance.set(this.fieldName, import_lodash.default.without(oldValue, ...import_lodash.default.castArray(options.values)));
+    await instance.save({ transaction: transaction2 });
+    if (options.hooks !== false) {
+      await this.emitAfterSave(instance, options);
+    }
+  }
+  getInstance(options) {
+    return this.collection.repository.findOne({
+      filterByTk: this.targetValue
+    });
+  }
+};
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "get", _get_dec, _ArrayFieldRepository);
+__decorateElement(_init, 1, "find", _find_dec, _ArrayFieldRepository);
+__decorateElement(_init, 1, "set", _set_dec, _ArrayFieldRepository);
+__decorateElement(_init, 1, "toggle", _toggle_dec, _ArrayFieldRepository);
+__decorateElement(_init, 1, "add", _add_dec, _ArrayFieldRepository);
+__decorateElement(_init, 1, "remove", _remove_dec, _ArrayFieldRepository);
+__decoratorMetadata(_init, _ArrayFieldRepository);
+__name(_ArrayFieldRepository, "ArrayFieldRepository");
+let ArrayFieldRepository = _ArrayFieldRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayFieldRepository
+});

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

@@ -0,0 +1,11 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class ArrayField extends Field {
+    get dataType(): DataTypes.AbstractDataTypeConstructor;
+    sortValue: (model: any) => void;
+    bind(): void;
+    unbind(): void;
+}
+export interface ArrayFieldOptions extends BaseColumnFieldOptions {
+    type: 'array';
+}

package/lib/fields/array-field.js

@@ -0,0 +1,57 @@
+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 array_field_exports = {};
+__export(array_field_exports, {
+  ArrayField: () => ArrayField
+});
+module.exports = __toCommonJS(array_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _ArrayField = class _ArrayField extends import_field.Field {
+  get dataType() {
+    if (this.database.sequelize.getDialect() === "postgres") {
+      return import_sequelize.DataTypes.JSONB;
+    }
+    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);
+      }
+      const newValue = oldValue.sort();
+      model.set(this.options.name, newValue);
+    }
+  }, "sortValue");
+  bind() {
+    super.bind();
+    this.on("beforeSave", this.sortValue);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeSave", this.sortValue);
+  }
+};
+__name(_ArrayField, "ArrayField");
+let ArrayField = _ArrayField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayField
+});

package/lib/fields/belongs-to-field.d.ts

@@ -0,0 +1,17 @@
+import { BelongsToOptions as SequelizeBelongsToOptions } from 'sequelize';
+import { Reference, ReferencePriority } from '../features/references-map';
+import { BaseRelationFieldOptions, RelationField } from './relation-field';
+export declare class BelongsToField extends RelationField {
+    static type: string;
+    get dataType(): string;
+    get target(): any;
+    static toReference(db: any, association: any, onDelete: any, priority?: ReferencePriority): Reference;
+    reference(association: any): Reference;
+    checkAssociationKeys(): void;
+    bind(): boolean;
+    unbind(): void;
+}
+export interface BelongsToFieldOptions extends BaseRelationFieldOptions, SequelizeBelongsToOptions {
+    type: 'belongsTo';
+    target?: string;
+}