@nocobase/plugin-graph-collection-manager 0.9.0-alpha.1

package/lib/client/utils.js

@@ -0,0 +1,565 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInheritCollections = exports.getDiffNode = exports.getDiffEdge = exports.getChildrenCollections = exports.formatPortData = exports.formatInheritEdgeData = exports.formatData = void 0;
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const shape = {
+  ER: 'er-rect',
+  EDGE: 'edge'
+};
+
+const getInheritCollections = (collections, name) => {
+  const parents = [];
+
+  const getParents = name => {
+    const collection = collections === null || collections === void 0 ? void 0 : collections.find(collection => collection.name === name);
+
+    if (collection) {
+      const inherits = collection.inherits;
+
+      if (inherits) {
+        for (let index = 0; index < inherits.length; index++) {
+          const collectionKey = inherits[index];
+          parents.push(collectionKey);
+          getParents(collectionKey);
+        }
+      }
+    }
+
+    return (0, _lodash().uniq)(parents);
+  };
+
+  return getParents(name);
+};
+
+exports.getInheritCollections = getInheritCollections;
+
+const getChildrenCollections = (collections, name) => {
+  const childrens = [];
+
+  const getChildrens = name => {
+    const inheritCollections = collections.filter(v => {
+      var _v$inherits;
+
+      return (_v$inherits = v.inherits) === null || _v$inherits === void 0 ? void 0 : _v$inherits.includes(name);
+    });
+    inheritCollections.forEach(v => {
+      const collectionKey = v.name;
+      childrens.push(v);
+      return getChildrens(collectionKey);
+    });
+    return childrens;
+  };
+
+  return getChildrens(name);
+};
+
+exports.getChildrenCollections = getChildrenCollections;
+
+const formatData = data => {
+  const edgeData = [];
+  const targetTablekeys = [];
+  const tableData = data.map((item, index) => {
+    const ports = [];
+    const totalFields = [...item.fields];
+    const inheritCollections = getInheritCollections(data, item.name);
+    const inheritedFields = (0, _lodash().reduce)(inheritCollections, (result, value) => {
+      var _data$find;
+
+      const arr = result;
+      const parentFields = (_data$find = data.find(k => k.name === value)) === null || _data$find === void 0 ? void 0 : _data$find.fields.map(v => {
+        return _objectSpread(_objectSpread({}, v), {}, {
+          sourceCollectionName: item.name
+        });
+      });
+      return arr.concat(parentFields);
+    }, []);
+    (0, _lodash().uniqBy)(totalFields.concat(inheritedFields), 'name').forEach(field => {
+      field.uiSchema && ports.push(_objectSpread({
+        id: field.key,
+        group: 'list'
+      }, field));
+      ['obo', 'oho', 'o2o', 'o2m', 'm2o', 'm2m', 'linkTo'].includes(field.interface) && edgeData.push(field);
+    });
+    targetTablekeys.push(item.name);
+    const portsData = formatPortData(ports);
+    return {
+      id: item.name,
+      shape: shape.ER,
+      name: item.name,
+      title: item.title,
+      width: 250,
+      // height: 40 * portsData.initPorts?.length||40,
+      ports: [...(portsData.initPorts || []), ...(portsData.morePorts || [])],
+      item: item
+    };
+  });
+  const edges = formatEdgeData(edgeData, targetTablekeys, tableData);
+  const inheritEdges = formatInheritEdgeData(data);
+  return {
+    nodesData: tableData,
+    edgesData: edges,
+    inheritEdges
+  };
+};
+
+exports.formatData = formatData;
+
+const formatPortData = ports => {
+  const portsData = (0, _lodash().groupBy)(ports, v => {
+    if (v.isForeignKey || v.primaryKey || ['obo', 'oho', 'o2o', 'o2m', 'm2o', 'm2m', 'linkTo', 'id'].includes(v.interface)) {
+      return 'initPorts';
+    } else {
+      return 'morePorts';
+    }
+  });
+  return portsData;
+};
+
+exports.formatPortData = formatPortData;
+
+const formatInheritEdgeData = collections => {
+  const commonAttrs = {
+    attrs: {
+      line: {
+        strokeWidth: 1,
+        textAnchor: 'middle',
+        textVerticalAnchor: 'middle',
+        stroke: '#ddd',
+        sourceMarker: null // targetMarker: null,
+
+      }
+    },
+    router: {
+      name: 'smooth',
+      args: {
+        direction: 'H'
+      }
+    },
+    labels: [{
+      markup: [{
+        tagName: 'ellipse',
+        selector: 'labelBody',
+        style: {
+          cursor: 'pointer'
+        }
+      }, {
+        tagName: 'text',
+        selector: 'labelText',
+        style: {
+          cursor: 'pointer'
+        }
+      }],
+      attrs: {
+        labelText: {
+          text: 'inherits',
+          fill: 'rgba(0, 0, 0, 0.3)',
+          textAnchor: 'middle',
+          textVerticalAnchor: 'middle'
+        },
+        labelBody: {
+          ref: 'labelText',
+          refWidth: '100%',
+          refHeight: '100%',
+          fill: '#f0f2f5'
+        }
+      },
+      position: {
+        distance: 0.5,
+        args: {
+          keepGradient: true,
+          ensureLegibility: true
+        }
+      }
+    }]
+  };
+  const inheritEdges = [];
+  collections.forEach(v => {
+    const parentCollectonKeys = v.inherits || [];
+
+    if (parentCollectonKeys.length) {
+      parentCollectonKeys.forEach(k => {
+        inheritEdges.push(_objectSpread({
+          id: v.name + k,
+          source: {
+            cell: v.name,
+            connectionPoint: 'rect'
+          },
+          target: {
+            cell: k,
+            connectionPoint: 'rect'
+          },
+          connector: 'rounded',
+          connectionType: 'inherited'
+        }, commonAttrs));
+      });
+    }
+  });
+  return inheritEdges;
+};
+
+exports.formatInheritEdgeData = formatInheritEdgeData;
+
+const formatEdgeData = (data, targetTables, tableData) => {
+  const edges = [];
+
+  for (let i = 0; i < data.length; i++) {
+    if (targetTables.includes(data[i].target)) {
+      const targetTable = tableData.find(v => v.name === data[i].target);
+      const sourceTable = tableData.find(v => v.name === (data[i].sourceCollectionName || data[i].collectionName));
+      const commonAttrs = {
+        attrs: {
+          line: {
+            strokeWidth: 1,
+            textAnchor: 'middle',
+            textVerticalAnchor: 'middle',
+            stroke: '#ddd',
+            sourceMarker: null,
+            targetMarker: null
+          }
+        },
+        router: sourceTable.id === targetTable.id ? {
+          name: 'oneSide',
+          args: {
+            side: 'left'
+          }
+        } : {
+          name: 'er',
+          args: {
+            direction: 'H'
+          }
+        },
+        labels: [{
+          markup: [{
+            tagName: 'ellipse',
+            selector: 'labelBody',
+            style: {
+              cursor: 'pointer'
+            }
+          }, {
+            tagName: 'text',
+            selector: 'labelText',
+            style: {
+              cursor: 'pointer'
+            }
+          }],
+          attrs: {
+            labelText: {
+              text: getRelationship(data[i].interface)[0],
+              fill: 'rgba(0, 0, 0, 0.3)',
+              textAnchor: 'middle',
+              textVerticalAnchor: 'middle'
+            },
+            labelBody: {
+              ref: 'labelText',
+              refWidth: '100%',
+              refHeight: '100%',
+              stroke: '#ddd',
+              fill: '#f0f2f5',
+              strokeWidth: 1,
+              rx: 10,
+              ry: 10
+            }
+          },
+          position: {
+            distance: 0.3,
+            args: {
+              keepGradient: true,
+              ensureLegibility: true
+            }
+          }
+        }, {
+          markup: [{
+            tagName: 'ellipse',
+            selector: 'labelBody',
+            style: {
+              cursor: 'pointer'
+            }
+          }, {
+            tagName: 'text',
+            selector: 'labelText',
+            style: {
+              cursor: 'pointer'
+            }
+          }],
+          attrs: {
+            labelText: {
+              text: getRelationship(data[i].interface)[1],
+              fill: 'rgba(0, 0, 0, 0.3)',
+              textAnchor: 'middle',
+              textVerticalAnchor: 'middle'
+            },
+            labelBody: {
+              ref: 'labelText',
+              refWidth: '100%',
+              refHeight: '100%',
+              stroke: '#ddd',
+              fill: '#f0f2f5',
+              rx: 10,
+              ry: 10,
+              strokeWidth: 1
+            }
+          },
+          position: {
+            distance: 0.7,
+            args: {
+              keepGradient: true,
+              ensureLegibility: true
+            }
+          }
+        }]
+      };
+
+      const isuniq = id => {
+        const targetEdge = edges.find(v => v.id === id);
+
+        if (targetEdge) {
+          targetEdge.associated.push(data[i].name);
+          return false;
+        }
+
+        return true;
+      };
+
+      if (['m2m', 'linkTo'].includes(data[i].interface)) {
+        const throughTable = tableData.find(v => v.name === data[i].through);
+
+        if (throughTable) {
+          var _sourceTable$ports$fi, _throughTable$ports$f, _targetTable$ports$fi, _throughTable$ports$f2;
+
+          const sCellId1 = sourceTable.id;
+          const tCellId1 = throughTable.id;
+          const sPortId1 = (_sourceTable$ports$fi = sourceTable.ports.find(v => v.name === data[i].sourceKey)) === null || _sourceTable$ports$fi === void 0 ? void 0 : _sourceTable$ports$fi.id;
+          const tPortId1 = (_throughTable$ports$f = throughTable.ports.find(v => v.name === data[i].foreignKey)) === null || _throughTable$ports$f === void 0 ? void 0 : _throughTable$ports$f.id;
+          const sCellId2 = targetTable.id;
+          const tCellId2 = throughTable.id;
+          const sPortId2 = (_targetTable$ports$fi = targetTable.ports.find(v => v.name === data[i].targetKey)) === null || _targetTable$ports$fi === void 0 ? void 0 : _targetTable$ports$fi.id;
+          const tPortId2 = (_throughTable$ports$f2 = throughTable.ports.find(v => v.name === data[i].otherKey)) === null || _throughTable$ports$f2 === void 0 ? void 0 : _throughTable$ports$f2.id;
+          const id1 = sCellId1 + sPortId1 + tCellId1 + tPortId1;
+          const id2 = sCellId2 + sPortId2 + tCellId2 + tPortId2;
+          edges.push(_objectSpread({
+            id: id1,
+            source: {
+              cell: sCellId1,
+              port: sPortId1,
+              anchor: {
+                name: 'right'
+              }
+            },
+            target: {
+              cell: tCellId1,
+              port: tPortId1,
+              anchor: {
+                name: 'left'
+              }
+            },
+            associated: [data[i].name],
+            m2m: [id1, id2]
+          }, commonAttrs));
+          edges.push(_objectSpread({
+            id: id2,
+            source: {
+              cell: sCellId2,
+              port: sPortId2,
+              anchor: {
+                name: 'right'
+              }
+            },
+            target: {
+              cell: tCellId2,
+              port: tPortId2,
+              anchor: {
+                name: 'left'
+              }
+            },
+            associated: [data[i].name],
+            m2m: [id1, id2]
+          }, commonAttrs));
+        }
+      } else {
+        var _targetTable$ports$fi2, _sourceTable$ports$fi2, _targetTable$ports$fi3;
+
+        const isLegalEdge = tableData.find(v => v.name == (data[i].sourceCollectionName || data[i].collectionName)).ports.find(v => v.name === data[i].foreignKey);
+        const sCellId1 = sourceTable.id;
+        const tCellId1 = targetTable.id;
+        const sPortId1 = isLegalEdge === null || isLegalEdge === void 0 ? void 0 : isLegalEdge.id;
+        const tPortId1 = (_targetTable$ports$fi2 = targetTable.ports.find(v => v.name === data[i].targetKey)) === null || _targetTable$ports$fi2 === void 0 ? void 0 : _targetTable$ports$fi2.id;
+        const sCellId2 = sourceTable.id;
+        const tCellId2 = targetTable.id;
+        const sPortId2 = (_sourceTable$ports$fi2 = sourceTable.ports.find(v => v.name === data[i].sourceKey)) === null || _sourceTable$ports$fi2 === void 0 ? void 0 : _sourceTable$ports$fi2.id;
+        const tPortId2 = (_targetTable$ports$fi3 = targetTable.ports.find(v => v.name === data[i].foreignKey)) === null || _targetTable$ports$fi3 === void 0 ? void 0 : _targetTable$ports$fi3.id;
+        const id1 = sCellId1 + sPortId1 + tCellId1 + tPortId1;
+        const id2 = sCellId2 + sPortId2 + tCellId2 + tPortId2;
+        isuniq(tCellId1 + tPortId1 + sCellId1 + sPortId1) && isLegalEdge && tPortId1 && edges.push(_objectSpread({
+          id: id1,
+          source: {
+            cell: sCellId1,
+            port: sPortId1,
+            anchor: {
+              name: 'right'
+            }
+          },
+          target: {
+            cell: tCellId1,
+            port: tPortId1,
+            anchor: {
+              name: 'left'
+            }
+          },
+          associated: [data[i].name]
+        }, commonAttrs));
+        isuniq(tCellId2 + tPortId2 + sCellId2 + sPortId2) && sPortId2 && tPortId2 && edges.push(_objectSpread({
+          id: id2,
+          source: {
+            cell: sCellId2,
+            port: sPortId2,
+            anchor: {
+              name: 'right'
+            }
+          },
+          target: {
+            cell: tCellId2,
+            port: tPortId2,
+            anchor: {
+              name: 'left'
+            }
+          },
+          associated: [data[i].name]
+        }, commonAttrs));
+      }
+    }
+  }
+
+  return (0, _lodash().uniqBy)(edges, 'id');
+};
+
+const getRelationship = relatioship => {
+  switch (relatioship) {
+    case 'm2m':
+    case 'linkTo':
+      return ['1', 'N'];
+
+    case 'o2m':
+      return ['1', 'N'];
+
+    case 'm2o':
+      return ['N', '1'];
+
+    case 'obo':
+    case 'oho':
+      return ['1', '1'];
+
+    default:
+      return [];
+  }
+};
+
+const getDiffNode = (newNodes, oldNodes) => {
+  let arr = [];
+  const length1 = newNodes.length;
+  const length2 = oldNodes.length;
+
+  for (let i = 0; i < length1; i++) {
+    if (!oldNodes.find(v => v.id === newNodes[i].id)) {
+      arr.push({
+        status: 'add',
+        node: newNodes[i]
+      });
+    } else {
+      const oldNode = oldNodes.find(v => v.id === newNodes[i].id);
+      const oldPorts = oldNode === null || oldNode === void 0 ? void 0 : oldNode.ports.items;
+      const newPorts = newNodes[i].ports;
+
+      if (oldNode) {
+        for (let h = 0; h < newPorts.length; h++) {
+          if (!oldPorts.find(v => v.id === newPorts[h].id)) {
+            arr.push({
+              status: 'insertPort',
+              node: newNodes[i],
+              port: {
+                index: h,
+                port: newPorts[h]
+              }
+            });
+          }
+        }
+
+        for (let k = 0; k < oldPorts.length; k++) {
+          if (!newPorts.find(v => v.id === oldPorts[k].id)) {
+            arr.push({
+              status: 'deletePort',
+              node: newNodes[i],
+              port: oldPorts[k]
+            });
+          }
+        }
+
+        if (oldNode.title !== newNodes[i].title) {
+          arr.push({
+            status: 'updateNode',
+            node: newNodes[i]
+          });
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < length2; i++) {
+    if (!newNodes.find(v => v.id === oldNodes[i].id)) {
+      arr.push({
+        status: 'delete',
+        node: oldNodes[i]
+      });
+    }
+  }
+
+  return arr;
+};
+
+exports.getDiffNode = getDiffNode;
+
+const getDiffEdge = (newEdges, oldEdges) => {
+  const length1 = newEdges.length;
+  const length2 = oldEdges === null || oldEdges === void 0 ? void 0 : oldEdges.length;
+  const edges = [];
+
+  for (let i = 0; i < length1; i++) {
+    if (!oldEdges.find(v => v.id === newEdges[i].id)) {
+      edges.push({
+        status: 'add',
+        edge: newEdges[i]
+      });
+    }
+  }
+
+  for (let i = 0; i < length2; i++) {
+    if (!newEdges.find(v => v.id === oldEdges[i].id)) {
+      edges.push({
+        status: 'delete',
+        edge: oldEdges[i]
+      });
+    }
+  }
+
+  return edges;
+};
+
+exports.getDiffEdge = getDiffEdge;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { default } from './server';

package/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _server.default;
+  }
+});
+
+var _server = _interopRequireDefault(require("./server"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/server/collections/graphPositions.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/lib/server/collections/graphPositions.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _database().defineCollection)({
+  name: 'graphPositions',
+  fields: [{
+    type: 'string',
+    name: 'collectionName',
+    unique: true
+  }, {
+    type: 'double',
+    name: 'x'
+  }, {
+    type: 'double',
+    name: 'y'
+  }]
+});
+
+exports.default = _default;

package/lib/server/index.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@nocobase/server';
+export declare class GraphCollectionManagerPlugin extends Plugin {
+    load(): Promise<void>;
+}
+export default GraphCollectionManagerPlugin;

package/lib/server/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.GraphCollectionManagerPlugin = void 0;
+
+function _server() {
+  const data = require("@nocobase/server");
+
+  _server = function _server() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class GraphCollectionManagerPlugin extends _server().Plugin {
+  load() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this.db.import({
+        directory: _path().default.resolve(__dirname, 'collections')
+      });
+
+      _this.app.acl.allow('graphPositions', '*');
+    })();
+  }
+
+}
+
+exports.GraphCollectionManagerPlugin = GraphCollectionManagerPlugin;
+var _default = GraphCollectionManagerPlugin;
+exports.default = _default;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@nocobase/plugin-graph-collection-manager",
+  "version": "0.9.0-alpha.1",
+  "description": "",
+  "license": "AGPL-3.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@antv/x6": "^1.9.0",
+    "@antv/x6-react-shape": "^1.6.2",
+    "dagre": "^0.8.5"
+  },
+  "devDependencies": {
+    "@nocobase/client": "0.9.0-alpha.1",
+    "@nocobase/test": "0.9.0-alpha.1"
+  },
+  "gitHead": "d84c2a47c42c2ffec4fbf317d53268952fbd58d7"
+}

package/server.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+export * from './lib/server';
+export { default } from './lib/server';
+