@nocobase/plugin-data-source-main 1.0.0-alpha.1

package/dist/server/migrations/20230509111114-alert-ui-schema.js

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 alert_ui_schema_exports = {};
+__export(alert_ui_schema_exports, {
+  default: () => alert_ui_schema_default
+});
+module.exports = __toCommonJS(alert_ui_schema_exports);
+var import_server = require("@nocobase/server");
+/* istanbul ignore file -- @preserve */
+class alert_ui_schema_default extends import_server.Migration {
+  appVersion = "<0.9.3-alpha.1";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.9.2-alpha.5");
+    if (!result) {
+      return;
+    }
+    const transaction = await this.db.sequelize.transaction();
+    const migrateFieldsSchema = async (collection) => {
+      this.app.log.info(`Start to migrate ${collection.name} collection's ui schema`);
+      const fieldRecords = await collection.repository.find({
+        transaction,
+        filter: {
+          type: ["hasOne", "hasMany", "belongsTo", "belongsToMany"]
+        }
+      });
+      const fieldsCount = await collection.repository.count({
+        transaction,
+        filter: {
+          type: ["hasOne", "hasMany", "belongsTo", "belongsToMany"]
+        }
+      });
+      this.app.log.info(`Total ${fieldsCount} fields need to be migrated`);
+      let i = 0;
+      for (const fieldRecord of fieldRecords) {
+        i++;
+        this.app.log.info(
+          `Migrate field ${fieldRecord.get("collectionName")}.${fieldRecord.get("name")}, ${i}/${fieldsCount}`
+        );
+        const uiSchema = fieldRecord.get("uiSchema");
+        if ((uiSchema == null ? void 0 : uiSchema["x-component"]) !== "RecordPicker") {
+          continue;
+        }
+        console.log(`${fieldRecord.get("collectionName")}.${fieldRecord.get("name")}: ${uiSchema["x-component"]}`);
+        uiSchema["x-component"] = "AssociationField";
+        fieldRecord.set("uiSchema", uiSchema);
+        await fieldRecord.save({
+          transaction
+        });
+      }
+    };
+    try {
+      await migrateFieldsSchema(this.db.getCollection("fields"));
+      if (this.db.getCollection("fieldsHistory")) {
+        await migrateFieldsSchema(this.db.getCollection("fieldsHistory"));
+      }
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      this.app.log.error(error);
+      throw error;
+    }
+  }
+}

package/dist/server/migrations/20230623145414-number-step.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230623145414-number-step.js

@@ -0,0 +1,72 @@
+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 __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 number_step_exports = {};
+__export(number_step_exports, {
+  default: () => number_step_default
+});
+module.exports = __toCommonJS(number_step_exports);
+var import_server = require("@nocobase/server");
+var import_lodash = __toESM(require("lodash"));
+/* istanbul ignore file -- @preserve */
+class number_step_default extends import_server.Migration {
+  appVersion = "<0.10.0-alpha.3";
+  async up() {
+    const transaction = await this.db.sequelize.transaction();
+    const migrateFieldsSchema = async (collection) => {
+      var _a;
+      this.app.log.info(`Start to migrate ${collection.name} collection's ui schema`);
+      const fieldRecords = await collection.repository.find({
+        transaction,
+        filter: {
+          type: ["bigInt", "float", "double"]
+        }
+      });
+      this.app.log.info(`Total ${fieldRecords.length} fields need to be migrated`);
+      for (const fieldRecord of fieldRecords) {
+        const uiSchema = fieldRecord.get("uiSchema");
+        if (((_a = uiSchema == null ? void 0 : uiSchema["x-component-props"]) == null ? void 0 : _a.step) !== "0") {
+          continue;
+        }
+        import_lodash.default.set(uiSchema, "x-component-props.step", "1");
+        fieldRecord.set("uiSchema", uiSchema);
+        await fieldRecord.save({
+          transaction
+        });
+        console.log(`changed: ${fieldRecord.get("collectionName")}.${fieldRecord.get("name")}`);
+      }
+    };
+    try {
+      await migrateFieldsSchema(this.db.getCollection("fields"));
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      this.app.log.error(error);
+      throw error;
+    }
+  }
+}

package/dist/server/migrations/20230704222935-tableoid.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230704222935-tableoid.js

@@ -0,0 +1,74 @@
+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 __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 tableoid_exports = {};
+__export(tableoid_exports, {
+  default: () => tableoid_default
+});
+module.exports = __toCommonJS(tableoid_exports);
+var import_server = require("@nocobase/server");
+var import_lodash = __toESM(require("lodash"));
+/* istanbul ignore file -- @preserve */
+class tableoid_default extends import_server.Migration {
+  appVersion = "<0.10.1-alpha.1";
+  async up() {
+    var _a;
+    if (!this.db.inDialect("postgres")) {
+      return;
+    }
+    const repository = this.db.getRepository("collections");
+    let names = [];
+    const items = await repository.find();
+    for (const item of items) {
+      if (Array.isArray((_a = item.options) == null ? void 0 : _a.inherits) && item.options.inherits.length) {
+        names.push(item.name);
+        names.push(...item.options.inherits);
+      }
+    }
+    names = import_lodash.default.uniq(names);
+    console.log("collection names:", names);
+    for (const name of names) {
+      const fieldRepository = this.db.getRepository("fields");
+      await fieldRepository.firstOrCreate({
+        values: {
+          collectionName: name,
+          name: "__collection",
+          type: "virtual",
+          interface: "tableoid",
+          uiSchema: {
+            type: "string",
+            title: '{{t("Table OID")}}',
+            "x-component": "CollectionSelect",
+            "x-component-props": { isTableOid: true },
+            "x-read-pretty": true
+          }
+        },
+        filterKeys: ["name", "collectionName"]
+      });
+    }
+  }
+}

package/dist/server/migrations/20230918024546-set-collection-schema.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230918024546-set-collection-schema.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 set_collection_schema_exports = {};
+__export(set_collection_schema_exports, {
+  default: () => set_collection_schema_default
+});
+module.exports = __toCommonJS(set_collection_schema_exports);
+var import_server = require("@nocobase/server");
+/* istanbul ignore file -- @preserve */
+class set_collection_schema_default extends import_server.Migration {
+  appVersion = "<0.14.0-alpha.4";
+  async up() {
+    if (!this.db.inDialect("postgres")) {
+      return;
+    }
+    if (this.context.app.name !== "main") {
+      return;
+    }
+    const userCollections = await this.db.getRepository("collections").find({
+      filter: {
+        "options.schema": null,
+        "options.from.$ne": "db2cm"
+      }
+    });
+    for (const collection of userCollections) {
+      await collection.set("schema", process.env.COLLECTION_MANAGER_SCHEMA || this.db.options.schema || "public");
+      await collection.save();
+    }
+    await this.context.app.emitAsync("loadCollections");
+  }
+}

package/dist/server/migrations/20240220153103-install-main-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20240220153103-install-main-datasource.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 install_main_datasource_exports = {};
+__export(install_main_datasource_exports, {
+  default: () => install_main_datasource_default
+});
+module.exports = __toCommonJS(install_main_datasource_exports);
+var import_server = require("@nocobase/server");
+/* istanbul ignore file -- @preserve */
+class install_main_datasource_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.20.0-alpha.1";
+  async up() {
+    const dataSourcesCollection = this.app.db.getCollection("dataSources");
+    await dataSourcesCollection.repository.firstOrCreate({
+      filterKeys: ["key"],
+      values: {
+        key: "main",
+        type: "main",
+        displayName: "Main",
+        fixed: true,
+        options: {}
+      }
+    });
+  }
+}

package/dist/server/migrations/20240419182147-fix-created-by-field-target.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20240419182147-fix-created-by-field-target.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 fix_created_by_field_target_exports = {};
+__export(fix_created_by_field_target_exports, {
+  default: () => fix_created_by_field_target_default
+});
+module.exports = __toCommonJS(fix_created_by_field_target_exports);
+var import_server = require("@nocobase/server");
+class fix_created_by_field_target_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.21.0-alpha.12";
+  async up() {
+    const fields = await this.db.getRepository("fields").find({
+      filter: {
+        name: ["createdBy", "updatedBy"],
+        "options.target.$ne": "users"
+      }
+    });
+    for (const field of fields) {
+      field.set("target", "users");
+      await field.save();
+    }
+  }
+}

package/dist/server/migrations/20240420105949-add-sort-field.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20240420105949-add-sort-field.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 add_sort_field_exports = {};
+__export(add_sort_field_exports, {
+  default: () => add_sort_field_default
+});
+module.exports = __toCommonJS(add_sort_field_exports);
+var import_server = require("@nocobase/server");
+class add_sort_field_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.21.0-alpha.13";
+  async up() {
+    const repository = this.db.getRepository("collections");
+    await repository.load();
+    const collections = await this.db.getRepository("collections").find();
+    const fields = [];
+    for (const item of collections) {
+      const collection = this.db.getCollection(item.name);
+      collection.forEachField((field) => {
+        if (field.type === "sort") {
+          fields.push({
+            collectionName: item.name,
+            name: field.name
+          });
+        }
+      });
+    }
+    const fieldRepository = this.db.getRepository("fields");
+    for (const field of fields) {
+      this.app.log.info(`field path: ${field.collectionName}.${field.name}`);
+      const instance = await fieldRepository.findOne({
+        filter: field
+      });
+      if (instance == null ? void 0 : instance.interface) {
+        continue;
+      }
+      await fieldRepository.updateOrCreate({
+        values: {
+          ...field,
+          interface: "sort",
+          type: "sort",
+          hidden: false,
+          uiSchema: {
+            type: "number",
+            title: field.name,
+            "x-component": "InputNumber",
+            "x-component-props": { stringMode: true, step: "1" },
+            "x-validator": "integer"
+          },
+          scopeKey: instance == null ? void 0 : instance.scopeKey
+        },
+        filterKeys: ["collectionName", "name"]
+      });
+    }
+  }
+}

package/dist/server/models/collection.d.ts

@@ -0,0 +1,19 @@
+import Database, { Collection, MagicAttributeModel, SyncOptions, Transactionable } from '@nocobase/database';
+import { QueryInterfaceDropTableOptions } from 'sequelize';
+interface LoadOptions extends Transactionable {
+    skipField?: boolean | Array<string>;
+    skipExist?: boolean;
+    resetFields?: boolean;
+}
+export declare class CollectionModel extends MagicAttributeModel {
+    get db(): Database;
+    toJSON(): any;
+    load(loadOptions?: LoadOptions): Promise<Collection<any, any>>;
+    loadFields(options?: Transactionable & {
+        skipField?: Array<string>;
+        includeFields?: Array<string>;
+    }): Promise<void>;
+    remove(options?: Transactionable & QueryInterfaceDropTableOptions): Promise<void>;
+    migrate(options?: SyncOptions & Transactionable): Promise<void>;
+}
+export {};

package/dist/server/models/collection.js

@@ -0,0 +1,185 @@
+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 __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 collection_exports = {};
+__export(collection_exports, {
+  CollectionModel: () => CollectionModel
+});
+module.exports = __toCommonJS(collection_exports);
+var import_database = require("@nocobase/database");
+var import_lodash = __toESM(require("lodash"));
+class CollectionModel extends import_database.MagicAttributeModel {
+  get db() {
+    return this.constructor.database;
+  }
+  toJSON() {
+    const json = super.toJSON();
+    if (!json.filterTargetKey) {
+      const collection = this.db.getCollection(json.name);
+      json.filterTargetKey = collection == null ? void 0 : collection.filterTargetKey;
+    }
+    return json;
+  }
+  async load(loadOptions = {}) {
+    const { skipExist, skipField, resetFields, transaction } = loadOptions;
+    const name = this.get("name");
+    let collection;
+    const collectionOptions = {
+      origin: "@nocobase/plugin-data-source-main",
+      ...this.get(),
+      fields: [],
+      loadedFromCollectionManager: true
+    };
+    if (!this.db.inDialect("postgres") && collectionOptions.schema) {
+      delete collectionOptions.schema;
+    }
+    if (this.db.hasCollection(name)) {
+      collection = this.db.getCollection(name);
+      if (skipExist) {
+        return collection;
+      }
+      if (resetFields) {
+        collection.resetFields();
+      }
+      collection.updateOptions(collectionOptions);
+    } else {
+      if (!collectionOptions.dumpRules) {
+        import_lodash.default.set(collectionOptions, "dumpRules.group", "custom");
+      }
+      collection = this.db.collection(collectionOptions);
+    }
+    if (!skipField) {
+      await this.loadFields({ transaction });
+    }
+    if (import_lodash.default.isArray(skipField)) {
+      await this.loadFields({ transaction, skipField });
+    }
+    await this.db.emitAsync("collection:loaded", {
+      collection,
+      transaction
+    });
+    return collection;
+  }
+  async loadFields(options = {}) {
+    let fields = this.get("fields") || [];
+    if (!fields.length) {
+      fields = await this.getFields(options);
+    }
+    if (options.skipField) {
+      fields = fields.filter((field) => !options.skipField.includes(field.name));
+    }
+    if (options.includeFields) {
+      fields = fields.filter((field) => options.includeFields.includes(field.name));
+    }
+    if (this.options.view && fields.find((f) => f.name == "id")) {
+      fields = fields.map((field) => {
+        if (field.name == "id") {
+          field.set("primaryKey", true);
+        } else {
+          field.set("primaryKey", false);
+        }
+        return field;
+      });
+    }
+    const instances = fields;
+    instances.sort((a, b) => {
+      if (a.isAssociationField() && !b.isAssociationField()) {
+        return 1;
+      }
+      if (!a.isAssociationField() && b.isAssociationField()) {
+        return -1;
+      }
+      return 0;
+    });
+    for (const instance of instances) {
+      await instance.load(options);
+    }
+  }
+  async remove(options) {
+    const { transaction } = options || {};
+    const name = this.get("name");
+    const collection = this.db.getCollection(name);
+    if (!collection) {
+      return;
+    }
+    const fields = await this.db.getRepository("fields").find({
+      filter: {
+        "type.$in": ["belongsToMany", "belongsTo", "hasMany", "hasOne"]
+      },
+      transaction
+    });
+    for (const field of fields) {
+      if (field.get("target") && field.get("target") === name) {
+        await field.destroy({ transaction });
+      } else if (field.get("through") && field.get("through") === name) {
+        await field.destroy({ transaction });
+      }
+    }
+    await collection.removeFromDb(options);
+  }
+  async migrate(options) {
+    const pendingFieldsTargetToThis = this.db.pendingFields.get(this.get("name")) || [];
+    const getPendingField = () => pendingFieldsTargetToThis.map((field) => {
+      return {
+        name: field.get("name"),
+        collectionName: field.get("collectionName")
+      };
+    });
+    const beforePendingFields = getPendingField();
+    const collection = await this.load({
+      transaction: options == null ? void 0 : options.transaction
+    });
+    const afterPendingFields = getPendingField();
+    const resolvedPendingFields = import_lodash.default.differenceWith(beforePendingFields, afterPendingFields, import_lodash.default.isEqual);
+    const resolvedPendingFieldsCollections = import_lodash.default.uniq(resolvedPendingFields.map((field) => field.collectionName));
+    if (Object.keys(collection.model.tableAttributes).length == 0 && !this.db.inDialect("postgres")) {
+      return;
+    }
+    try {
+      const syncOptions = {
+        force: false,
+        alter: {
+          drop: false
+        },
+        ...options
+      };
+      await collection.sync(syncOptions);
+      for (const collectionName of resolvedPendingFieldsCollections) {
+        await this.db.getCollection(collectionName).sync(syncOptions);
+      }
+    } catch (error) {
+      console.error(error);
+      const name = this.get("name");
+      this.db.removeCollection(name);
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionModel
+});