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

package/dist/server/hooks/beforeCreateForChildrenCollection.js

@@ -0,0 +1,58 @@
+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 beforeCreateForChildrenCollection_exports = {};
+__export(beforeCreateForChildrenCollection_exports, {
+  beforeCreateForChildrenCollection: () => beforeCreateForChildrenCollection
+});
+module.exports = __toCommonJS(beforeCreateForChildrenCollection_exports);
+function beforeCreateForChildrenCollection(db) {
+  return async (model, { transaction, context }) => {
+    const Collection = db.getCollection("collections");
+    const Field = db.getCollection("fields");
+    const parentKey = model.get("parentKey");
+    if (!parentKey) {
+      return;
+    }
+    const parent = await Field.model.findByPk(parentKey, { transaction });
+    const parentTarget = parent.get("target");
+    model.set("collectionName", parentTarget);
+    const collection = await Collection.model.findOne({
+      transaction,
+      where: {
+        name: parentTarget
+      }
+    });
+    if (!collection) {
+      await Collection.repository.create({
+        values: {
+          name: parentTarget,
+          createdBy: true,
+          updatedBy: true,
+          sortable: true,
+          inherit: true
+        },
+        transaction,
+        context
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForChildrenCollection
+});

package/dist/server/hooks/beforeCreateForReverseField.d.ts

@@ -0,0 +1,4 @@
+import Database from '@nocobase/database';
+export declare function beforeCreateForReverseField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;

package/dist/server/hooks/beforeCreateForReverseField.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 beforeCreateForReverseField_exports = {};
+__export(beforeCreateForReverseField_exports, {
+  beforeCreateForReverseField: () => beforeCreateForReverseField
+});
+module.exports = __toCommonJS(beforeCreateForReverseField_exports);
+function beforeCreateForReverseField(db) {
+  return async (model, { transaction }) => {
+    const Field = db.getCollection("fields");
+    const reverseKey = model.get("reverseKey");
+    if (!reverseKey) {
+      return;
+    }
+    const reverse = await Field.model.findByPk(reverseKey, { transaction });
+    model.set("collectionName", reverse.get("target"));
+    model.set("target", reverse.get("collectionName"));
+    if (reverse.get("onDelete")) {
+      model.set("onDelete", reverse.get("onDelete"));
+    }
+    const reverseType = reverse.get("type");
+    if (["hasMany", "hasOne"].includes(reverseType)) {
+      model.set("type", "belongsTo");
+      model.set("targetKey", reverse.get("sourceKey"));
+      model.set("foreignKey", reverse.get("foreignKey"));
+      model.set("sourceKey", reverse.get("targetKey"));
+    }
+    if (["belongsTo"].includes(reverseType)) {
+      if (!model.get("type")) {
+        model.set("type", "hasMany");
+      }
+      model.set("sourceKey", reverse.get("targetKey"));
+      model.set("foreignKey", reverse.get("foreignKey"));
+      model.set("targetKey", reverse.get("sourceKey"));
+    }
+    if (["belongsToMany"].includes(reverseType)) {
+      model.set("type", "belongsToMany");
+      model.set("through", reverse.get("through"));
+      model.set("sourceKey", reverse.get("targetKey"));
+      model.set("foreignKey", reverse.get("otherKey"));
+      model.set("targetKey", reverse.get("sourceKey"));
+      model.set("otherKey", reverse.get("foreignKey"));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForReverseField
+});

package/dist/server/hooks/beforeCreateForValidateField.d.ts

@@ -0,0 +1,7 @@
+import { Database } from '@nocobase/database';
+export declare function beforeCreateForValidateField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;
+export declare function beforeUpdateForValidateField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;

package/dist/server/hooks/beforeCreateForValidateField.js

@@ -0,0 +1,67 @@
+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 beforeCreateForValidateField_exports = {};
+__export(beforeCreateForValidateField_exports, {
+  beforeCreateForValidateField: () => beforeCreateForValidateField,
+  beforeUpdateForValidateField: () => beforeUpdateForValidateField
+});
+module.exports = __toCommonJS(beforeCreateForValidateField_exports);
+function beforeCreateForValidateField(db) {
+  return async (model, { transaction }) => {
+    if (model.type === "belongsToMany") {
+      if (model.get("foreignKey") === model.get("otherKey")) {
+        throw new Error("foreignKey and otherKey can not be the same");
+      }
+    }
+    const isPrimaryKey = model.get("primaryKey");
+    if (isPrimaryKey) {
+      const collection = db.getCollection(model.get("collectionName"));
+      if (!collection) {
+        return;
+      }
+      const primaryKey = collection.model.primaryKeyAttribute;
+      if (primaryKey !== model.get("name") && collection.model.rawAttributes[primaryKey]) {
+        throw new Error(
+          `add field ${model.get("name")} failed, collection ${collection.name} already has primary key ${primaryKey}`
+        );
+      }
+    }
+  };
+}
+function beforeUpdateForValidateField(db) {
+  return async (model, { transaction }) => {
+    const isPrimaryKey = model.get("primaryKey");
+    if (isPrimaryKey) {
+      const collection = db.getCollection(model.get("collectionName"));
+      if (!collection) {
+        return;
+      }
+      const primaryKey = collection.model.primaryKeyAttribute;
+      if (primaryKey !== model.get("name") && collection.model.rawAttributes[primaryKey]) {
+        throw new Error(
+          `update field ${model.get("name")} failed, collection ${collection.name} already has primary key ${primaryKey}`
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForValidateField,
+  beforeUpdateForValidateField
+});

package/dist/server/hooks/beforeCreateForViewCollection.d.ts

@@ -0,0 +1,5 @@
+import { Database } from '@nocobase/database';
+export declare function beforeCreateForViewCollection(db: Database): (model: any, { transaction, context }: {
+    transaction: any;
+    context: any;
+}) => Promise<void>;

package/dist/server/hooks/beforeCreateForViewCollection.js

@@ -0,0 +1,30 @@
+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 beforeCreateForViewCollection_exports = {};
+__export(beforeCreateForViewCollection_exports, {
+  beforeCreateForViewCollection: () => beforeCreateForViewCollection
+});
+module.exports = __toCommonJS(beforeCreateForViewCollection_exports);
+function beforeCreateForViewCollection(db) {
+  return async (model, { transaction, context }) => {
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForViewCollection
+});

package/dist/server/hooks/beforeDestroyForeignKey.d.ts

@@ -0,0 +1,2 @@
+import Database from '@nocobase/database';
+export declare function beforeDestroyForeignKey(db: Database): (model: any, opts: any) => Promise<void>;

package/dist/server/hooks/beforeDestroyForeignKey.js

@@ -0,0 +1,66 @@
+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 beforeDestroyForeignKey_exports = {};
+__export(beforeDestroyForeignKey_exports, {
+  beforeDestroyForeignKey: () => beforeDestroyForeignKey
+});
+module.exports = __toCommonJS(beforeDestroyForeignKey_exports);
+function beforeDestroyForeignKey(db) {
+  return async (model, opts) => {
+    var _a;
+    const { transaction } = opts;
+    const { isForeignKey, collectionName: fkCollectionName, name: fkName } = model.get();
+    if (!isForeignKey) {
+      return;
+    }
+    const fieldKeys = [];
+    for (const [sourceName, collection] of db.collections) {
+      for (const [, field] of collection.fields) {
+        const fieldKey = (_a = field.options) == null ? void 0 : _a.key;
+        if (!fieldKey) {
+          continue;
+        }
+        if (field.type === "belongsTo") {
+          if (sourceName === fkCollectionName && field.foreignKey === fkName) {
+            fieldKeys.push(fieldKey);
+          }
+        } else if (field.type === "hasOne" || field.type === "hasMany") {
+          if (fkCollectionName === field.target && field.foreignKey === fkName) {
+            fieldKeys.push(fieldKey);
+          }
+        } else if (field.type === "belongsToMany" && field.through === fkCollectionName) {
+          console.log(field.foreignKey, field.otherKey);
+          if (field.foreignKey === fkName || field.otherKey === fkName) {
+            fieldKeys.push(fieldKey);
+          }
+        }
+      }
+    }
+    const r = db.getRepository("fields");
+    await r.destroy({
+      filter: {
+        "key.$in": fieldKeys
+      },
+      transaction
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeDestroyForeignKey
+});

package/dist/server/hooks/beforeInitOptions.d.ts

@@ -0,0 +1,15 @@
+import { Model } from '@nocobase/database';
+export declare const beforeInitOptions: {
+    belongsTo(model: Model, { database }: {
+        database: any;
+    }): void;
+    belongsToMany(model: Model, { database }: {
+        database: any;
+    }): void;
+    hasMany(model: Model, { database }: {
+        database: any;
+    }): void;
+    hasOne(model: Model, { database }: {
+        database: any;
+    }): void;
+};

package/dist/server/hooks/beforeInitOptions.js

@@ -0,0 +1,128 @@
+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 beforeInitOptions_exports = {};
+__export(beforeInitOptions_exports, {
+  beforeInitOptions: () => beforeInitOptions
+});
+module.exports = __toCommonJS(beforeInitOptions_exports);
+var import_utils = require("@nocobase/utils");
+var import_sequelize = require("sequelize");
+const setTargetKey = (db, model) => {
+  if (model.get("targetKey")) {
+    return;
+  }
+  const target = model.get("target");
+  if (db.hasCollection(target)) {
+    const targetModel = db.getCollection(target).model;
+    model.set("targetKey", targetModel.primaryKeyAttribute || "id");
+  } else {
+    model.set("targetKey", "id");
+  }
+};
+const setSourceKey = (db, model) => {
+  if (model.get("sourceKey")) {
+    return;
+  }
+  const source = model.get("collectionName");
+  if (db.hasCollection(source)) {
+    const sourceModel = db.getCollection(source).model;
+    model.set("sourceKey", sourceModel.primaryKeyAttribute || "id");
+  } else {
+    model.set("sourceKey", "id");
+  }
+};
+const beforeInitOptions = {
+  belongsTo(model, { database }) {
+    if (!model.get("target")) {
+      model.set("target", import_sequelize.Utils.pluralize(model.get("name")));
+    }
+    const defaults = {
+      // targetKey: 'id',
+      foreignKey: `f_${(0, import_utils.uid)()}`
+    };
+    for (const key in defaults) {
+      if (model.get(key)) {
+        continue;
+      }
+      model.set(key, defaults[key]);
+    }
+    setTargetKey(database, model);
+  },
+  belongsToMany(model, { database }) {
+    if (!model.get("target")) {
+      model.set("target", model.get("name"));
+    }
+    const defaults = {
+      // targetKey: 'id',
+      // sourceKey: 'id',
+      through: `t_${(0, import_utils.uid)()}`,
+      foreignKey: `f_${(0, import_utils.uid)()}`,
+      otherKey: `f_${(0, import_utils.uid)()}`
+    };
+    for (const key in defaults) {
+      if (model.get(key)) {
+        continue;
+      }
+      model.set(key, defaults[key]);
+    }
+    setTargetKey(database, model);
+    setSourceKey(database, model);
+  },
+  hasMany(model, { database }) {
+    if (!model.get("target")) {
+      model.set("target", model.get("name"));
+    }
+    const defaults = {
+      // targetKey: 'id',
+      // sourceKey: 'id',
+      foreignKey: `f_${(0, import_utils.uid)()}`,
+      target: `t_${(0, import_utils.uid)()}`
+    };
+    for (const key in defaults) {
+      if (model.get(key)) {
+        continue;
+      }
+      model.set(key, defaults[key]);
+    }
+    setTargetKey(database, model);
+    setSourceKey(database, model);
+    if (model.get("sortable") && model.get("type") === "hasMany") {
+      model.set("sortBy", model.get("foreignKey") + "Sort");
+    }
+  },
+  hasOne(model, { database }) {
+    if (!model.get("target")) {
+      model.set("target", import_sequelize.Utils.pluralize(model.get("name")));
+    }
+    const defaults = {
+      // sourceKey: 'id',
+      foreignKey: `f_${(0, import_utils.uid)()}`
+    };
+    for (const key in defaults) {
+      if (model.get(key)) {
+        continue;
+      }
+      model.set(key, defaults[key]);
+    }
+    setSourceKey(database, model);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeInitOptions
+});

package/dist/server/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './afterCreateForForeignKeyField';
+export * from './afterCreateForReverseField';
+export * from './beforeCreateForReverseField';
+export * from './beforeDestroyForeignKey';
+export * from './beforeInitOptions';

package/dist/server/hooks/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);
+__reExport(hooks_exports, require("./afterCreateForForeignKeyField"), module.exports);
+__reExport(hooks_exports, require("./afterCreateForReverseField"), module.exports);
+__reExport(hooks_exports, require("./beforeCreateForReverseField"), module.exports);
+__reExport(hooks_exports, require("./beforeDestroyForeignKey"), module.exports);
+__reExport(hooks_exports, require("./beforeInitOptions"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./afterCreateForForeignKeyField"),
+  ...require("./afterCreateForReverseField"),
+  ...require("./beforeCreateForReverseField"),
+  ...require("./beforeDestroyForeignKey"),
+  ...require("./beforeInitOptions")
+});

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+export * from './repositories';
+export { default as fieldsCollection } from './collections/fields';
+export { default as collectionsCollection } from './collections/collections';
+export { default } from './server';

package/dist/server/index.js

@@ -0,0 +1,45 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 server_exports = {};
+__export(server_exports, {
+  collectionsCollection: () => import_collections.default,
+  default: () => import_server.default,
+  fieldsCollection: () => import_fields.default
+});
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./repositories"), module.exports);
+var import_fields = __toESM(require("./collections/fields"));
+var import_collections = __toESM(require("./collections/collections"));
+var import_server = __toESM(require("./server"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectionsCollection,
+  fieldsCollection,
+  ...require("./repositories")
+});

package/dist/server/migrations/20220613103214-alert-sub-table.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/20220613103214-alert-sub-table.js

@@ -0,0 +1,41 @@
+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_sub_table_exports = {};
+__export(alert_sub_table_exports, {
+  default: () => alert_sub_table_default
+});
+module.exports = __toCommonJS(alert_sub_table_exports);
+var import_server = require("@nocobase/server");
+/* istanbul ignore file -- @preserve */
+class alert_sub_table_default extends import_server.Migration {
+  appVersion = "<=0.7.0-alpha.83";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.7.0-alpha.83");
+    if (!result) {
+      return;
+    }
+    const Field = this.context.db.getRepository("fields");
+    const fields = await Field.find();
+    for (const field of fields) {
+      if (field.get("interface") === "subTable") {
+        field.set("interface", "o2m");
+        await field.save();
+      }
+    }
+  }
+}

package/dist/server/migrations/20220704225714-drop-foreign-keys.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/20220704225714-drop-foreign-keys.js

@@ -0,0 +1,70 @@
+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_foreign_keys_exports = {};
+__export(drop_foreign_keys_exports, {
+  default: () => drop_foreign_keys_default
+});
+module.exports = __toCommonJS(drop_foreign_keys_exports);
+var import_server = require("@nocobase/server");
+/* istanbul ignore file -- @preserve */
+class drop_foreign_keys_default extends import_server.Migration {
+  appVersion = "<=0.7.1-alpha.7";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.7.1-alpha.7");
+    if (!result) {
+      return;
+    }
+    const transaction = await this.db.sequelize.transaction();
+    try {
+      if (this.db.isMySQLCompatibleDialect()) {
+        const [results] = await this.db.sequelize.query(
+          `
+            SELECT CONCAT('ALTER TABLE ', TABLE_SCHEMA, '.', TABLE_NAME, ' DROP FOREIGN KEY ', CONSTRAINT_NAME,
+                          ' ;') as q
+            FROM information_schema.TABLE_CONSTRAINTS c
+            WHERE c.TABLE_SCHEMA = '${this.db.options.database}'
+              AND c.CONSTRAINT_TYPE = 'FOREIGN KEY';
+          `,
+          { transaction }
+        );
+        for (const result2 of results) {
+          await this.db.sequelize.query(result2.q, { transaction });
+        }
+      } else if (this.db.inDialect("postgres")) {
+        const [results] = await this.db.sequelize.query(
+          `
+            select 'alter table ' || quote_ident(tb.relname) ||
+                   ' drop constraint ' || quote_ident(conname) || ';' as q
+            from pg_constraint c
+                   join pg_class tb on tb.oid = c.conrelid
+                   join pg_namespace ns on ns.oid = tb.relnamespace
+            where ns.nspname in ('public')
+              and c.contype = 'f';
+          `,
+          { transaction }
+        );
+        for (const result2 of results) {
+          await this.db.sequelize.query(result2.q, { transaction });
+        }
+      }
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+    }
+  }
+}