@tachybase/module-collection 0.23.8

package/dist/server/hooks/beforeCreateForValidateField.js

@@ -0,0 +1,48 @@
+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
+});
+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}`
+        );
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForValidateField
+});

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

@@ -0,0 +1,5 @@
+import { Database } from '@tachybase/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 '@tachybase/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,29 @@
+import { Model } from '@tachybase/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;
+};
+export declare const beforeCheckOptions: {
+    belongsTo(model: Model, { database }: {
+        database: any;
+    }): void;
+    hasMany(model: Model, { database }: {
+        database: any;
+    }): void;
+    hasOne(model: Model, { database }: {
+        database: any;
+    }): void;
+    belongsToMany(model: Model, { database }: {
+        database: any;
+    }): void;
+};

package/dist/server/hooks/beforeInitOptions.js

@@ -0,0 +1,233 @@
+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, {
+  beforeCheckOptions: () => beforeCheckOptions,
+  beforeInitOptions: () => beforeInitOptions
+});
+module.exports = __toCommonJS(beforeInitOptions_exports);
+var import_utils = require("@tachybase/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);
+  }
+};
+function getAttributeType(attribute) {
+  return attribute == null ? void 0 : attribute.type.constructor.toString();
+}
+const beforeCheckOptions = {
+  belongsTo(model, { database }) {
+    var _a, _b;
+    const target = model.get("target");
+    const targetModel = (_a = database.getCollection(target)) == null ? void 0 : _a.model;
+    const sourceModel = (_b = database.getCollection(model.get("collectionName"))) == null ? void 0 : _b.model;
+    if (!sourceModel || !targetModel) {
+      return;
+    }
+    const foreignKey = sourceModel.rawAttributes[model.get("foreignKey")];
+    const targetKey = targetModel.rawAttributes[model.get("targetKey")];
+    const foreignKeyType = getAttributeType(foreignKey);
+    const targetKeyType = getAttributeType(targetKey);
+    if (foreignKeyType && foreignKeyType !== targetKeyType) {
+      throw new Error(
+        `Foreign key "${model.get("foreignKey")}" type "${foreignKeyType}" does not match target key "${model.get(
+          "targetKey"
+        )}" type "${targetKeyType}"`
+      );
+    }
+  },
+  hasMany(model, { database }) {
+    var _a, _b;
+    const target = model.get("target");
+    const source = model.get("collectionName");
+    const targetModel = (_a = database.getCollection(target)) == null ? void 0 : _a.model;
+    const sourceModel = (_b = database.getCollection(source)) == null ? void 0 : _b.model;
+    if (!sourceModel || !targetModel) {
+      return;
+    }
+    const foreignKey = targetModel.rawAttributes[model.get("foreignKey")];
+    const sourceKey = sourceModel.rawAttributes[model.get("sourceKey")];
+    const foreignKeyType = getAttributeType(foreignKey);
+    const sourceKeyType = getAttributeType(sourceKey);
+    if (foreignKeyType && foreignKeyType !== sourceKeyType) {
+      throw new Error(
+        `Foreign key "${model.get("foreignKey")}" type "${foreignKeyType}" does not match source key "${model.get(
+          "sourceKey"
+        )}" type "${sourceKeyType}"`
+      );
+    }
+  },
+  hasOne(model, { database }) {
+    var _a, _b;
+    const target = model.get("target");
+    const source = model.get("collectionName");
+    const targetModel = (_a = database.getCollection(target)) == null ? void 0 : _a.model;
+    const sourceModel = (_b = database.getCollection(source)) == null ? void 0 : _b.model;
+    if (!sourceModel || !targetModel) {
+      return;
+    }
+    const foreignKey = targetModel.rawAttributes[model.get("foreignKey")];
+    const sourceKey = sourceModel.rawAttributes[model.get("sourceKey")];
+    const foreignKeyType = getAttributeType(foreignKey);
+    const sourceKeyType = getAttributeType(sourceKey);
+    if (foreignKeyType && foreignKeyType !== sourceKeyType) {
+      throw new Error(
+        `Foreign key "${model.get("foreignKey")}" type "${foreignKeyType}" does not match source key "${model.get(
+          "sourceKey"
+        )}" type "${sourceKeyType}"`
+      );
+    }
+  },
+  belongsToMany(model, { database }) {
+    var _a, _b;
+    const target = model.get("target");
+    const through = model.get("through");
+    const throughCollection = database.getCollection(through);
+    if (!throughCollection) {
+      return;
+    }
+    const targetModel = (_a = database.getCollection(target)) == null ? void 0 : _a.model;
+    const sourceModel = (_b = database.getCollection(model.get("collectionName"))) == null ? void 0 : _b.model;
+    if (!sourceModel || !targetModel) {
+      return;
+    }
+    const foreignKey = throughCollection.model.rawAttributes[model.get("foreignKey")];
+    const otherKey = throughCollection.model.rawAttributes[model.get("otherKey")];
+    const sourceKey = sourceModel.rawAttributes[model.get("sourceKey")];
+    const targetKey = targetModel.rawAttributes[model.get("targetKey")];
+    const foreignKeyType = getAttributeType(foreignKey);
+    const otherKeyType = getAttributeType(otherKey);
+    const sourceKeyType = getAttributeType(sourceKey);
+    const targetKeyType = getAttributeType(targetKey);
+    if (foreignKeyType && foreignKeyType !== sourceKeyType) {
+      throw new Error(
+        `Foreign key "${model.get("foreignKey")}" type "${foreignKeyType}" does not match source key "${model.get(
+          "sourceKey"
+        )}" type "${sourceKeyType}"`
+      );
+    }
+    if (otherKeyType && otherKeyType !== targetKeyType) {
+      throw new Error(
+        `Other key "${model.get("otherKey")}" type "${otherKeyType}" does not match target key "${model.get(
+          "targetKey"
+        )}" type "${targetKeyType}"`
+      );
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCheckOptions,
+  beforeInitOptions
+});

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

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

package/dist/server/hooks/index.js

@@ -0,0 +1,31 @@
+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("./beforeCreateForChildrenCollection"), 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("./beforeCreateForChildrenCollection"),
+  ...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 '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20220613103214-alert-sub-table.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 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("@tachybase/server");
+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 '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20220704225714-drop-foreign-keys.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 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("@tachybase/server");
+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();
+    }
+  }
+}

package/dist/server/migrations/20221101111110-update-foreign-fields.d.ts

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