@tachybase/module-collection 1.3.22 → 1.3.24

package/dist/externalVersion.js

@@ -1,10 +1,10 @@
 module.exports = {
-  "@tachybase/client": "1.3.22",
-  "@tachybase/module-error-handler": "1.3.22",
-  "@tego/server": "1.3.39",
+  "@tachybase/client": "1.3.24",
+  "@tachybase/module-error-handler": "1.3.24",
+  "@tego/server": "1.3.49",
   "async-mutex": "0.5.0",
   "lodash": "4.17.21",
-  "@tachybase/test": "1.3.39",
+  "@tachybase/test": "1.3.49",
   "sequelize": "6.37.5",
   "dayjs": "1.11.13"
 };

package/dist/server/hooks/afterCreateForForeignKeyField.js

@@ -122,6 +122,7 @@ function afterCreateForForeignKeyField(db) {
       source
     } = model.get();
     if (source) return;
+    if (target === "__temp__") return;
     if (["oho", "o2m"].includes(interfaceType)) {
       const values = generateFkOptions(target, foreignKey);
       await createFieldIfNotExists({

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

@@ -0,0 +1,2 @@
+import { Database } from '@tego/server';
+export declare function afterUpdateForForeignKeyField(db: Database): (model: any, options: any) => Promise<void>;

package/dist/server/hooks/afterUpdateForForeignKeyField.js

@@ -0,0 +1,249 @@
+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 afterUpdateForForeignKeyField_exports = {};
+__export(afterUpdateForForeignKeyField_exports, {
+  afterUpdateForForeignKeyField: () => afterUpdateForForeignKeyField
+});
+module.exports = __toCommonJS(afterUpdateForForeignKeyField_exports);
+function afterUpdateForForeignKeyField(db) {
+  function generateFkOptions(collectionName, foreignKey) {
+    const collection = db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error("collection not found");
+    }
+    const M = collection.model;
+    const attr = M.rawAttributes[foreignKey];
+    if (!attr) {
+      throw new Error(`${collectionName}.${foreignKey} does not exists`);
+    }
+    return attribute2field(attr);
+  }
+  function attribute2field(attribute) {
+    let type = "bigInt";
+    if (attribute.type.constructor.name === "INTEGER") {
+      type = "integer";
+    } else if (attribute.type.constructor.name === "STRING") {
+      type = "string";
+    }
+    const name = attribute.fieldName;
+    const data = {
+      interface: "integer",
+      name,
+      type,
+      uiSchema: {
+        type: "number",
+        title: name,
+        "x-component": "InputNumber",
+        "x-read-pretty": true
+      }
+    };
+    if (type === "string") {
+      data["interface"] = "input";
+      data["uiSchema"] = {
+        type: "string",
+        title: name,
+        "x-component": "Input",
+        "x-read-pretty": true
+      };
+    }
+    return data;
+  }
+  async function createFieldIfNotExists({ values, transaction }) {
+    const { collectionName, name } = values;
+    if (!collectionName || !name) {
+      throw new Error(`field options invalid`);
+    }
+    const r = db.getRepository("fields");
+    const instance = await r.findOne({
+      filter: {
+        collectionName,
+        name
+      },
+      transaction
+    });
+    if (instance) {
+      if (instance.type !== values.type) {
+        throw new Error(`fk type invalid`);
+      }
+      instance.set("sort", 1);
+      instance.set("isForeignKey", true);
+      await instance.save({ transaction });
+    } else {
+      const creatInstance = await r.create({
+        values: {
+          isForeignKey: true,
+          ...values
+        },
+        transaction
+      });
+      creatInstance.set("sort", 1);
+      await creatInstance.save({ transaction });
+    }
+    await r.update({
+      filter: {
+        collectionName,
+        options: {
+          primaryKey: true
+        }
+      },
+      values: {
+        sort: 0
+      },
+      transaction
+    });
+  }
+  const hook = async (model, { transaction, context }) => {
+    var _a;
+    if (!context) return;
+    const {
+      interface: interfaceType,
+      collectionName,
+      target: newTarget,
+      foreignKey: newForeignKey,
+      otherKey: newOtherKey,
+      through,
+      source,
+      type
+    } = model.get();
+    if (source || !interfaceType) return;
+    if (newTarget === "__temp__") return;
+    const { target: oldTarget, foreignKey: oldForeignKey, otherKey: oldOtherKey } = model.previous("options") || {};
+    const fieldsRepo = db.getRepository("fields");
+    const hasTargetChanged = oldTarget !== void 0 && oldTarget !== newTarget;
+    const hasForeignKeyChanged = oldForeignKey !== void 0 && oldForeignKey !== newForeignKey;
+    const hasOtherKeyChanged = oldOtherKey !== void 0 && oldOtherKey !== newOtherKey;
+    const needUpdate = hasTargetChanged || hasForeignKeyChanged || hasOtherKeyChanged;
+    const collection = db.getCollection(model.get("collectionName"));
+    collection == null ? void 0 : collection.updateField(model.get("name"), model.get());
+    const field = collection == null ? void 0 : collection.getField(model.get("name"));
+    if (!needUpdate) return;
+    try {
+      (_a = field == null ? void 0 : field.unbind) == null ? void 0 : _a.call(field);
+      field.bind();
+    } catch (e) {
+      throw e;
+    }
+    async function removeOldForeignKeyField(collection2, fkName) {
+      if (!collection2 || !fkName) return;
+      const exists = await fieldsRepo.findOne({
+        filter: {
+          collectionName: collection2,
+          name: fkName
+          // isForeignKey: true,
+        },
+        transaction
+      });
+      if (exists) {
+        await fieldsRepo.destroy({
+          filter: {
+            collectionName: collection2,
+            name: fkName
+            // isForeignKey: true,
+          },
+          transaction
+        });
+      }
+    }
+    if (["oho", "o2m"].includes(interfaceType)) {
+      await removeOldForeignKeyField(oldTarget, oldForeignKey);
+      const values = generateFkOptions(newTarget, newForeignKey);
+      await createFieldIfNotExists({
+        values: {
+          collectionName: newTarget,
+          ...values
+        },
+        transaction
+      });
+    } else if (["obo", "m2o"].includes(interfaceType)) {
+      await removeOldForeignKeyField(collectionName, oldForeignKey);
+      const values = generateFkOptions(collectionName, newForeignKey);
+      await createFieldIfNotExists({
+        values: {
+          collectionName,
+          ...values
+        },
+        transaction
+      });
+    } else if (["linkTo", "m2m"].includes(interfaceType)) {
+      if (type !== "belongsToMany") {
+        return;
+      }
+      const collectionsRepo = db.getRepository("collections");
+      const existingThrough = await collectionsRepo.findOne({
+        filter: {
+          name: through
+        },
+        transaction
+      });
+      if (existingThrough) {
+        await collectionsRepo.destroy({
+          filter: {
+            name: through
+          },
+          transaction
+        });
+      }
+      await collectionsRepo.create({
+        values: {
+          name: through,
+          title: through,
+          timestamps: true,
+          autoGenId: false,
+          hidden: true,
+          autoCreate: true,
+          isThrough: true,
+          sortable: false
+        },
+        context,
+        transaction
+      });
+      const opts1 = generateFkOptions(through, newForeignKey);
+      const opts2 = generateFkOptions(through, newOtherKey);
+      await createFieldIfNotExists({
+        values: {
+          collectionName: through,
+          ...opts1
+        },
+        transaction
+      });
+      await createFieldIfNotExists({
+        values: {
+          collectionName: through,
+          ...opts2
+        },
+        transaction
+      });
+    }
+    await model.migrate({
+      isNew: true,
+      transaction
+    });
+  };
+  return async (model, options) => {
+    try {
+      await hook(model, options);
+    } catch (error) {
+      console.error("Failed to update foreign key field:", error);
+      throw error;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterUpdateForForeignKeyField
+});

package/dist/server/server.js

@@ -40,6 +40,7 @@ var import_lodash = __toESM(require("lodash"));
 var import__ = require(".");
 var import_collectionImportExportMeta = require("./actions/collectionImportExportMeta");
 var import_hooks = require("./hooks");
+var import_afterUpdateForForeignKeyField = require("./hooks/afterUpdateForForeignKeyField");
 var import_beforeCreateForValidateField = require("./hooks/beforeCreateForValidateField");
 var import_beforeCreateForViewCollection = require("./hooks/beforeCreateForViewCollection");
 var import_models = require("./models");
@@ -147,6 +148,7 @@ class CollectionManagerPlugin extends import_server.Plugin {
         model.set("sortBy", model.get("foreignKey") + "Sort");
       }
     });
+    this.app.db.on("fields.afterUpdate", (0, import_afterUpdateForForeignKeyField.afterUpdateForForeignKeyField)(this.app.db));
     this.app.db.on("fields.afterUpdate", async (model, { context, transaction }) => {
       const prevOptions = model.previous("options");
       const currentOptions = model.get("options");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tachybase/module-collection",
   "displayName": "Data source: Main",
-  "version": "1.3.22",
+  "version": "1.3.24",
   "description": "TachyBase main database, supports relational databases such as MySQL, PostgreSQL, SQLite and so on.",
   "keywords": [
     "Data sources"
@@ -11,16 +11,16 @@
   "dependencies": {},
   "devDependencies": {
     "@hapi/topo": "^6.0.2",
-    "@tachybase/test": "^1.3.39",
-    "@tego/client": "^1.3.39",
-    "@tego/server": "^1.3.39",
+    "@tachybase/test": "^1.3.49",
+    "@tego/client": "^1.3.49",
+    "@tego/server": "^1.3.49",
     "@types/lodash": "^4.17.20",
     "async-mutex": "^0.5.0",
     "lodash": "4.17.21",
     "sequelize": "^6.37.5",
     "toposort": "^2.0.2",
-    "@tachybase/client": "1.3.22",
-    "@tachybase/module-error-handler": "1.3.22"
+    "@tachybase/client": "1.3.24",
+    "@tachybase/module-error-handler": "1.3.24"
   },
   "description.zh-CN": "TachyBase 主数据库，支持 MySQL、PostgreSQL、SQLite 等关系型数据库。",
   "displayName.zh-CN": "数据源：主数据库",