@tachybase/module-collection 0.23.8

package/dist/server/migrations/20221101111110-update-foreign-fields.js

@@ -0,0 +1,64 @@
+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 update_foreign_fields_exports = {};
+__export(update_foreign_fields_exports, {
+  default: () => DropForeignKeysMigration
+});
+module.exports = __toCommonJS(update_foreign_fields_exports);
+var import_server = require("@tachybase/server");
+var import_afterCreateForForeignKeyField = require("../hooks/afterCreateForForeignKeyField");
+class DropForeignKeysMigration extends import_server.Migration {
+  appVersion = "<0.8.0-alpha.9";
+  async up() {
+    const result = await this.app.version.satisfies("<0.8.0");
+    if (!result) {
+      return;
+    }
+    const transaction = await this.app.db.sequelize.transaction();
+    const callback = (0, import_afterCreateForForeignKeyField.afterCreateForForeignKeyField)(this.app.db);
+    try {
+      const fields = await this.app.db.getCollection("fields").repository.find({
+        filter: {
+          interface: {
+            $in: ["oho", "o2m", "obo", "m2o", "linkTo", "m2m"]
+          },
+          collectionName: {
+            $not: null
+          }
+        }
+      });
+      for (const field of fields) {
+        try {
+          await callback(field, {
+            transaction,
+            context: {}
+          });
+        } catch (error) {
+          if (error.message.includes("collection not found")) {
+            continue;
+          }
+          throw error;
+        }
+      }
+      await transaction.commit();
+    } catch (error) {
+      console.log(error);
+      await transaction.rollback();
+    }
+  }
+}

package/dist/server/migrations/20221104151410-update-collections-hidden.d.ts

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

package/dist/server/migrations/20221104151410-update-collections-hidden.js

@@ -0,0 +1,47 @@
+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 update_collections_hidden_exports = {};
+__export(update_collections_hidden_exports, {
+  default: () => UpdateCollectionsHiddenMigration
+});
+module.exports = __toCommonJS(update_collections_hidden_exports);
+var import_server = require("@tachybase/server");
+class UpdateCollectionsHiddenMigration extends import_server.Migration {
+  appVersion = "<0.8.0-alpha.11";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.8.0-alpha.9");
+    if (!result) {
+      return;
+    }
+    try {
+      await this.app.db.getRepository("collections").update({
+        filter: {
+          options: {
+            autoCreate: true,
+            isThrough: true
+          }
+        },
+        values: {
+          hidden: true
+        }
+      });
+    } catch (error) {
+      console.error(error);
+    }
+  }
+}

package/dist/server/migrations/20221121111110-update-fk-type.d.ts

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

package/dist/server/migrations/20221121111110-update-fk-type.js

@@ -0,0 +1,144 @@
+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 update_fk_type_exports = {};
+__export(update_fk_type_exports, {
+  default: () => UpdateIdToBigIntMigrator
+});
+module.exports = __toCommonJS(update_fk_type_exports);
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+class UpdateIdToBigIntMigrator extends import_server.Migration {
+  appVersion = "<0.8.1-alpha.2";
+  async up() {
+    const result = await this.app.version.satisfies("<0.9.0-alpha.1");
+    if (!result) {
+      return;
+    }
+    const db = this.app.db;
+    await db.getCollection("fields").repository.update({
+      filter: {
+        name: "id",
+        type: "integer"
+      },
+      values: {
+        type: "bigInt"
+      }
+    });
+    if (!db.inDialect("mysql", "mariadb", "postgres")) {
+      return;
+    }
+    const models = [];
+    const queryInterface = db.sequelize.getQueryInterface();
+    const queryGenerator = queryInterface.queryGenerator;
+    const updateToBigInt = async (model, fieldName) => {
+      let sql;
+      const tableName = model.tableName;
+      if (model.rawAttributes[fieldName].type instanceof import_database.DataTypes.INTEGER) {
+        if (db.inDialect("postgres")) {
+          sql = `ALTER TABLE "${tableName}" ALTER COLUMN "${fieldName}" SET DATA TYPE BIGINT;`;
+        } else if (db.inDialect("mysql", "mariadb")) {
+          const dataTypeOrOptions = model.rawAttributes[fieldName];
+          const attributeName = fieldName;
+          const query = queryGenerator.attributesToSQL(
+            {
+              [attributeName]: queryInterface.normalizeAttribute({
+                ...dataTypeOrOptions,
+                type: import_database.DataTypes.BIGINT
+              })
+            },
+            {
+              context: "changeColumn",
+              table: tableName
+            }
+          );
+          sql = queryGenerator.changeColumnQuery(tableName, query);
+          sql = sql.replace(" PRIMARY KEY;", " ;");
+        }
+        try {
+          await this.sequelize.query(sql, {});
+        } catch (err) {
+          if (err.message.includes("does not exist")) {
+            return;
+          }
+          throw err;
+        }
+        this.app.logger.info(`updated ${tableName}.${fieldName} to BIGINT`, { tableName, fieldName });
+      }
+    };
+    this.app.db.sequelize.modelManager.forEachModel((model) => {
+      models.push(model);
+    });
+    for (const model of models) {
+      try {
+        const primaryKeyField = model.tableAttributes[model.primaryKeyField];
+        const collection = db.modelCollection.get(model);
+        if (!collection) {
+          continue;
+        }
+        if (primaryKeyField && primaryKeyField.primaryKey) {
+          await updateToBigInt(model, model.primaryKeyField);
+        }
+        if (model.tableAttributes["sort"] && model.tableAttributes["sort"].type instanceof import_database.DataTypes.INTEGER) {
+          await updateToBigInt(model, "sort");
+        }
+        const associations = model.associations;
+        for (const associationName of Object.keys(associations)) {
+          const association = associations[associationName];
+          const type = association.associationType;
+          let foreignModel;
+          let fieldName;
+          if (type === "BelongsTo") {
+            foreignModel = association.source;
+            fieldName = association.foreignKey;
+          }
+          if (type === "HasMany") {
+            foreignModel = association.target;
+            fieldName = association.foreignKey;
+          }
+          if (type === "HasOne") {
+            foreignModel = association.target;
+            fieldName = association.foreignKey;
+          }
+          if (foreignModel && fieldName) {
+            const cf = await db.getRepository("collections.fields", foreignModel.name).findOne({
+              filterByTk: fieldName
+            });
+            if (cf) {
+              cf.interface = "integer";
+              cf.type = "bigInt";
+              await cf.save();
+            }
+            await updateToBigInt(foreignModel, fieldName);
+          }
+          if (type === "BelongsToMany") {
+            const throughModel = association.through.model;
+            const otherKey = association.otherKey;
+            const foreignKey = association.foreignKey;
+            await updateToBigInt(throughModel, otherKey);
+            await updateToBigInt(throughModel, foreignKey);
+          }
+        }
+      } catch (error) {
+        if (error.message.includes("cannot alter inherited column")) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+}

package/dist/server/migrations/20221121111113-update-id-to-bigint.d.ts

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

package/dist/server/migrations/20221121111113-update-id-to-bigint.js

@@ -0,0 +1,178 @@
+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 update_id_to_bigint_exports = {};
+__export(update_id_to_bigint_exports, {
+  default: () => UpdateIdToBigIntMigrator
+});
+module.exports = __toCommonJS(update_id_to_bigint_exports);
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+class UpdateIdToBigIntMigrator extends import_server.Migration {
+  appVersion = "<0.8.1-alpha.2";
+  async up() {
+    const result = await this.app.version.satisfies("<0.9.0-alpha.1");
+    if (!result) {
+      return;
+    }
+    const db = this.app.db;
+    await db.getCollection("fields").repository.update({
+      filter: {
+        $or: [
+          {
+            name: "id",
+            type: "integer"
+          }
+        ]
+      },
+      values: {
+        type: "bigInt"
+      }
+    });
+    if (!db.inDialect("mysql", "mariadb", "postgres")) {
+      return;
+    }
+    const models = [];
+    const queryInterface = db.sequelize.getQueryInterface();
+    const queryGenerator = queryInterface.queryGenerator;
+    const updateToBigInt = async (model, fieldName) => {
+      const columnName = model.rawAttributes[fieldName].field;
+      let sql;
+      const tableName = model.tableName;
+      const addSchemaTableName = db.utils.addSchema(tableName);
+      const quoteTableName = db.utils.quoteTable(addSchemaTableName);
+      const collection = db.modelCollection.get(model);
+      const fieldRecord = await db.getCollection("fields").repository.findOne({
+        filter: {
+          collectionName: collection.name,
+          name: fieldName,
+          type: "integer"
+        }
+      });
+      if (fieldRecord) {
+        fieldRecord.set("type", "bigInt");
+        await fieldRecord.save();
+      }
+      if (model.rawAttributes[fieldName].type instanceof import_database.DataTypes.INTEGER) {
+        if (db.inDialect("postgres")) {
+          sql = `ALTER TABLE ${quoteTableName} ALTER COLUMN "${columnName}" SET DATA TYPE BIGINT;`;
+        } else if (db.inDialect("mysql", "mariadb")) {
+          const dataTypeOrOptions = model.rawAttributes[fieldName];
+          const attributeName = fieldName;
+          const query = queryGenerator.attributesToSQL(
+            {
+              [attributeName]: queryInterface.normalizeAttribute({
+                ...dataTypeOrOptions,
+                type: import_database.DataTypes.BIGINT
+              })
+            },
+            {
+              context: "changeColumn",
+              table: tableName
+            }
+          );
+          sql = queryGenerator.changeColumnQuery(addSchemaTableName, query);
+          sql = sql.replace(" PRIMARY KEY;", " ;");
+        }
+        try {
+          await this.sequelize.query(sql, {});
+        } catch (err) {
+          if (err.message.includes("does not exist") || err.message.includes("cannot alter inherited column")) {
+            return;
+          }
+          throw err;
+        }
+        if (db.inDialect("postgres")) {
+          const sequenceQuery = `SELECT pg_get_serial_sequence('${quoteTableName}', '${columnName}');`;
+          const [result2] = await this.sequelize.query(sequenceQuery, {});
+          const sequenceName = result2[0]["pg_get_serial_sequence"];
+          if (sequenceName) {
+            await this.sequelize.query(`ALTER SEQUENCE ${sequenceName} AS BIGINT;`, {});
+          }
+        }
+        this.app.logger.info(`updated ${tableName}.${fieldName} to BIGINT`, { tableName, fieldName });
+      }
+    };
+    const singleForeignFields = await db.getCollection("fields").repository.find({
+      filter: {
+        options: {
+          isForeignKey: true
+        },
+        type: "integer"
+      }
+    });
+    for (const field of singleForeignFields) {
+      const collection = db.getCollection(field.get("collectionName"));
+      if (!collection) {
+        console.log("collection not found", field.get("collectionName"));
+      }
+      await updateToBigInt(collection.model, field.get("name"));
+    }
+    this.app.db.sequelize.modelManager.forEachModel((model) => {
+      models.push(model);
+    });
+    for (const model of models) {
+      try {
+        const primaryKeyField = model.tableAttributes[model.primaryKeyField];
+        const collection = db.modelCollection.get(model);
+        if (!collection) {
+          continue;
+        }
+        if (primaryKeyField && primaryKeyField.primaryKey) {
+          await updateToBigInt(model, model.primaryKeyField);
+        }
+        if (model.tableAttributes["sort"] && model.tableAttributes["sort"].type instanceof import_database.DataTypes.INTEGER) {
+          await updateToBigInt(model, "sort");
+        }
+        const associations = model.associations;
+        for (const associationName of Object.keys(associations)) {
+          const association = associations[associationName];
+          const type = association.associationType;
+          let foreignModel;
+          let fieldName;
+          if (type === "BelongsTo") {
+            foreignModel = association.source;
+            fieldName = association.foreignKey;
+          }
+          if (type === "HasMany") {
+            foreignModel = association.target;
+            fieldName = association.foreignKey;
+          }
+          if (type === "HasOne") {
+            foreignModel = association.target;
+            fieldName = association.foreignKey;
+          }
+          if (foreignModel && fieldName) {
+            await updateToBigInt(foreignModel, fieldName);
+          }
+          if (type === "BelongsToMany") {
+            const throughModel = association.through.model;
+            const otherKey = association.otherKey;
+            const foreignKey = association.foreignKey;
+            await updateToBigInt(throughModel, otherKey);
+            await updateToBigInt(throughModel, foreignKey);
+          }
+        }
+      } catch (error) {
+        if (error.message.includes("cannot alter inherited column")) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+}

package/dist/server/migrations/20221221103220-timestamps.d.ts

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

package/dist/server/migrations/20221221103220-timestamps.js

@@ -0,0 +1,45 @@
+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 timestamps_exports = {};
+__export(timestamps_exports, {
+  default: () => timestamps_default
+});
+module.exports = __toCommonJS(timestamps_exports);
+var import_server = require("@tachybase/server");
+class timestamps_default extends import_server.Migration {
+  appVersion = "<0.8.1-alpha.2";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.8.0-alpha.14");
+    if (!result) {
+      return;
+    }
+    try {
+      const collections = await this.app.db.getRepository("collections").find();
+      console.log("migrating...");
+      for (const collection of collections) {
+        if (collection.get("autoCreate") && collection.get("isThrough")) {
+          collection.set("timestamps", true);
+          await collection.save();
+          console.log(`collection name: ${collection.name}`);
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+}

package/dist/server/migrations/20230225111112-drop-ui-schema-relation.d.ts

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

package/dist/server/migrations/20230225111112-drop-ui-schema-relation.js

@@ -0,0 +1,87 @@
+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 drop_ui_schema_relation_exports = {};
+__export(drop_ui_schema_relation_exports, {
+  default: () => drop_ui_schema_relation_default
+});
+module.exports = __toCommonJS(drop_ui_schema_relation_exports);
+var import_server = require("@tachybase/server");
+class drop_ui_schema_relation_default extends import_server.Migration {
+  appVersion = "<0.9.2-alpha.1";
+  async up() {
+    const result = await this.app.version.satisfies("<0.9.2-alpha.2");
+    if (!result) {
+      return;
+    }
+    const transaction = await this.db.sequelize.transaction();
+    const migrateFieldsSchema = async (collection) => {
+      this.app.logger.info(`Start to migrate ${collection.name} collection's ui schema`);
+      const field = collection.setField("uiSchemaUid", {
+        type: "string"
+      });
+      const exists = await field.existsInDb({ transaction });
+      if (!exists) {
+        collection.removeField("uiSchemaUid");
+        return;
+      }
+      const fieldRecords = await collection.repository.find({
+        transaction
+      });
+      const fieldsCount = await collection.repository.count({
+        transaction
+      });
+      this.app.logger.info(`Total ${fieldsCount} fields need to be migrated`);
+      let i = 0;
+      for (const fieldRecord of fieldRecords) {
+        i++;
+        this.app.logger.info(
+          `Migrate field ${fieldRecord.get("collectionName")}.${fieldRecord.get("name")}, ${i}/${fieldsCount}`
+        );
+        const uiSchemaUid = fieldRecord.get("uiSchemaUid");
+        if (!uiSchemaUid) {
+          continue;
+        }
+        const uiSchemaRecord = await this.db.getRepository("uiSchemas").findOne({
+          filterByTk: uiSchemaUid,
+          transaction
+        });
+        if (!uiSchemaRecord) {
+          continue;
+        }
+        const uiSchema = uiSchemaRecord.get("schema");
+        fieldRecord.set("uiSchema", uiSchema);
+        await fieldRecord.save({
+          transaction
+        });
+      }
+      collection.removeField("uiSchemaUid");
+      this.app.logger.info("Migrate uiSchema to options field done");
+    };
+    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.logger.error(error);
+      throw error;
+    }
+  }
+}

package/dist/server/migrations/20230509111114-alert-ui-schema.d.ts

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

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

@@ -0,0 +1,77 @@
+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("@tachybase/server");
+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.logger.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.logger.info(`Total ${fieldsCount} fields need to be migrated`);
+      let i = 0;
+      for (const fieldRecord of fieldRecords) {
+        i++;
+        this.app.logger.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.logger.error(error);
+      throw error;
+    }
+  }
+}