@nocobase/database 0.19.0-alpha.9 → 0.20.0-alpha.2

package/lib/collection.d.ts

@@ -84,14 +84,18 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     findField(callback: (field: Field) => boolean): any;
     hasField(name: string): boolean;
     getField<F extends Field>(name: string): F;
+    getFields(): any[];
     addField(name: string, options: FieldOptions): Field;
     checkFieldType(name: string, options: FieldOptions): void;
+    correctOptions(options: any): void;
     setField(name: string, options: FieldOptions): Field;
     setFields(fields: FieldOptions[], resetFields?: boolean): void;
     resetFields(): void;
     remove(): Collection<any, any>;
     removeFieldFromDb(name: string, options?: QueryInterfaceOptions): Promise<void>;
-    removeFromDb(options?: QueryInterfaceDropTableOptions): Promise<Collection<any, any>>;
+    removeFromDb(options?: QueryInterfaceDropTableOptions & {
+        dropCollection?: boolean;
+    }): Promise<Collection<any, any>>;
     existsInDb(options?: Transactionable): Promise<boolean>;
     removeField(name: string): void | Field;
     /**

package/lib/collection.js

@@ -96,11 +96,15 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     this.setSortable(options.sortable);
   }
   get filterTargetKey() {
-    const targetKey = import_lodash.default.get(this.options, "filterTargetKey", this.model.primaryKeyAttribute);
-    if (!targetKey && this.model.rawAttributes["id"]) {
-      return "id";
+    var _a;
+    const targetKey = (_a = this.options) == null ? void 0 : _a.filterTargetKey;
+    if (targetKey && this.model.getAttributes()[targetKey]) {
+      return targetKey;
     }
-    return targetKey;
+    if (this.model.primaryKeyAttributes.length > 1) {
+      return null;
+    }
+    return this.model.primaryKeyAttribute;
   }
   get name() {
     return this.options.name;
@@ -187,6 +191,9 @@ const _Collection = class _Collection extends import_events.EventEmitter {
   getField(name) {
     return this.fields.get(name);
   }
+  getFields() {
+    return [...this.fields.values()];
+  }
   addField(name, options) {
     return this.setField(name, options);
   }
@@ -211,6 +218,11 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       throw new Error(`fields with same column must be of the same type ${JSON.stringify(options)}`);
     }
   }
+  correctOptions(options) {
+    if (options.primaryKey && options.autoIncrement) {
+      delete options.defaultValue;
+    }
+  }
   setField(name, options) {
     (0, import_utils.checkIdentifier)(name);
     this.checkFieldType(name, options);
@@ -233,6 +245,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
         }
       }
     }
+    this.correctOptions(options);
     this.emit("field.beforeAdd", name, options, { collection: this });
     const field = database.buildField(
       { name, ...options },
@@ -253,6 +266,10 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     this.removeField(name);
     this.fields.set(name, field);
     this.emit("field.afterAdd", field);
+    this.db.emit("field.afterAdd", {
+      collection: this,
+      field
+    });
     if (this.isParent()) {
       for (const child of this.context.database.inheritanceMap.getChildren(this.name, {
         deep: false
@@ -306,9 +323,6 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       field.remove();
       return;
     }
-    if (this.model.primaryKeyAttributes.includes(this.name)) {
-      return;
-    }
     if (this.model.options.timestamps !== false) {
       let timestampsFields = ["createdAt", "updatedAt", "deletedAt"];
       if (this.db.options.underscored) {
@@ -341,8 +355,17 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     if (await field.existsInDb({
       transaction: options == null ? void 0 : options.transaction
     }) && columnReferencesCount == 1) {
-      const queryInterface = this.db.sequelize.getQueryInterface();
-      await queryInterface.removeColumn(this.getTableNameWithSchema(), field.columnName(), options);
+      const columns = await this.model.sequelize.getQueryInterface().describeTable(this.getTableNameWithSchema(), options);
+      if (Object.keys(columns).length == 1) {
+        await this.removeFromDb({
+          ...options,
+          cascade: true,
+          dropCollection: false
+        });
+      } else {
+        const queryInterface = this.db.sequelize.getQueryInterface();
+        await queryInterface.removeColumn(this.getTableNameWithSchema(), field.columnName(), options);
+      }
     }
     field.remove();
   }
@@ -353,7 +376,9 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       const queryInterface = this.db.sequelize.getQueryInterface();
       await queryInterface.dropTable(this.getTableNameWithSchema(), options);
     }
-    return this.remove();
+    if ((options == null ? void 0 : options.dropCollection) !== false) {
+      return this.remove();
+    }
   }
   async existsInDb(options) {
     return this.db.queryInterface.collectionTableExists(this, options);

package/lib/database.js

@@ -220,6 +220,9 @@ const _Database = class _Database extends import_events.EventEmitter {
     this.migrations = new import_migration.Migrations(context);
     this.sequelize.beforeDefine((model, opts2) => {
       if (this.options.tablePrefix) {
+        if (opts2.tableName && opts2.tableName.startsWith(this.options.tablePrefix)) {
+          return;
+        }
         opts2.tableName = `${this.options.tablePrefix}${opts2.tableName || opts2.modelName || opts2.name.plural}`;
       }
     });
@@ -445,7 +448,7 @@ const _Database = class _Database extends import_events.EventEmitter {
     return collection;
   }
   hasCollection(name) {
-    return this.collections.has(name);
+    return !!this.getCollection(name);
   }
   removeCollection(name) {
     const collection = this.collections.get(name);
@@ -536,6 +539,9 @@ const _Database = class _Database extends import_events.EventEmitter {
     if (options.field && collection.options.underscored && !collection.isView()) {
       options.field = (0, import_utils2.snakeCase)(options.field);
     }
+    if (Object.prototype.hasOwnProperty.call(options, "defaultValue") && options.defaultValue === null) {
+      delete options.defaultValue;
+    }
     return new Field2(options, context);
   }
   async sync(options) {

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

@@ -91,6 +91,11 @@ const _EagerLoadingTree = class _EagerLoadingTree {
           continue;
         }
         const association = import_lodash.default.isString(include.association) ? eagerLoadingTreeParent.model.associations[include.association] : include.association;
+        if (!association) {
+          throw new Error(
+            `Association "${include.association}" not found in model "${eagerLoadingTreeParent.model.name}"`
+          );
+        }
         const associationType = association.associationType;
         const child = buildNode({
           model: association.target,

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/fields/array-field.js

@@ -31,8 +31,11 @@ const _ArrayField = class _ArrayField extends import_field.Field {
     return import_sequelize.DataTypes.JSON;
   }
   sortValue = (model) => {
-    const oldValue = model.get(this.options.name);
+    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);
     }

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

@@ -13,6 +13,7 @@ export declare class BelongsToField extends RelationField {
         onDelete: any;
     };
     reference(association: any): Reference;
+    checkAssociationKeys(): void;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/belongs-to-field.js

@@ -1,6 +1,8 @@
+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 __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 });
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -26,7 +36,7 @@ __export(belongs_to_field_exports, {
   BelongsToField: () => BelongsToField
 });
 module.exports = __toCommonJS(belongs_to_field_exports);
-var import_lodash = require("lodash");
+var import_lodash = __toESM(require("lodash"));
 var import_sequelize = require("sequelize");
 var import_utils = require("../utils");
 var import_relation_field = require("./relation-field");
@@ -51,6 +61,27 @@ const _BelongsToField = class _BelongsToField extends import_relation_field.Rela
   reference(association) {
     return _BelongsToField.toReference(this.database, association, this.options.onDelete);
   }
+  checkAssociationKeys() {
+    let { foreignKey, targetKey } = this.options;
+    if (!targetKey) {
+      targetKey = this.TargetModel.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_lodash.default.camelCase(`${this.name}_${targetKey}`);
+    }
+    const targetKeyAttribute = this.TargetModel.rawAttributes[targetKey];
+    const foreignKeyAttribute = this.collection.model.rawAttributes[foreignKey];
+    if (!foreignKeyAttribute || !targetKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const targetKeyType = targetKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, targetKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match target key "${targetKey}" type "${targetKeyType}" in belongs to relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -58,6 +89,7 @@ const _BelongsToField = class _BelongsToField extends import_relation_field.Rela
       database.addPendingField(this);
       return false;
     }
+    this.checkAssociationKeys();
     if (collection.model.associations[this.name]) {
       delete collection.model.associations[this.name];
     }
@@ -70,6 +102,9 @@ const _BelongsToField = class _BelongsToField extends import_relation_field.Rela
     if (!this.options.foreignKey) {
       this.options.foreignKey = association.foreignKey;
     }
+    if (!this.options.targetKey) {
+      this.options.targetKey = association.targetKey;
+    }
     try {
       (0, import_utils.checkIdentifier)(this.options.foreignKey);
     } catch (error) {

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

@@ -1,4 +1,4 @@
-import { BelongsToManyOptions as SequelizeBelongsToManyOptions } from 'sequelize';
+import { AssociationScope, BelongsToManyOptions as SequelizeBelongsToManyOptions } from 'sequelize';
 import { Reference } from '../features/ReferencesMap';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 export declare class BelongsToManyField extends RelationField {
@@ -6,6 +6,7 @@ export declare class BelongsToManyField extends RelationField {
     get through(): any;
     get otherKey(): any;
     references(association: any): Reference[];
+    checkAssociationKeys(database: any): void;
     bind(): boolean;
     unbind(): void;
 }
@@ -13,4 +14,7 @@ export interface BelongsToManyFieldOptions extends MultipleRelationFieldOptions,
     type: 'belongsToMany';
     target?: string;
     through?: string;
+    throughScope?: AssociationScope;
+    throughUnique?: boolean;
+    throughParanoid?: boolean;
 }

package/lib/fields/belongs-to-many-field.js

@@ -54,6 +54,47 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       import_belongs_to_field.BelongsToField.toReference(db, sourceAssociation, onDelete)
     ];
   }
+  checkAssociationKeys(database) {
+    let { foreignKey, sourceKey, otherKey, targetKey } = this.options;
+    const through = this.through;
+    const throughCollection = database.getCollection(through);
+    if (!throughCollection) {
+      return;
+    }
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.collection.model.name), sourceKey].join("_"));
+    }
+    if (!targetKey) {
+      targetKey = this.TargetModel.primaryKeyAttribute;
+    }
+    if (!otherKey) {
+      otherKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.TargetModel.name), targetKey].join("_"));
+    }
+    const foreignKeyAttribute = throughCollection.model.rawAttributes[foreignKey];
+    const otherKeyAttribute = throughCollection.model.rawAttributes[otherKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    const targetKeyAttribute = this.TargetModel.rawAttributes[targetKey];
+    if (!foreignKeyAttribute || !otherKeyAttribute || !sourceKeyAttribute || !targetKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const otherKeyType = otherKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    const targetKeyType = targetKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, sourceKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match source key "${sourceKey}" type "${sourceKeyType}" in belongs to many relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+    if (!this.keyPairsTypeMatched(otherKeyType, targetKeyType)) {
+      throw new Error(
+        `Other key "${otherKey}" type "${otherKeyType}" does not match target key "${targetKey}" type "${targetKeyType}" in belongs to many relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -61,6 +102,13 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       database.addPendingField(this);
       return false;
     }
+    if (!this.collection.model.primaryKeyAttribute) {
+      throw new Error(`Collection model ${this.collection.model.name} has no primary key attribute`);
+    }
+    if (!Target.primaryKeyAttribute) {
+      throw new Error(`Target model ${Target.name} has no primary key attribute`);
+    }
+    this.checkAssociationKeys(database);
     const through = this.through;
     let Through;
     if (database.hasCollection(through)) {
@@ -85,7 +133,12 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       constraints: false,
       ...(0, import_lodash.omit)(this.options, ["name", "type", "target"]),
       as: this.name,
-      through: Through.model
+      through: {
+        model: Through.model,
+        scope: this.options.throughScope,
+        paranoid: this.options.throughParanoid,
+        unique: this.options.throughUnique
+      }
     };
     const association = collection.model.belongsToMany(Target, belongsToManyOptions);
     database.removePendingField(this);
@@ -98,6 +151,9 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
     if (!this.options.otherKey) {
       this.options.otherKey = association.otherKey;
     }
+    if (!this.options.targetKey) {
+      this.options.targetKey = association.targetKey;
+    }
     try {
       (0, import_utils.checkIdentifier)(this.options.foreignKey);
       (0, import_utils.checkIdentifier)(this.options.otherKey);

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

@@ -6,6 +6,7 @@ export declare class DateField extends Field {
     getProps(): any;
     isDateOnly(): boolean;
     isGMT(): any;
+    bind(): void;
 }
 export interface DateFieldOptions extends BaseColumnFieldOptions {
     type: 'date';

package/lib/fields/date-field.js

@@ -42,6 +42,19 @@ const _DateField = class _DateField extends import_field.Field {
     const props = this.getProps();
     return props.gmt;
   }
+  bind() {
+    super.bind();
+    if (this.options.interface === "createdAt") {
+      const { model } = this.context.collection;
+      model._timestampAttributes.createdAt = this.name;
+      model.refreshAttributes();
+    }
+    if (this.options.interface === "updatedAt") {
+      const { model } = this.context.collection;
+      model._timestampAttributes.updatedAt = this.name;
+      model.refreshAttributes();
+    }
+  }
 };
 __name(_DateField, "DateField");
 let DateField = _DateField;

package/lib/fields/has-many-field.d.ts

@@ -58,6 +58,7 @@ export declare class HasManyField extends RelationField {
     get dataType(): any;
     get foreignKey(): any;
     reference(association: any): Reference;
+    checkAssociationKeys(): void;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/has-many-field.js

@@ -46,6 +46,27 @@ const _HasManyField = class _HasManyField extends import_relation_field.Relation
       onDelete: this.options.onDelete
     };
   }
+  checkAssociationKeys() {
+    let { foreignKey, sourceKey } = this.options;
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.name), this.collection.model.primaryKeyAttribute].join("_"));
+    }
+    const foreignKeyAttribute = this.TargetModel.rawAttributes[foreignKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    if (!foreignKeyAttribute || !sourceKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, sourceKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match source key "${sourceKey}" type "${sourceKeyType}" in has many relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -53,6 +74,7 @@ const _HasManyField = class _HasManyField extends import_relation_field.Relation
       database.addPendingField(this);
       return false;
     }
+    this.checkAssociationKeys();
     if (collection.model.associations[this.name]) {
       delete collection.model.associations[this.name];
     }
@@ -66,6 +88,9 @@ const _HasManyField = class _HasManyField extends import_relation_field.Relation
     if (!this.options.foreignKey) {
       this.options.foreignKey = association.foreignKey;
     }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
     try {
       (0, import_utils.checkIdentifier)(this.options.foreignKey);
     } catch (error) {

package/lib/fields/has-one-field.d.ts

@@ -59,6 +59,7 @@ export declare class HasOneField extends RelationField {
     get target(): any;
     get foreignKey(): any;
     reference(association: any): Reference;
+    checkAssociationKeys(): void;
     bind(): boolean;
     unbind(): void;
 }

package/lib/fields/has-one-field.js

@@ -53,6 +53,27 @@ const _HasOneField = class _HasOneField extends import_relation_field.RelationFi
       onDelete: this.options.onDelete
     };
   }
+  checkAssociationKeys() {
+    let { foreignKey, sourceKey } = this.options;
+    if (!sourceKey) {
+      sourceKey = this.collection.model.primaryKeyAttribute;
+    }
+    if (!foreignKey) {
+      foreignKey = import_sequelize.Utils.camelize([import_sequelize.Utils.singularize(this.name), this.collection.model.primaryKeyAttribute].join("_"));
+    }
+    const foreignKeyAttribute = this.TargetModel.rawAttributes[foreignKey];
+    const sourceKeyAttribute = this.collection.model.rawAttributes[sourceKey];
+    if (!foreignKeyAttribute || !sourceKeyAttribute) {
+      return;
+    }
+    const foreignKeyType = foreignKeyAttribute.type.constructor.toString();
+    const sourceKeyType = sourceKeyAttribute.type.constructor.toString();
+    if (!this.keyPairsTypeMatched(foreignKeyType, sourceKeyType)) {
+      throw new Error(
+        `Foreign key "${foreignKey}" type "${foreignKeyType}" does not match source key "${sourceKey}" type "${sourceKeyType}" in has one relation "${this.name}" of collection "${this.collection.name}"`
+      );
+    }
+  }
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -60,6 +81,7 @@ const _HasOneField = class _HasOneField extends import_relation_field.RelationFi
       database.addPendingField(this);
       return false;
     }
+    this.checkAssociationKeys();
     const association = collection.model.hasOne(Target, {
       constraints: false,
       ...(0, import_lodash.omit)(this.options, ["name", "type", "target", "onDelete"]),
@@ -70,6 +92,9 @@ const _HasOneField = class _HasOneField extends import_relation_field.RelationFi
     if (!this.options.foreignKey) {
       this.options.foreignKey = association.foreignKey;
     }
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
+    }
     try {
       (0, import_utils.checkIdentifier)(this.options.foreignKey);
     } catch (error) {

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

@@ -16,5 +16,6 @@ export declare abstract class RelationField extends Field {
      * @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

@@ -46,6 +46,19 @@ const _RelationField = class _RelationField extends import_field.Field {
   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];

package/lib/inherited-collection.d.ts

@@ -3,11 +3,12 @@ import { Collection, CollectionContext, CollectionOptions } from './collection';
 export declare class InheritedCollection extends Collection {
     parents?: Collection[];
     constructor(options: CollectionOptions, context: CollectionContext);
-    protected bindParents(): void;
-    protected setParents(inherits: string | string[]): void;
-    protected setParentFields(): void;
     getParents(): Collection<any, any>[];
+    getFlatParents(): any[];
     parentFields(): Map<string, Field>;
     parentAttributes(): {};
     isInherited(): boolean;
+    protected bindParents(): void;
+    protected setParents(inherits: string | string[]): void;
+    protected setParentFields(): void;
 }

package/lib/inherited-collection.js

@@ -57,31 +57,18 @@ const _InheritedCollection = class _InheritedCollection extends import_collectio
       }
     }
   }
-  bindParents() {
-    this.setParents(this.options.inherits);
-    this.setParentFields();
-    this.setFields(this.options.fields, false);
-    this.db.inheritanceMap.setInheritance(this.name, this.options.inherits);
+  getParents() {
+    return this.parents;
   }
-  setParents(inherits) {
-    this.parents = import_lodash.default.castArray(inherits).map((name) => {
-      const existCollection = this.db.collections.get(name);
-      if (!existCollection) {
-        throw new ParentCollectionNotFound(name);
+  getFlatParents() {
+    const parents = [];
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        parents.push(...parent.getFlatParents());
       }
-      return existCollection;
-    });
-  }
-  setParentFields() {
-    for (const [name, fieldOptions] of this.parentFields()) {
-      this.setField(name, {
-        ...fieldOptions,
-        inherit: true
-      });
+      parents.push(parent);
     }
-  }
-  getParents() {
-    return this.parents;
+    return parents;
   }
   parentFields() {
     const fields = /* @__PURE__ */ new Map();
@@ -112,6 +99,29 @@ const _InheritedCollection = class _InheritedCollection extends import_collectio
   isInherited() {
     return true;
   }
+  bindParents() {
+    this.setParents(this.options.inherits);
+    this.setParentFields();
+    this.setFields(this.options.fields, false);
+    this.db.inheritanceMap.setInheritance(this.name, this.options.inherits);
+  }
+  setParents(inherits) {
+    this.parents = import_lodash.default.castArray(inherits).map((name) => {
+      const existCollection = this.db.collections.get(name);
+      if (!existCollection) {
+        throw new ParentCollectionNotFound(name);
+      }
+      return existCollection;
+    });
+  }
+  setParentFields() {
+    for (const [name, fieldOptions] of this.parentFields()) {
+      this.setField(name, {
+        ...fieldOptions,
+        inherit: true
+      });
+    }
+  }
 };
 __name(_InheritedCollection, "InheritedCollection");
 let InheritedCollection = _InheritedCollection;