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

package/src/types/node.ts

@@ -1,246 +0,0 @@
-import { ColumnNode, CustomNode, TableNode } from '../components';
-import { expandIcon, foldIcon, loadingIcon } from '../assets';
-import { IBaseEdgeConfig, IBaseNodeConfig } from "@aloudata/ink-graph-new";
-
-export type IAssetNode = TableNode | CustomNode;
-export type INode = IAssetNode | ColumnNode;
-
-export enum EEntityType {
-  // 表
-  TABLE = 'TABLE',
-  // 视图
-  VIEW = 'VIEW',
-  // 任务
-  TASK = 'TASK',
-  // 临时表
-  TEMP_TABLE = 'TEMP_TABLE',
-  // CUSTOM
-  CUSTOM = 'CUSTOM',
-}
-
-// 表的类型
-export enum ETableType {
-  // 视图
-  VIEW = 'VIEW',
-  // 表
-  TABLE = 'TABLE',
-  // 临时表
-  TEMP_TABLE = 'TEMP_TABLE',
-}
-
-export enum EDirection {
-  OUTPUT = 'OUTPUT',
-  INPUT = 'INPUT',
-  BOTH = 'BOTH',
-}
-
-export enum EDataSourceType {
-  MYSQL = 'MYSQL',
-  MARIADB = 'MARIADB',
-  GAUSS = 'GAUSS',
-  HIVE = 'HIVE',
-  KAFKA = 'KAFKA',
-  POSTGRE = 'POSTGRE',
-  POSTGRESQL = 'POSTGRESQL',
-  SNOWFLAKE = 'SNOWFLAKE',
-  IMPALA = 'IMPALA',
-  ORACLE = 'ORACLE',
-  SPARK = 'SPARK',
-  TERADATA = 'TERADATA',
-  DB2 = 'DB2',
-  OTHER = 'OTHER',
-  DORIS = 'DORIS',
-  OPEN_GAUSS = 'OPENGAUSS',
-  FLINK = 'FLINK',
-  GREEN_PLUM = 'GREENPLUM',
-  SQLSERVER = 'SQLSERVER',
-  CLICK_HOUSE = 'CLICKHOUSE',
-  BYTE_HOUSE = 'BYTEHOUSE',
-  TIDB = 'TIDB',
-  GOLDENDB = 'GOLDENDB',
-  OCEAN_BASE = 'OCEANBASE',
-  POLAR_DB = 'POLARDB',
-  DM = 'DM',
-  TDSQL = 'TDSQL',
-  SEQUOIA_DB = 'SEQUOIADB',
-}
-
-export enum ERelationType {
-  // 表到表 直接关系
-  TableDirectTable = 'TableDirectTable',
-  // 表到表 间接关系
-  TableIndirectTable = 'TableIndirectTable',
-  // 列到列 直接关系
-  ColumnDirectColumn = 'ColumnDirectColumn',
-  // 列到列 间接关系
-  ColumnIndirectColumn = 'ColumnIndirectColumn',
-  // 列到表  间接关系
-  ColumnIndirectTable = 'ColumnIndirectTable',
-  // 列到自定义  直接关系 new
-  ColumnDirectCustom = 'ColumnDirectCustom',
-  // 列到自定义  间接关系 new
-  ColumnIndirectCustom = 'ColumnIndirectCustom',
-  // 表到自定义  直接关系 new
-  TableDirectCustom = 'TableDirectCustom',
-  // 表到自定义  间接关系 new
-  TableIndirectCustom = 'TableIndirectCustom',
-  // 自定义到自定义  直接关系 new
-  CustomDirectCustom = 'CustomDirectCustom',
-  // 自定义到自定义  间接关系 new
-  CustomIndirectCustom = 'CustomIndirectCustom',
-  // 自定义到表  间接关系 new
-  CustomIndirectTable = 'CustomIndirectTable',
-  // 自定义到表 直接关系 new
-  CustomDirectTable = 'CustomDirectTable',
-  // 自定义到列  直接关系 new
-  CustomDirectColumn = 'CustomDirectColumn',
-  // 自定义到列  间接关系 new
-  CustomIndirectColumn = 'CustomIndirectColumn',
-}
-
-export enum EExpandType {
-  EXPAND = 'EXPAND',
-  FOLD = 'FOLD',
-  LODING = 'LODING',
-}
-
-export const EXPAND_BUTTON_TYPE = {
-  [EExpandType.EXPAND]: expandIcon,
-  [EExpandType.FOLD]: foldIcon,
-  [EExpandType.LODING]: loadingIcon,
-};
-
-export enum EElementType {
-  TABLE = 'TABLE',
-  COLUMN = 'COLUMN',
-  CUSTOM = 'CUSTOM',
-}
-
-export enum EOverviewType {
-  TABLE = 'TABLE',
-  VIEW = 'VIEW',
-  COLUMN = 'COLUMN',
-  TASK = 'TASK',
-  TEMP_TABLE = 'TEMP_TABLE',
-  TEMP_COLUMN = 'TEMP_COLUMN',
-  CUSTOM = 'CUSTOM',
-}
-
-export enum EDashType {
-  DIRECT = 'DIRECT',
-  INDIRECT = 'INDIRECT',
-  ALL = 'ALL',
-}
-
-// 定义输入数据的接口
-export interface ILineageData<TTable, TColumn> {
-  entities: IEntity<TTable>[];
-  relations: IBseRelation[];
-}
-
-// 血缘接口返回的数据，并且在dataProcessor中处理实体的方法需要这个定义
-export interface IEntity<T> {
-  guid: string;
-  typeCode: string;
-  typeCodeName: string;
-  properties: T;
-}
-
-// 血缘接口返回的数据，并且在dataProcessor中处理关系的方法需要这个定义
-export interface IBseRelation {
-  srcGuid: string;
-  dstGuid: string;
-  relationTypeCode: ERelationType;
-  fold: boolean;
-}
-
-export interface TDataBase<T> {
-  columns?: Array<T>;
-  name: string;
-  type?: string;
-  columnCount?: number;
-  typeCodeName?: string;
-  icon?: string;
-  typeCode?: string;
-  displayName?: string;
-  datasourceType?: EDataSourceType;
-  description?: string;
-  assetPath?: string;
-  isHotspot?: boolean;
-}
-export interface IColResBase {
-  name: string;
-  guid: string;
-  tableName: string;
-  position: number;
-  constraint?: string;
-  displayName?: string;
-  description?: string;
-}
-
-/****************************************************************** *******************************************************************/export interface IEdgeConfig extends IBaseEdgeConfig {
-  id: string;
-  type: string;
-  relationType: EDashType;
-  isFolded: boolean; // 展开/收起
-  canBeFold: boolean; // 合并链路
-  data: {
-    srcGuid: string;
-    dstGuid: string;
-    relationTypeCode: ERelationType;
-    fold?: boolean;
-  };
-  source: string;
-  target: string;
-  style?: {
-    [key: string]: any;
-  };
-}
-
-export interface INodeConfig<T extends TDataBase<M>, M extends IColResBase> extends IBaseNodeConfig {
-  data: T;
-  children: IColumnConfig<M>[];
-  isStartNode: boolean;
-  isOpen: boolean; // open table
-  visible: boolean; // see: direct & indirect & - & +
-  isRelated: boolean; // see: related & uncorrelated
-  isFolded: boolean; // see: fold & unfold
-  isFoldInput: boolean;
-  isFoldOutput: boolean;
-  isExpandOutput: boolean;
-  isExpandInput: boolean;
-  canExpandInput: boolean; // has edge.target === this
-  canExpandOutput: boolean; // has edge.source === this
-  canFoldInput: boolean;
-  canFoldOutput: boolean;
-  hasMoreInput: boolean; // has more input data
-  hasMoreOutput: boolean; // has more output data
-  canBeFold: boolean;
-  pagination: {
-    pageNum: number; // current page index
-    pageSize: number; // page size
-    total: number; // columns count
-    totalPage: number; // page count
-  };
-  relatedColumns: IColumnConfig<M>[]; // related columns are expanded out
-  [key: string]: unknown;
-}
-
-export interface IColumnConfig<T> extends IBaseNodeConfig {
-  id: string;
-  tableId: string;
-  tableName: string;
-  visible: boolean;
-  isRelated: boolean;
-  isRelatedColumn: boolean;
-  isFolded: boolean;
-  canBeFold: boolean;
-  canExpandInput: boolean;
-  canExpandOutput: boolean;
-  canFoldInput: boolean;
-  canFoldOutput: boolean;
-  hasMoreInput: boolean;
-  hasMoreOutput: boolean;
-  isStartNode: boolean;
-  data: T;
-}

package/src/utils/foldNode.ts

@@ -1,345 +0,0 @@
-import { FOLD_EDGE, LINEAGE_EDGE } from '../constant';
-import {
-  EDashType,
-  ERelationType,
-  IColResBase,
-  IColumnConfig,
-  IEdgeConfig,
-  INodeConfig,
-  TDataBase,
-} from '../types';
-import { IFoldGroup, InkLineageManager } from '..';
-
-function getRootNodesId<TTableData extends {
-  columns?: Array<TColumnData>;
-  name: string;
-  type?: string;
-}, TColumnData extends IColResBase>(
-  nodesConfig: INodeConfig<TTableData, TColumnData>[],
-  allNodesId: Set<string>,
-  edgesConfig: IEdgeConfig[],
-): string[] {
-  const downstreamNodesId = new Set(edgesConfig.map((edge) => edge.target));
-  const rootNodesId = [...allNodesId].filter(
-    (INodeId) => !downstreamNodesId.has(INodeId),
-  );
-
-  const rootNodes = nodesConfig.filter((nodeCfg) =>
-    rootNodesId.includes(nodeCfg.id),
-  );
-
-  return rootNodes.map((node) => node.id);
-}
-
-function getFoldNodeGroup<TTableData extends {
-  columns?: Array<TColumnData>;
-  name: string;
-  type?: string;
-}, TColumnData extends IColResBase>(
-  nodeId: string,
-  nodesConfig: INodeConfig<TTableData, TColumnData>[],
-  edgesConfig: IEdgeConfig[],
-): INodeConfig<TTableData, TColumnData>[] {
-  const downstreamNodes = getDownstreamINodes(nodeId, edgesConfig);
-  const subtree = [nodesConfig.find((nodeCfg) => nodeCfg.id === nodeId)];
-
-  downstreamNodes.forEach((downstreamNodeId) => {
-    subtree.push(
-      ...getFoldNodeGroup<TTableData, TColumnData>(downstreamNodeId, nodesConfig, edgesConfig),
-    );
-  });
-  return subtree;
-}
-
-function getDownstreamINodes(
-  nodeId: string,
-  edgesConfig: IEdgeConfig[],
-): string[] {
-  return edgesConfig
-    .filter((edgeCfg) => edgeCfg.source === nodeId)
-    .map((edgeCfg) => edgeCfg.target);
-}
-
-function getUpstreamTableId(nodeId: string, edgesConfig: IEdgeConfig[]) {
-  const validEdge = edgesConfig.find((edge) => {
-    return (
-      edge.target === nodeId &&
-      (edge.relationType === EDashType.ALL ||
-        edge.relationType === EDashType.DIRECT)
-    );
-  });
-
-  if (!validEdge) return '';
-
-  return validEdge.source;
-}
-
-function getDownstreamTableId(nodeId: string, edgesConfig: IEdgeConfig[]) {
-  const validEdge = edgesConfig.find((edge) => {
-    return (
-      edge.source === nodeId &&
-      (edge.relationType === EDashType.ALL ||
-        edge.relationType === EDashType.DIRECT)
-    );
-  });
-
-  if (!validEdge) return '';
-
-  return validEdge.target;
-}
-
-function findColumnsWithDirectEdges<TColumnData extends IColResBase>(
-  columns: IColumnConfig<TColumnData>[],
-  edges: IEdgeConfig[],
-): {
-    column: IColumnConfig<TColumnData>;
-  inputEdge: IEdgeConfig;
-  outputEdge: IEdgeConfig;
-}[] {
-  const result: {
-    column: IColumnConfig<TColumnData>;
-    inputEdge: IEdgeConfig;
-    outputEdge: IEdgeConfig;
-  }[] = [];
-
-  for (const column of columns) {
-    const upstreamEdges = edges.filter(
-      (edge) =>
-        edge.target === column.id &&
-        edge.relationType === EDashType.DIRECT &&
-        edge.data.fold === true,
-    );
-
-    const downstreamEdges = edges.filter(
-      (edge) =>
-        edge.source === column.id &&
-        edge.relationType === EDashType.DIRECT &&
-        edge.data.fold === true,
-    );
-
-    if (upstreamEdges.length === 1 && downstreamEdges.length === 1) {
-      result.push({
-        column,
-        inputEdge: upstreamEdges[0],
-        outputEdge: downstreamEdges[0],
-      });
-    }
-  }
-
-  return result;
-}
-
-// step 1: find all fold nodes
-export function getFoldNodes<TTableData extends TDataBase<TColumnData>, TColumnData extends IColResBase>(
-  nodes: INodeConfig<TTableData, TColumnData>[],
-  edges: IEdgeConfig[],
-  lineageMgr: InkLineageManager<TTableData, TColumnData>
-) {
-  const foldNodes: INodeConfig<TTableData, TColumnData>[] = [];
-
-  nodes.forEach((node) => {
-    if (node.isStartNode) return;
-
-    const { relatedColumns } = node;
-
-    // 只有一个列满足其上下游均为直接边，且直接边只有一条，表示该列可以被折叠
-    const canBeFoldColumns = findColumnsWithDirectEdges(relatedColumns, edges);
-
-    if (canBeFoldColumns.length !== 1) return;
-
-    const tableInputEdges: IEdgeConfig[] = [];
-    const tableOutputEdges: IEdgeConfig[] = [];
-
-    // 且该列的上下游relation只有一个且只能是fold为true
-    edges.forEach((edge) => {
-
-      if (tableInputEdges.length > 1 || tableOutputEdges.length > 1) {
-        return;
-      }
-
-      if (
-        edge.target === node.id &&
-        (edge.relationType === EDashType.DIRECT ||
-          edge.relationType === EDashType.ALL)
-      ) {
-        tableInputEdges.push(edge);
-      }
-
-      if (
-        edge.source === node.id &&
-        (edge.relationType === EDashType.DIRECT ||
-          edge.relationType === EDashType.ALL)
-      ) {
-        tableOutputEdges.push(edge);
-      }
-    });
-
-    if (tableInputEdges.length === 1 && tableOutputEdges.length === 1) {
-      const inputNodeConfig = lineageMgr.getNodeConfigById(
-        canBeFoldColumns[0]?.inputEdge.source,
-      );
-
-      const currNodeConfig = lineageMgr.getNodeConfigById(
-        canBeFoldColumns[0]?.outputEdge.target,
-      );
-
-      const inputTableNode = lineageMgr.getNodeConfigById(
-        (inputNodeConfig?.tableId as string) || inputNodeConfig?.id,
-      );
-
-      const currTableNode = lineageMgr.getNodeConfigById(
-        (currNodeConfig?.tableId as string) || currNodeConfig?.id,
-      );
-
-      if (inputTableNode?.position?.x >= currTableNode?.position?.x) return; // FIXME: 这里需要优化  @yunke
-      node.canBeFold = true;
-
-      foldNodes.push(node);
-    }
-  });
-
-  return foldNodes;
-}
-
-// step 2: find all fold node groups
-export function getFoldNodesGroup<TTableData extends {
-  columns?: Array<TColumnData>;
-  name: string;
-  type?: string;
-}, TColumnData extends IColResBase>(
-  nodesConfig: INodeConfig<TTableData, TColumnData>[],
-  edgesConfig: IEdgeConfig[],
-): INodeConfig<TTableData, TColumnData>[][] {
-  const validNodeIds = new Set(nodesConfig.map((nodeCfg) => nodeCfg.id));
-  const validEdges = edgesConfig.filter((edgeCfg) => {
-    return validNodeIds.has(edgeCfg.source) && validNodeIds.has(edgeCfg.target);
-  });
-
-  const rootNodesId = getRootNodesId<TTableData, TColumnData>(nodesConfig, validNodeIds, validEdges);
-
-  const nodesGroup = rootNodesId.map((rootNodeId) =>
-    getFoldNodeGroup<TTableData, TColumnData>(rootNodeId, nodesConfig, validEdges),
-  );
-
-  return nodesGroup;
-}
-
-// step 3: generate fold nodes map
-export function getFoldNodesGroupMap<TTableData extends {
-  columns?: Array<TColumnData>;
-  name: string;
-  type?: string;
-}, TColumnData extends IColResBase>(
-  lineageMgr: InkLineageManager<TTableData, TColumnData>,
-  nodesConfigGroup: INodeConfig<TTableData, TColumnData>[][],
-  edgesConfig: IEdgeConfig[],
-) {
-  const foldNodesMap = new Map<string, IFoldGroup<TTableData, TColumnData>>();
-  nodesConfigGroup.forEach((nodes) => {
-    // 获取起始节点的id:  每个子数组的第一个节点的srcId
-    const startNode = nodes[0];
-    // 从edges中找到startNode的上游table的id
-    const upstreamNodeId = getUpstreamTableId(startNode.id, edgesConfig);
-
-    // 获取末尾节点的id：每个子数组的末尾节点的dstId
-    const endNode = nodes[nodes.length - 1];
-    // 从edges中找到endNode的下游table的id
-    const downstreamNodeId = getDownstreamTableId(endNode.id, edgesConfig);
-
-    let srcColumnId = '';
-    let dstColumnId = '';
-
-    const startCanBeFoldColumns = findColumnsWithDirectEdges<TColumnData>(
-      startNode.relatedColumns,
-      edgesConfig,
-    );
-
-    const endCanBeFoldColumns = findColumnsWithDirectEdges<TColumnData>(
-      endNode.relatedColumns,
-      edgesConfig,
-    );
-
-    srcColumnId = startCanBeFoldColumns[0]?.inputEdge.source;
-    dstColumnId = endCanBeFoldColumns[0]?.outputEdge.target;
-
-    if (!srcColumnId || !dstColumnId) return;
-
-    // 生成key "起始节点的id-末尾节点的id"
-    const key = `${srcColumnId}___${dstColumnId}`;
-
-    // 从edges中挑选出当前子数组的所有边,都会删除
-    const foldEdges: IEdgeConfig[] = [];
-
-    edgesConfig.forEach((edge) => {
-      const { source, target, data } = edge;
-      if (data?.relationTypeCode?.includes('Table')) return; // FIXME: 这里的判断条件不够严谨 @yunke
-
-      nodes.forEach((node) => {
-        if (
-          source === node.id ||
-          target === node.id ||
-          source.startsWith(`${node.id}.`) ||
-          target.startsWith(`${node.id}.`)
-        ) {
-          edge.inFoldLink = true;
-          edge.foldTableId = key;
-          edge.type = FOLD_EDGE;
-          foldEdges.push(edge);
-        }
-      });
-    });
-    const value = {
-      foldNodes: nodes,
-      foldEdges,
-      foldNodeEdgeConfig: {
-        id: `${upstreamNodeId}___${downstreamNodeId}`,
-        type: LINEAGE_EDGE,
-        data: {
-          relationTypeCode: ERelationType.TableDirectTable,
-        },
-        source: upstreamNodeId,
-        target: downstreamNodeId,
-        relationType: EDashType.DIRECT,
-        fold: false,
-        foldNodeId: key,
-        visible: true,
-        isActive: false,
-        isFolded: false,
-        canBeFold: false,
-        style: {
-          fill: '#0000',
-          stroke: '#B1B1B1',
-          lineWidth: 1,
-        },
-        isExtraFoldEdge: true,
-      },
-      foldColumnEdgeConfig: {
-        id: `${srcColumnId}___${dstColumnId}`,
-        type: FOLD_EDGE,
-        data: {
-          relationTypeCode: ERelationType.ColumnDirectColumn,
-        },
-        source: srcColumnId,
-        target: dstColumnId,
-        relationType: EDashType.DIRECT,
-        fold: false,
-        showExpand: true,
-        foldNodeId: key,
-        visible: true,
-        isActive: false,
-        isFolded: false,
-        canBeFold: false,
-        style: {
-          fill: '#0000',
-          stroke: '#FFB01F',
-          lineWidth: 1,
-        },
-        isExtraFoldEdge: true,
-      },
-    } as IFoldGroup<TTableData, TColumnData>;
-
-    foldNodesMap.set(key, value);
-  });
-
-  return foldNodesMap;
-}

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 '';
-  }
-};