@aloudata/ink-lineage 0.0.1-beta.2 → 0.0.1-beta.20

package/src/utils/getIconByType.ts

@@ -1,104 +0,0 @@
-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/node.ts

@@ -1,294 +0,0 @@
-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

@@ -1,30 +0,0 @@
-{
-  "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": []
-}