feat: .getDepPkgs() to get all pkgs except root

Author: michael-go

README.md

@@ -51,14 +51,21 @@ export interface DepGraph {
     name: string;
     version: string | null;
   };
+  // all unique packages in the graph (including root package)
   getPkgs(): Array<{
     name: string;
     version: string | null;
   }>;
+  // all unique packages in the graph, except the root package
+  getDepPkgs(): Array<{
+    name: string;
+    version: string | null;
+  }>;
   pkgPathsToRoot(pkg: Pkg): Array<Array<{
     name: string;
     version: string | null;
   }>>;
+  countPathsToRoot(pkg: Pkg): number;
   toJSON(): DepGraphData;
   equals(other: DepGraph, options?: { compareRoot?: boolean }): boolean;
 }

src/core/dep-graph.ts

@@ -23,6 +23,7 @@ class DepGraphImpl implements types.DepGraphInternal {
   private _pkgNodes: { [pkgId: string]: Set<string> };
 
   private _pkgList: types.PkgInfo[];
+  private _depPkgsList: types.PkgInfo[];
 
   private _graph: graphlib.Graph;
   private _pkgManager: types.PkgManager;
@@ -50,6 +51,8 @@ class DepGraphImpl implements types.DepGraphInternal {
     this._rootPkgId = (graph.node(rootNodeId) as Node).pkgId;
 
     this._pkgList = _.values(pkgs);
+    this._depPkgsList = this._pkgList
+      .filter((pkg) => pkg !== this.rootPkg);
   }
 
   get pkgManager() {
@@ -68,6 +71,10 @@ class DepGraphImpl implements types.DepGraphInternal {
     return this._pkgList;
   }
 
+  public getDepPkgs(): types.PkgInfo[] {
+    return this._depPkgsList;
+  }
+
   public getNode(nodeId: string): types.NodeInfo {
     return this.getGraphNode(nodeId).info || {};
   }

src/core/types.ts

@@ -84,6 +84,7 @@ export interface DepGraph {
   readonly pkgManager: PkgManager;
   readonly rootPkg: PkgInfo;
   getPkgs(): PkgInfo[];
+  getDepPkgs(): PkgInfo[];
   toJSON(): DepGraphData;
   pkgPathsToRoot(pkg: Pkg): PkgInfo[][];
   countPathsToRoot(pkg: Pkg): number;

test/core/builder.test.ts

@@ -9,5 +9,6 @@ describe('empty graph', () => {
     expect(depGraph.pkgManager.name).toEqual('pip');
     expect(depGraph.rootPkg).toHaveProperty('name');
     expect(depGraph.getPkgs()).toHaveLength(1);
+    expect(depGraph.getDepPkgs()).toHaveLength(0);
   });
 });

test/core/create-from-json.test.ts

@@ -16,7 +16,7 @@ describe('fromJSON simple', () => {
 
   });
 
-  test('getPkgs', async () => {
+  test('getPkgs()', async () => {
     expect(graph.getPkgs().sort(helpers.depSort)).toEqual([
       { name: 'a', version: '1.0.0' },
       { name: 'b', version: '1.0.0' },
@@ -28,6 +28,17 @@ describe('fromJSON simple', () => {
     ].sort(helpers.depSort));
   });
 
+  test('getDepPkgs()', async () => {
+    expect(graph.getDepPkgs().sort(helpers.depSort)).toEqual([
+      { name: 'a', version: '1.0.0' },
+      { name: 'b', version: '1.0.0' },
+      { name: 'c', version: '1.0.0' },
+      { name: 'd', version: '0.0.1' },
+      { name: 'd', version: '0.0.2' },
+      { name: 'e', version: '5.0.0' },
+    ].sort(helpers.depSort));
+  });
+
   test('getPathsToRoot', async () => {
     expect(graph.pkgPathsToRoot({ name: 'd', version: '0.0.1' })).toHaveLength(1);
     expect(graph.countPathsToRoot({ name: 'd', version: '0.0.1' })).toBe(1);
@@ -133,6 +144,9 @@ test('fromJSON a pkg and a node share same id', async () => {
     { name: 'toor', version: '1.0.0' },
     { name: 'foo', version: '2' },
   ].sort());
+  expect(depGraph.getDepPkgs()).toEqual([
+    { name: 'foo', version: '2' },
+  ]);
 
   expect(depGraph.pkgPathsToRoot({ name: 'foo', version: '2' })).toEqual([[
     { name: 'foo', version: '2' },
@@ -166,6 +180,7 @@ test('fromJSON no deps', async () => {
 
   expect(depGraph.rootPkg).toEqual({ name: 'toor', version: '1.0.0' });
   expect(depGraph.getPkgs()).toEqual([{ name: 'toor', version: '1.0.0' }]);
+  expect(depGraph.getDepPkgs()).toEqual([]);
   expect(depGraph.pkgManager.name).toEqual('pip');
 });
 
@@ -176,6 +191,7 @@ test('fromJSON inside schemaVersion', async () => {
 
   const depGraph = depGraphLib.createFromJSON(graphJson);
   expect(depGraph.getPkgs()).toHaveLength(7);
+  expect(depGraph.getDepPkgs()).toHaveLength(6);
 });
 
 test('fromJSON too old schemaVersion', async () => {
@@ -342,6 +358,11 @@ test('fromJSON with a cycle', async () => {
     { name: 'bar', version: '3' },
     { name: 'baz', version: '4' },
   ]);
+  expect(depGraph.getDepPkgs().sort()).toEqual([
+    { name: 'foo', version: '2' },
+    { name: 'bar', version: '3' },
+    { name: 'baz', version: '4' },
+  ]);
 
   // const convertToDepTree = async () => depGraphLib.legacy.graphToDepTree(depGraph);
   // expect(convertToDepTree()).rejects.toThrow(/cycl/);
@@ -631,6 +652,9 @@ test('fromJSON root has several instances', async () => {
     {name: 'toor', version: '1.0.0'},
     {name: 'foo', version: '2'},
   ].sort());
+  expect(depGraph.getDepPkgs().sort()).toEqual([
+    {name: 'foo', version: '2'},
+  ].sort());
   expect(depGraph.countPathsToRoot({name: 'toor', version: '1.0.0'})).toBe(2);
 });
 
@@ -737,6 +761,9 @@ test('fromJSON a pkg missing version field', async () => {
     { name: 'toor', version: '1.0.0' },
     { name: 'foo', version: null },
   ]);
+  expect(depGraph.getDepPkgs().sort()).toEqual([
+    { name: 'foo', version: null },
+  ]);
 });
 
 test('fromJSON pkg-id is not name@version', async () => {

test/legacy/from-dep-tree.test.ts

@@ -38,6 +38,14 @@ describe('depTreeToGraph simple dysmorphic', () => {
       { name: 'e', version: '5.0.0' },
       { name: 'root', version: '0.0.0' },
     ].sort(helpers.depSort));
+    expect(depGraph.getDepPkgs().sort(helpers.depSort)).toEqual([
+      { name: 'a', version: '1.0.0' },
+      { name: 'b', version: '1.0.0' },
+      { name: 'c', version: '1.0.0' },
+      { name: 'd', version: '0.0.1' },
+      { name: 'd', version: '0.0.2' },
+      { name: 'e', version: '5.0.0' },
+    ].sort(helpers.depSort));
   });
 
   test('getPathsToRoot', async () => {
@@ -113,6 +121,7 @@ describe('depTreeToGraph 0 deps', () => {
     const depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'npm');
 
     expect(depGraph.getPkgs()).toHaveLength(1);
+    expect(depGraph.getDepPkgs()).toHaveLength(0);
   });
 });
 
@@ -125,6 +134,7 @@ describe('depTreeToGraph goof', () => {
     depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'npm');
 
     expect(depGraph.getPkgs()).toHaveLength(439);
+    expect(depGraph.getDepPkgs()).toHaveLength(438);
   });
 
   test('check nodes', async () => {
@@ -181,6 +191,7 @@ describe('depTreeToGraph with pkg that that misses a version', () => {
     const depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'npm');
 
     expect(depGraph.getPkgs()).toHaveLength(3);
+    expect(depGraph.getDepPkgs()).toHaveLength(2);
 
     const depGraphInternal = depGraph as types.DepGraphInternal;
     expect(depGraphInternal.getPkgNodeIds({name: 'bar'} as any)).toEqual(['bar@']);
@@ -210,13 +221,15 @@ describe('depTreeToGraph with funky pipes in the version', () => {
   test('create', async () => {
     depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'composer');
     expect(depGraph.getPkgs()).toHaveLength(4);
+    expect(depGraph.getDepPkgs()).toHaveLength(3);
   });
 
   test('convert to JSON and back', async () => {
     const graphJson = depGraph.toJSON();
     const restoredGraph = await depGraphLib.createFromJSON(graphJson);
 
     expect(restoredGraph.getPkgs().sort()).toEqual(depGraph.getPkgs().sort());
+    expect(restoredGraph.getDepPkgs().sort()).toEqual(depGraph.getDepPkgs().sort());
   });
 });
 
@@ -243,6 +256,12 @@ describe('depTreeToGraph cycle with root', () => {
   test('create', async () => {
     depGraph = await depGraphLib.legacy.depTreeToGraph(depTree, 'composer');
     expect(depGraph.getPkgs()).toHaveLength(3);
+    // note that despite maple@3 being a dependency of bar@1,
+    //   it's still not returned, as it's the root package.
+    expect(depGraph.getDepPkgs()).toEqual([
+        {name: 'bar', version: '1'},
+        {name: 'foo', version: '2'},
+    ]);
 
     expect(depGraph.countPathsToRoot(depGraph.rootPkg)).toBe(2);
     expect(depGraph.pkgPathsToRoot(depGraph.rootPkg)).toEqual([
@@ -262,6 +281,7 @@ describe('depTreeToGraph cycle with root', () => {
     const restoredGraph = await depGraphLib.createFromJSON(graphJson);
 
     expect(restoredGraph.getPkgs().sort()).toEqual(depGraph.getPkgs().sort());
+    expect(restoredGraph.getDepPkgs().sort()).toEqual(depGraph.getDepPkgs().sort());
   });
 });
 
@@ -296,6 +316,10 @@ describe('depTreeToGraph with (invalid) null dependency', () => {
       {name: 'foo', version: '1'},
       {name: 'baz', version: '3'},
     ], 'name'));
+    expect(_.sortBy(depGraph.getDepPkgs(), 'name')).toEqual(_.sortBy([
+      {name: 'foo', version: '1'},
+      {name: 'baz', version: '3'},
+    ], 'name'));
   });
 });