@aloudata/ink-lineage 0.0.1-beta.1

package/src/utils/getIconByType.ts

@@ -0,0 +1,104 @@
+import {
+  column24,
+  custom24,
+  table24,
+  tableTemporary,
+  taskSql,
+  view24,
+  mySql,
+  oracle,
+  postgre,
+  snowflake,
+  spark,
+  teradata,
+  kafka,
+  impala,
+  hive,
+  gauss,
+  flink,
+  greenplum,
+  SQLServer,
+  clickhouse,
+  byteHouse,
+  TiDB,
+  goldenDb,
+  oceanBase,
+  polarDb,
+  dm,
+  tdSQL,
+  sequoiaDb,
+} from '../assets';
+import { EDataSourceType, ETableType } from '../types';
+
+export function getEntityTypeIcon(typeCode: string, type?: string) {
+  switch (typeCode) {
+    case 'Table':
+      if (type === ETableType.TEMP_TABLE) {
+        return tableTemporary;
+      }
+
+      if (type === ETableType.VIEW) {
+        return view24;
+      }
+
+      return table24;
+    case 'Task':
+      return taskSql;
+    case 'Column':
+      return column24;
+    default:
+      return custom24;
+  }
+}
+
+export const getDataSourceTypeIcon = (datasourceType: EDataSourceType) => {
+  switch (datasourceType) {
+    case EDataSourceType.HIVE:
+      return hive;
+    case EDataSourceType.MYSQL:
+      return mySql;
+    case EDataSourceType.GAUSS:
+      return gauss;
+    case EDataSourceType.KAFKA:
+      return kafka;
+    case EDataSourceType.SNOWFLAKE:
+      return snowflake;
+    case EDataSourceType.POSTGRE:
+    case EDataSourceType.POSTGRESQL:
+      return postgre;
+    case EDataSourceType.IMPALA:
+      return impala;
+    case EDataSourceType.SPARK:
+      return spark;
+    case EDataSourceType.ORACLE:
+      return oracle;
+    case EDataSourceType.TERADATA:
+      return teradata;
+    case EDataSourceType.FLINK:
+      return flink;
+    case EDataSourceType.GREEN_PLUM:
+      return greenplum;
+    case EDataSourceType.SQLSERVER:
+      return SQLServer;
+    case EDataSourceType.CLICK_HOUSE:
+      return clickhouse;
+    case EDataSourceType.BYTE_HOUSE:
+      return byteHouse;
+    case EDataSourceType.TIDB:
+      return TiDB;
+    case EDataSourceType.GOLDENDB:
+      return goldenDb;
+    case EDataSourceType.OCEAN_BASE:
+      return oceanBase;
+    case EDataSourceType.POLAR_DB:
+      return polarDb;
+    case EDataSourceType.DM:
+      return dm;
+    case EDataSourceType.TDSQL:
+      return tdSQL;
+    case EDataSourceType.SEQUOIA_DB:
+      return sequoiaDb;
+    default:
+      return '';
+  }
+};

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './node';
+export * from './getIconByType';
+export * from './foldNode';

package/src/utils/node.ts

@@ -0,0 +1,294 @@
+import {
+  EColumnEvents,
+  ECustomEvents,
+  EventEnumType,
+  ETableEvents,
+} from '../types';
+import _ from 'lodash';
+import {
+  EElementType,
+  EOverviewType,
+  EDirection,
+  IColumnConfig,
+  IEdgeConfig,
+  INodeConfig,
+  IColResBase,
+  TDataBase,
+} from '../types';
+
+export function getEventTypeByNodeType(elementType: EElementType): EventEnumType {
+  if (elementType === EElementType.TABLE) {
+    return ETableEvents;
+  }
+
+  if (elementType === EElementType.CUSTOM) {
+    return ECustomEvents;
+  }
+
+  if (elementType === EElementType.COLUMN) {
+    return EColumnEvents;
+  }
+
+  return ETableEvents;
+}
+
+export function getOverviewType(type: string) {
+  switch (type) {
+    case 'VIEW':
+      return EOverviewType.TABLE;
+    case 'TABLE':
+      return EOverviewType.TABLE;
+    case 'TEMP_TABLE':
+      return EOverviewType.TEMP_TABLE;
+    case 'CUSTOM':
+      return EOverviewType.CUSTOM;
+  }
+  return EOverviewType.TABLE;
+}
+
+export function getRelatedData<TTableData extends TDataBase<TColumnData>, TColumnData extends IColResBase>(
+  startNodeCfg: INodeConfig<TTableData, TColumnData> | IColumnConfig<TColumnData>,
+  nodesConfig: INodeConfig<TTableData, TColumnData>[],
+  edgesConfig: IEdgeConfig[],
+  direction: EDirection,
+  // edgeDashVisible: EDashType,
+) {
+  const nodesConfigMap = new Map<string, INodeConfig<TTableData, TColumnData>>();
+  const columnsConfigMap = new Map<string, IColumnConfig<TColumnData>>();
+
+  nodesConfig.forEach((n) => {
+    nodesConfigMap.set(n.id, n);
+    n.relatedColumns?.forEach((c) => columnsConfigMap.set(c.id, c));
+  });
+
+  // related nodes
+  const relatedNodes: (INodeConfig<TTableData, TColumnData> | IColumnConfig<TColumnData>)[] = [startNodeCfg];
+
+  // related edges
+  const relatedEdges: IEdgeConfig[] = [];
+
+  // loop list
+  const todoList: (INodeConfig<TTableData, TColumnData> | IColumnConfig<TColumnData>)[] = [startNodeCfg];
+
+  while (todoList.length > 0) {
+    const curr = todoList.shift();
+    // check exist
+    if (_.isNil(curr)) return;
+
+    let validEdges = [];
+
+    validEdges = edgesConfig;
+
+    validEdges.forEach((edge) => {
+      // find input list
+      if (direction === EDirection.BOTH || direction === EDirection.INPUT) {
+        if (edge.target === curr.id) {
+          relatedEdges.push(edge);
+
+          // find target from tables & related columns
+          const srcNode =
+            nodesConfigMap.get(edge.source) ||
+            columnsConfigMap.get(edge.source);
+
+          if (!srcNode) return;
+
+          if (!_.some(relatedNodes, { id: srcNode.id })) {
+            todoList.push(srcNode);
+            relatedNodes.push(srcNode);
+          }
+        }
+      }
+
+      // find output list
+      if (direction === EDirection.BOTH || direction === EDirection.OUTPUT) {
+        if (edge.source === curr.id) {
+          relatedEdges.push(edge);
+
+          // find target from tables & related columns
+          const tgtNode =
+            nodesConfigMap.get(edge.target) ||
+            columnsConfigMap.get(edge.target);
+
+          if (!tgtNode) return;
+
+          if (!_.some(relatedNodes, { id: tgtNode.id })) {
+            todoList.push(tgtNode);
+            relatedNodes.push(tgtNode);
+          }
+        }
+      }
+    });
+  }
+
+  return {
+    relatedNodes,
+    relatedEdges,
+  };
+}
+
+export function groupNodesByEdgesAndDirection<TTableData extends TDataBase<TColumnData>, TColumnData extends IColResBase>(
+  startNodeCfg: INodeConfig<TTableData, TColumnData>,
+  nodesConfig: INodeConfig<TTableData, TColumnData>[],
+  edgesConfig: IEdgeConfig[],
+  direction: EDirection,
+  filterFoldNodes: boolean = false,
+  skipCircle: boolean = false,
+) {
+  const nodesConfigMap = new Map<string, INodeConfig<TTableData, TColumnData>>();
+  nodesConfig.forEach((n) => nodesConfigMap.set(n.id, n));
+
+  const existMap = new Map<string, number>();
+  existMap.set(startNodeCfg.id, 0);
+
+  const todoList: INodeConfig<TTableData, TColumnData>[] = [startNodeCfg];
+
+  const relatedEdges: IEdgeConfig[] = [];
+
+  while (todoList.length > 0) {
+    const curr = todoList.shift();
+    // check exist
+    if (_.isNil(curr)) return;
+
+    // get curr position
+    const currPosition = existMap.get(curr.id);
+    if (_.isNil(currPosition)) return;
+
+    edgesConfig.forEach((edge) => {
+      // find input list
+      if (direction === EDirection.BOTH || direction === EDirection.INPUT) {
+        if (edge.target === curr.id) {
+          relatedEdges.push(edge);
+
+          const srcNode =
+            nodesConfigMap.get(edge.source) ||
+            Array.from(nodesConfigMap.values()).find((item) =>
+              item.children.some((col) => col?.id === edge.source),
+            );
+
+          if (!srcNode) return;
+
+          if (skipCircle && srcNode.position.x >= curr.position.x) {
+            return;
+          }
+
+          if (!existMap.has(srcNode.id)) {
+            existMap.set(srcNode.id, currPosition - 1);
+
+            if (filterFoldNodes && srcNode.isFoldInput) {
+              return;
+            } else {
+              todoList.push(srcNode);
+            }
+          }
+        }
+      }
+
+      if (direction === EDirection.BOTH || direction === EDirection.OUTPUT) {
+        // find output list
+        if (edge.source === curr.id) {
+          relatedEdges.push(edge);
+
+          const tgtNode =
+            nodesConfigMap.get(edge.target) ||
+            Array.from(nodesConfigMap.values()).find((item) =>
+              item.children.some((col) => col?.id === edge.target),
+            );
+
+          if (!tgtNode) return;
+
+          if (skipCircle && tgtNode.position.x <= curr.position.x) {
+            return;
+          }
+
+          if (!existMap.has(tgtNode.id)) {
+            existMap.set(tgtNode.id, currPosition + 1);
+
+            if (filterFoldNodes && tgtNode.isFoldOutput) {
+              return;
+            } else {
+              todoList.push(tgtNode);
+            }
+          }
+        }
+      }
+    });
+  }
+
+  return {
+    groupedNodes: existMap,
+    relatedEdges,
+  };
+}
+
+export function isAllDirectEdges<TTableData extends TDataBase<TColumnData>, TColumnData extends IColResBase>(
+  currNode: INodeConfig<TTableData, TColumnData>
+    | IColumnConfig<TColumnData>,
+  nodes: (INodeConfig<TTableData, TColumnData>
+    | IColumnConfig<TColumnData>)[],
+  edges: IEdgeConfig[],
+) {
+  const nodeId = currNode.id;
+  const startNode = nodes.find((node) => node.isStartNode);
+
+  if (!startNode) {
+    return false;
+  }
+
+  const visited = new Set();
+
+  function dfsUpstream(currentNodeId: string) {
+    if (
+      currentNodeId === startNode.id ||
+      currentNodeId.includes(`${startNode.id}.`)
+    ) {
+      return true;
+    }
+
+    visited.add(currentNodeId);
+
+    const incomingEdges = edges.filter((edge) => edge.target === currentNodeId);
+
+    for (const edge of incomingEdges) {
+      if (edge.relationType === 'INDIRECT') {
+        return false;
+      }
+
+      if (!visited.has(edge.source)) {
+        if (dfsUpstream(edge.source)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  function dfsDownstream(currentNodeId: string) {
+    if (
+      currentNodeId === startNode.id ||
+      currentNodeId.includes(`${startNode.id}.`)
+    ) {
+      return true;
+    }
+
+    visited.add(currentNodeId);
+
+    const outgoingEdges = edges.filter((edge) => edge.source === currentNodeId);
+
+    for (const edge of outgoingEdges) {
+      if (edge.relationType === 'INDIRECT') {
+        return false;
+      }
+
+      if (!visited.has(edge.target)) {
+        if (dfsDownstream(edge.target)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return dfsUpstream(nodeId) || dfsDownstream(nodeId);
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "composite": true,
+    "module": "esnext",
+    "declaration": true /* 生成相关的 '.d.ts' 文件。 */,
+    "declarationDir": "./dist" /* '.d.ts' 文件输出目录 */,
+    // "emitDeclarationOnly": true /* 只生成声明文件，不生成 js 文件*/,
+    "sourceMap": true,
+    "target": "es5",
+    "outDir": "dist",
+    "jsx": "react",
+    //    "watch": true,
+    "importHelpers": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "lib": ["esnext", "dom"],
+    "types": ["jest"],
+    "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
+    "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
+    "downlevelIteration": true
+  },
+  // "include": ["src/**/*", "rollup.config.js"],
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.spec.ts"],
+  "references": []
+}