Add types for BundleGraph nodes

packages/bundlers/default/src/DefaultBundler.js

@@ -166,6 +166,7 @@ export default new Bundler({
       const dumpGraphToGraphViz = require('@parcel/utils/src/dumpGraphToGraphViz')
         .default;
       dumpGraphToGraphViz(assetGraph, 'BundlerInputAssetGraph');
+      // $FlowFixMe
       dumpGraphToGraphViz(bundleGraph, 'BundleGraph');
       bundleGraph.traverseBundles(bundle => {
         dumpGraphToGraphViz(bundle.assetGraph, `${bundle.id}`);

packages/core/core/src/BundleGraph.js

@@ -2,18 +2,21 @@
 import type {
   Asset,
   Bundle,
+  BundleGraph as IBundleGraph,
+  BundleGraphNode,
   BundleGroup,
-  GraphTraversalCallback,
-  Node
+  BundleNode,
+  GraphTraversalCallback
 } from '@parcel/types';
-import type AssetGraph from './AssetGraph';
 
+import invariant from 'assert';
 import Graph from './Graph';
 
 const getBundleGroupId = (bundleGroup: BundleGroup) =>
   'bundle_group:' + bundleGroup.entryAssetId;
 
-export default class BundleGraph extends Graph<Node> {
+export default class BundleGraph extends Graph<BundleGraphNode>
+  implements IBundleGraph {
   constructor() {
     super();
     this.setRootNode({
@@ -56,7 +59,7 @@ export default class BundleGraph extends Graph<Node> {
     }
 
     let bundleGroupId = getBundleGroupId(bundleGroup);
-    let bundleNode = {
+    let bundleNode: BundleNode = {
       id: bundle.id,
       type: 'bundle',
       value: bundle
@@ -73,11 +76,11 @@ export default class BundleGraph extends Graph<Node> {
       // already created bundles in the bundle graph. This can happen when two
       // bundles point to the same dependency, which has an async import.
       if (node.type === 'bundle_group') {
-        // TODO: fix the AssetGraph interface so we don't need to do this
-        let assetGraph: AssetGraph = (bundle.assetGraph: any);
+        let {assetGraph} = bundle;
         let bundleGroup: BundleGroup = node.value;
         let depNode = assetGraph.getNode(bundleGroup.dependency.id);
         if (depNode && !assetGraph.hasNode(node.id)) {
+          // $FlowFixMe Merging a graph of a subtype into a graph of the supertype
           assetGraph.merge(this.getSubGraph(node));
           assetGraph.replaceNodesConnectedTo(depNode, [node]);
           this.addEdge({from: bundle.id, to: node.id});
@@ -105,7 +108,10 @@ export default class BundleGraph extends Graph<Node> {
       return [];
     }
 
-    return this.getNodesConnectedFrom(node).map(node => node.value);
+    return this.getNodesConnectedFrom(node).map(node => {
+      invariant(node.type === 'bundle');
+      return node.value;
+    });
   }
 
   getBundleGroups(bundle: Bundle): Array<BundleGroup> {
@@ -114,7 +120,10 @@ export default class BundleGraph extends Graph<Node> {
       return [];
     }
 
-    return this.getNodesConnectedTo(node).map(node => node.value);
+    return this.getNodesConnectedTo(node).map(node => {
+      invariant(node.type === 'bundle_group');
+      return node.value;
+    });
   }
 
   isAssetInAncestorBundle(bundle: Bundle, asset: Asset): boolean {
@@ -145,12 +154,15 @@ export default class BundleGraph extends Graph<Node> {
   }
 
   findBundlesWithAsset(asset: Asset): Array<Bundle> {
-    return Array.from(this.nodes.values())
-      .filter(
-        node =>
-          node.type === 'bundle' && node.value.assetGraph.hasNode(asset.id)
-      )
-      .map(node => node.value);
+    return (
+      Array.from(this.nodes.values())
+        .filter(
+          node =>
+            node.type === 'bundle' && node.value.assetGraph.hasNode(asset.id)
+        )
+        // $FlowFixMe Flow can't refine on filter https://github.com/facebook/flow/issues/1414
+        .map(node => node.value)
+    );
   }
 
   traverseBundles<TContext>(

packages/core/core/src/Graph.js

@@ -5,20 +5,19 @@ import type {
   Node,
   NodeId,
   GraphTraversalCallback,
+  GraphUpdates,
   TraversalActions,
   Graph as IGraph
 } from '@parcel/types';
 
-type GraphUpdates<TNode> = {|
-  added: Graph<TNode>,
-  removed: Graph<TNode>
-|};
+import nullthrows from 'nullthrows';
 
 type GraphOpts<TNode> = {|
   nodes?: Array<[NodeId, TNode]>,
   edges?: Array<Edge>,
   rootNodeId?: ?NodeId
 |};
+
 export default class Graph<TNode: Node> implements IGraph<TNode> {
   nodes: Map<NodeId, TNode>;
   edges: Set<Edge>;
@@ -87,10 +86,7 @@ export default class Graph<TNode: Node> implements IGraph<TNode> {
 
   getNodesConnectedFrom(node: TNode): Array<TNode> {
     let edges = Array.from(this.edges).filter(edge => edge.from === node.id);
-    return edges.map(edge => {
-      // $FlowFixMe
-      return this.nodes.get(edge.to);
-    });
+    return edges.map(edge => nullthrows(this.nodes.get(edge.to)));
   }
 
   merge(graph: IGraph<TNode>): void {

packages/core/types/index.js

@@ -299,6 +299,12 @@ export type AssetReferenceNode = {|
   value: Asset
 |};
 
+export type BundleNode = {|
+  id: string,
+  type: 'bundle',
+  value: Bundle
+|};
+
 export type BundleGroupNode = {|
   id: string,
   type: 'bundle_group',
@@ -320,24 +326,58 @@ export type TransformerRequestNode = {|
   value: TransformerRequest
 |};
 
+export type BundleGroup = {
+  dependency: Dependency,
+  target: ?Target,
+  entryAssetId: string
+};
+
+export type Bundle = {|
+  id: string,
+  type: string,
+  assetGraph: AssetGraph,
+  env: Environment,
+  isEntry?: boolean,
+  target?: Target,
+  filePath?: FilePath
+|};
+
 export type AssetGraphNode =
   | AssetNode
   | AssetReferenceNode
-  | BundleGroupNode
   | DependencyNode
   | FileNode
   | RootNode
-  | TransformerRequestNode;
+  | TransformerRequestNode
+  // Bundle graphs are merged into asset graphs during the bundling phase
+  | BundleGraphNode;
+
+export type BundleGraphNode = BundleNode | BundleGroupNode | RootNode;
 
 export type Edge = {|
   from: NodeId,
   to: NodeId
 |};
 
+export type GraphUpdates<TNode> = {|
+  added: Graph<TNode>,
+  removed: Graph<TNode>
+|};
+
 export interface Graph<TNode: Node> {
-  nodes: Map<string, TNode>;
   edges: Set<Edge>;
+  nodes: Map<string, TNode>;
+  addEdge(edge: Edge): Edge;
+  addNode(node: TNode): TNode;
+  getNode(id: string): ?TNode;
+  getNodesConnectedFrom(node: TNode): Array<TNode>;
+  getRootNode(): ?TNode;
+  hasNode(id: string): boolean;
   merge(graph: Graph<TNode>): void;
+  replaceNodesConnectedTo(
+    fromNode: TNode,
+    toNodes: Array<TNode>
+  ): GraphUpdates<TNode>;
   traverse<TContext>(
     visit: GraphTraversalCallback<TNode, TContext>,
     startNode: ?TNode
@@ -346,40 +386,24 @@ export interface Graph<TNode: Node> {
 
 // TODO: what do we want to expose here?
 export interface AssetGraph extends Graph<AssetGraphNode> {
-  traverseAssets(
-    visit: GraphTraversalCallback<Asset, AssetGraphNode>
-  ): ?AssetGraphNode;
   createBundle(asset: Asset): Bundle;
-  getTotalSize(asset?: Asset): number;
-  getEntryAssets(): Array<Asset>;
-  removeAsset(asset: Asset): void;
   getDependencies(asset: Asset): Array<Dependency>;
   getDependencyResolution(dependency: Dependency): ?Asset;
+  getEntryAssets(): Array<Asset>;
+  getTotalSize(asset?: Asset): number;
+  removeAsset(asset: Asset): void;
+  traverseAssets(
+    visit: GraphTraversalCallback<Asset, AssetGraphNode>
+  ): ?AssetGraphNode;
 }
 
-export type BundleGroup = {
-  dependency: Dependency,
-  target: ?Target,
-  entryAssetId: string
-};
-
-export type Bundle = {|
-  id: string,
-  type: string,
-  assetGraph: AssetGraph,
-  env: Environment,
-  isEntry?: boolean,
-  target?: Target,
-  filePath?: FilePath
-|};
-
-export interface BundleGraph extends Graph<Node> {
-  addBundleGroup(parentBundle: ?Bundle, bundleGroup: BundleGroup): void;
+export interface BundleGraph extends Graph<BundleGraphNode> {
   addBundle(bundleGroup: BundleGroup, bundle: Bundle): void;
-  isAssetInAncestorBundle(bundle: Bundle, asset: Asset): boolean;
+  addBundleGroup(parentBundle: ?Bundle, bundleGroup: BundleGroup): void;
   findBundlesWithAsset(asset: Asset): Array<Bundle>;
-  getBundles(bundleGroup: BundleGroup): Array<Bundle>;
   getBundleGroups(bundle: Bundle): Array<BundleGroup>;
+  getBundles(bundleGroup: BundleGroup): Array<Bundle>;
+  isAssetInAncestorBundle(bundle: Bundle, asset: Asset): boolean;
   traverseBundles<TContext>(
     visit: GraphTraversalCallback<Bundle, TContext>
   ): ?TContext;

packages/core/utils/package.json

@@ -24,6 +24,7 @@
     "@parcel/workers": "^1.10.3"
   },
   "devDependencies": {
-    "@babel/plugin-transform-flow-strip-types": "^7.2.0"
+    "@babel/plugin-transform-flow-strip-types": "^7.2.0",
+    "nullthrows": "^1.1.1"
   }
 }

packages/core/utils/src/dumpGraphToGraphViz.js

@@ -1,31 +1,39 @@
 // @flow
 
-import type {Environment, Graph, Node} from '@parcel/types';
+import type {
+  Environment,
+  Graph,
+  BundleGraphNode,
+  AssetGraphNode
+} from '@parcel/types';
 
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
 import graphviz from 'graphviz';
 import tempy from 'tempy';
 import path from 'path';
 
+const COLORS = {
+  root: 'gray',
+  asset: 'green',
+  dependency: 'orange',
+  transformer_request: 'cyan',
+  file: 'gray',
+  default: 'white'
+};
+
 export default async function dumpGraphToGraphViz(
-  graph: Graph<Node>,
+  graph: Graph<AssetGraphNode | BundleGraphNode>,
   name: string
 ): Promise<void> {
   let g = graphviz.digraph('G');
 
-  let colors = {
-    root: 'gray',
-    asset: 'green',
-    dependency: 'orange',
-    transformer_request: 'cyan',
-    file: 'gray',
-    default: 'white'
-  };
-
-  let nodes: Array<Node> = Array.from(graph.nodes.values());
+  let nodes = Array.from(graph.nodes.values());
   for (let node of nodes) {
     let n = g.addNode(node.id);
 
-    n.set('color', colors[node.type || 'default']);
+    // $FlowFixMe default is fine. Not every type needs to be in the map.
+    n.set('color', COLORS[node.type || 'default']);
     n.set('shape', 'box');
     n.set('style', 'filled');
 
@@ -49,10 +57,11 @@ export default async function dumpGraphToGraphViz(
         ` (${getEnvDescription(node.value.env)})`;
     } else if (node.type === 'bundle') {
       let rootAssets = node.value.assetGraph.getNodesConnectedFrom(
-        node.value.assetGraph.getRootNode()
+        nullthrows(node.value.assetGraph.getRootNode())
       );
       label += rootAssets
         .map(asset => {
+          invariant(asset.type === 'asset');
           let parts = asset.value.filePath.split(path.sep);
           let index = parts.lastIndexOf('node_modules');
           if (index >= 0) {

packages/runtimes/js/src/JSRuntime.js

@@ -1,9 +1,10 @@
 // @flow
 
-import type {BundleGroup} from '@parcel/types';
+import type {BundleGroupNode} from '@parcel/types';
 
-import {Runtime} from '@parcel/plugin';
+import invariant from 'assert';
 import path from 'path';
+import {Runtime} from '@parcel/plugin';
 
 const LOADERS = {
   browser: {
@@ -40,7 +41,7 @@ export default new Runtime({
     }
 
     // $FlowFixMe Flow can't refine on filter https://github.com/facebook/flow/issues/1414
-    let bundleGroups: Array<BundleGroup> = Array.from(
+    let bundleGroups: Array<BundleGroupNode> = Array.from(
       bundle.assetGraph.nodes.values()
     ).filter(n => n.type === 'bundle_group');
 
@@ -51,9 +52,11 @@ export default new Runtime({
       }
 
       let bundles = bundle.assetGraph
-        // $FlowFixMe - define a better asset graph interface
         .getNodesConnectedFrom(bundleGroup)
-        .map(node => node.value)
+        .map(node => {
+          invariant(node.type === 'bundle');
+          return node.value;
+        })
         .sort(
           bundle =>
             bundle.assetGraph.hasNode(bundleGroup.value.entryAssetId) ? 1 : -1