export async function fetchEntityDetails()

in packages/graph-explorer/src/core/fetchEntityDetails.ts [13:81]


export async function fetchEntityDetails(
  vertices: Set<VertexId>,
  edges: Set<EdgeId>,
  queryClient: QueryClient,
  explorer: Explorer
) {
  const vertexResults = await Promise.allSettled(
    vertices
      .values()
      .map(id =>
        queryClient.ensureQueryData(
          vertexDetailsQuery({ vertexId: id }, explorer)
        )
      )
  );
  const edgeResults = await Promise.allSettled(
    edges
      .values()
      .map(id =>
        queryClient.ensureQueryData(edgeDetailsQuery({ edgeId: id }, explorer))
      )
  );

  const vertexDetails = vertexResults
    .filter(result => result.status === "fulfilled")
    .map(result => result.value.vertex)
    .filter(v => v != null);
  const edgeDetails = edgeResults
    .filter(result => result.status === "fulfilled")
    .map(result => result.value.edge)
    .filter(e => e != null);

  const countOfVertexErrors = vertexResults.reduce((sum, item) => {
    return sum + (item.status === "rejected" ? 1 : 0);
  }, 0);
  const countOfEdgeErrors = edgeResults.reduce((sum, item) => {
    return sum + (item.status === "rejected" ? 1 : 0);
  }, 0);

  const countOfVertexNotFound = vertexResults.reduce((sum, item) => {
    return (
      sum + (item.status === "fulfilled" && item.value.vertex == null ? 1 : 0)
    );
  }, 0);
  const countOfEdgeNotFound = edgeResults.reduce((sum, item) => {
    return (
      sum + (item.status === "fulfilled" && item.value.edge == null ? 1 : 0)
    );
  }, 0);

  return {
    entities: {
      vertices: vertexDetails,
      edges: edgeDetails,
    },
    counts: {
      notFound: {
        vertices: countOfVertexNotFound,
        edges: countOfEdgeNotFound,
        total: countOfVertexNotFound + countOfEdgeNotFound,
      },
      errors: {
        vertices: countOfVertexErrors,
        edges: countOfEdgeErrors,
        total: countOfVertexErrors + countOfEdgeErrors,
      },
    },
  };
}