workspace-tools 0.20.0 → 0.21.0

package/CHANGELOG.json

@@ -2,7 +2,22 @@
   "name": "workspace-tools",
   "entries": [
     {
-      "date": "Thu, 23 Jun 2022 20:24:10 GMT",
+      "date": "Fri, 01 Jul 2022 14:55:58 GMT",
+      "tag": "workspace-tools_v0.21.0",
+      "version": "0.21.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "ken@gizzar.com",
+            "package": "workspace-tools",
+            "comment": "adds a package graph implementation",
+            "commit": "28ba85b087e3e3bb8715ea637563793fbb97b069"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 23 Jun 2022 20:24:15 GMT",
       "tag": "workspace-tools_v0.20.0",
       "version": "0.20.0",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,20 @@
 # Change Log - workspace-tools
 
-This log was last generated on Thu, 23 Jun 2022 20:24:10 GMT and should not be manually modified.
+This log was last generated on Fri, 01 Jul 2022 14:55:58 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.21.0
+
+Fri, 01 Jul 2022 14:55:58 GMT
+
+### Minor changes
+
+- adds a package graph implementation (ken@gizzar.com)
+
 ## 0.20.0
 
-Thu, 23 Jun 2022 20:24:10 GMT
+Thu, 23 Jun 2022 20:24:15 GMT
 
 ### Minor changes
 

package/lib/__tests__/graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/graph.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graph_1 = require("../graph");
+describe("createPackageGraph", () => {
+    it("can get linear dependencies", () => {
+        const allPackages = {
+            a: stubPackage("a", ["b"]),
+            b: stubPackage("b", ["c"]),
+            c: stubPackage("c"),
+        };
+        const actual = (0, graph_1.createPackageGraph)(allPackages, { namePatterns: ["a"], includeDependencies: true });
+        expect(actual).toMatchInlineSnapshot(`
+      Object {
+        "dependencies": Array [
+          Object {
+            "dependency": "b",
+            "name": "a",
+          },
+          Object {
+            "dependency": "c",
+            "name": "b",
+          },
+        ],
+        "packages": Array [
+          "a",
+          "b",
+          "c",
+        ],
+      }
+    `);
+    });
+    it("can represent a graph with some nodes with no edges", () => {
+        const allPackages = {
+            a: stubPackage("a"),
+            b: stubPackage("b"),
+            c: stubPackage("c"),
+        };
+        const actual = (0, graph_1.createPackageGraph)(allPackages);
+        expect(actual).toMatchInlineSnapshot(`
+      Object {
+        "dependencies": Array [],
+        "packages": Array [
+          "c",
+          "b",
+          "a",
+        ],
+      }
+    `);
+    });
+    it("can get linear dependents", () => {
+        const allPackages = {
+            a: stubPackage("a", ["b"]),
+            b: stubPackage("b", ["c"]),
+            c: stubPackage("c"),
+        };
+        const actual = (0, graph_1.createPackageGraph)(allPackages, { namePatterns: ["c"], includeDependents: true });
+        expect(actual).toMatchInlineSnapshot(`
+      Object {
+        "dependencies": Array [
+          Object {
+            "dependency": "c",
+            "name": "b",
+          },
+          Object {
+            "dependency": "b",
+            "name": "a",
+          },
+        ],
+        "packages": Array [
+          "c",
+          "b",
+          "a",
+        ],
+      }
+    `);
+    });
+    it("will handle circular dependencies", () => {
+        const allPackages = {
+            a: stubPackage("a", ["b"]),
+            b: stubPackage("b", ["c"]),
+            c: stubPackage("c", ["a"]),
+        };
+        const actual = (0, graph_1.createPackageGraph)(allPackages, { namePatterns: ["a"], includeDependencies: true });
+        expect(actual).toMatchInlineSnapshot(`
+      Object {
+        "dependencies": Array [
+          Object {
+            "dependency": "b",
+            "name": "a",
+          },
+          Object {
+            "dependency": "c",
+            "name": "b",
+          },
+          Object {
+            "dependency": "a",
+            "name": "c",
+          },
+        ],
+        "packages": Array [
+          "a",
+          "b",
+          "c",
+        ],
+      }
+    `);
+    });
+});
+function stubPackage(name, deps = []) {
+    return {
+        name,
+        packageJsonPath: `packages/${name}`,
+        version: "1.0",
+        dependencies: deps.reduce((depMap, dep) => (Object.assign(Object.assign({}, depMap), { [dep]: "*" })), {}),
+        devDependencies: {},
+    };
+}

package/lib/createDependencyMap.d.ts

@@ -0,0 +1,9 @@
+import { PackageInfos } from "./types/PackageInfo";
+export interface DependencyMap {
+    dependencies: Map<string, Set<string>>;
+    dependents: Map<string, Set<string>>;
+}
+export declare function createDependencyMap(packages: PackageInfos): {
+    dependencies: Map<string, Set<string>>;
+    dependents: Map<string, Set<string>>;
+};

package/lib/createDependencyMap.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencyMap = void 0;
+// @internal
+function createDependencyMap(packages) {
+    const map = {
+        dependencies: new Map(),
+        dependents: new Map(),
+    };
+    for (const [pkg, info] of Object.entries(packages)) {
+        const deps = Object.keys(Object.assign(Object.assign({}, info.dependencies), info.devDependencies));
+        for (const dep of deps) {
+            if (!map.dependencies.has(pkg)) {
+                map.dependencies.set(pkg, new Set());
+            }
+            map.dependencies.get(pkg).add(dep);
+            if (!map.dependents.has(dep)) {
+                map.dependents.set(dep, new Set());
+            }
+            map.dependents.get(dep).add(pkg);
+        }
+    }
+    return map;
+}
+exports.createDependencyMap = createDependencyMap;

package/lib/dependencies.d.ts

@@ -1,6 +1,8 @@
 import { PackageInfo, PackageInfos } from "./types/PackageInfo";
 export declare function getDependentMap(packages: PackageInfos): Map<string, Set<string>>;
 /**
+ * @deprecated Do not use
+ *
  * for a package graph of a->b->c (where b depends on a), transitive consumers of a are b & c and their consumers (or what are the consequences of a)
  * @param targets
  * @param packages
@@ -8,11 +10,16 @@ export declare function getDependentMap(packages: PackageInfos): Map<string, Set
  */
 export declare function getTransitiveConsumers(targets: string[], packages: PackageInfos, scope?: string[]): string[];
 /**
+ * @deprecated Do not use
+ *
  * for a package graph of a->b->c (where b depends on a), transitive providers of c are a & b and their providers (or what is needed to satisfy c)
  * @param targets
  * @param packages
  */
 export declare function getTransitiveProviders(targets: string[], packages: PackageInfos): string[];
+/** @deprecated Do not use */
 export declare const getTransitiveDependencies: typeof getTransitiveProviders;
+/** @deprecated Do not use */
 export declare const getTransitiveDependents: typeof getTransitiveConsumers;
+/** @deprecated Do not use */
 export declare function getInternalDeps(info: PackageInfo, packages: PackageInfos): string[];

package/lib/dependencies.js

@@ -49,6 +49,8 @@ function getDependentMap(packages) {
 }
 exports.getDependentMap = getDependentMap;
 /**
+ * @deprecated Do not use
+ *
  * for a package graph of a->b->c (where b depends on a), transitive consumers of a are b & c and their consumers (or what are the consequences of a)
  * @param targets
  * @param packages
@@ -73,6 +75,8 @@ function getTransitiveConsumers(targets, packages, scope = []) {
 }
 exports.getTransitiveConsumers = getTransitiveConsumers;
 /**
+ * @deprecated Do not use
+ *
  * for a package graph of a->b->c (where b depends on a), transitive providers of c are a & b and their providers (or what is needed to satisfy c)
  * @param targets
  * @param packages
@@ -95,10 +99,11 @@ function getTransitiveProviders(targets, packages) {
     return [...visited].filter((pkg) => !targets.includes(pkg));
 }
 exports.getTransitiveProviders = getTransitiveProviders;
-// package dependencies = getting transitive providers
+/** @deprecated Do not use */
 exports.getTransitiveDependencies = getTransitiveProviders;
-// package dependents = getting transitive consumers
+/** @deprecated Do not use */
 exports.getTransitiveDependents = getTransitiveConsumers;
+/** @deprecated Do not use */
 function getInternalDeps(info, packages) {
     const deps = Object.keys(Object.assign(Object.assign({}, info.dependencies), info.devDependencies));
     return Object.keys(packages).filter((pkg) => deps.includes(pkg));

package/lib/graph.d.ts

@@ -1,6 +1,8 @@
-import { PackageInfos } from "./types/PackageInfo";
-export declare function getPackageGraph(packages: PackageInfos): [string, string][];
-/**
- * @internal resets the graph cache for internal testing purpose only
- */
-export declare function _resetGraphCache(): void;
+import type { PackageInfos } from "./types/PackageInfo";
+import type { PackageGraph } from "./types/PackageGraph";
+export interface PackageGraphScope {
+    namePatterns?: string[];
+    includeDependencies?: boolean;
+    includeDependents?: boolean;
+}
+export declare function createPackageGraph(packages: PackageInfos, scope?: PackageGraphScope): PackageGraph;

package/lib/graph.js

@@ -1,27 +1,61 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._resetGraphCache = exports.getPackageGraph = void 0;
-const dependencies_1 = require("./dependencies");
-const graphCache = new Map();
-function getPackageGraph(packages) {
-    if (graphCache.has(packages)) {
-        return graphCache.get(packages);
-    }
+exports.createPackageGraph = void 0;
+const createDependencyMap_1 = require("./createDependencyMap");
+const multimatch_1 = __importDefault(require("multimatch"));
+function createPackageGraph(packages, scope = {}) {
+    const dependencyMap = (0, createDependencyMap_1.createDependencyMap)(packages);
+    const packageSet = new Set();
     const edges = [];
-    for (const [pkg, info] of Object.entries(packages)) {
-        const deps = (0, dependencies_1.getInternalDeps)(info, packages);
-        for (const dep of deps) {
-            edges.push([dep, pkg]);
+    const visitor = (pkg, dependencies, dependents) => {
+        packageSet.add(pkg);
+        if (scope.includeDependencies && dependencies) {
+            for (const dep of dependencies) {
+                edges.push({ name: pkg, dependency: dep });
+                packageSet.add(dep);
+            }
         }
-    }
-    graphCache.set(packages, edges);
-    return edges;
+        if (scope.includeDependents && dependents) {
+            for (const dep of dependents) {
+                edges.push({ name: dep, dependency: pkg });
+                packageSet.add(dep);
+            }
+        }
+    };
+    visitPackageGraph(packages, dependencyMap, visitor, scope);
+    return { packages: [...packageSet], dependencies: edges };
 }
-exports.getPackageGraph = getPackageGraph;
-/**
- * @internal resets the graph cache for internal testing purpose only
- */
-function _resetGraphCache() {
-    graphCache.clear();
+exports.createPackageGraph = createPackageGraph;
+function visitPackageGraph(packages, dependencyMap, visitor, scope) {
+    var _a, _b;
+    const visited = new Set();
+    const packageNames = Object.keys(packages);
+    const stack = scope && scope.namePatterns ? (0, multimatch_1.default)(packageNames, scope.namePatterns) : packageNames;
+    while (stack.length > 0) {
+        const pkg = stack.pop();
+        if (visited.has(pkg)) {
+            continue;
+        }
+        const nextPkgs = [];
+        let dependencies = [];
+        let dependents = [];
+        if (scope === null || scope === void 0 ? void 0 : scope.includeDependencies) {
+            dependencies = [...(_a = dependencyMap.dependencies.get(pkg)) !== null && _a !== void 0 ? _a : []];
+            nextPkgs.push(...dependencies);
+        }
+        if (scope === null || scope === void 0 ? void 0 : scope.includeDependents) {
+            dependents = [...(_b = dependencyMap.dependents.get(pkg)) !== null && _b !== void 0 ? _b : []];
+            nextPkgs.push(...dependents);
+        }
+        visitor(pkg, dependencies, dependents);
+        visited.add(pkg);
+        if (nextPkgs.length > 0) {
+            for (const nextPkg of nextPkgs) {
+                stack.push(nextPkg);
+            }
+        }
+    }
 }
-exports._resetGraphCache = _resetGraphCache;

package/lib/types/PackageGraph.d.ts

@@ -0,0 +1,14 @@
+/** A package graph edge that defines a single package name and one of its dependency */
+export interface PackageDependency {
+    name: string;
+    dependency: string;
+}
+/** The graph is defined by as a list of package names as nodes, and a list of PackageDependency as edges*/
+export interface PackageGraph {
+    packages: string[];
+    dependencies: PackageDependency[];
+}
+/** Package graph visitor is called as it visits every package in dependency order */
+export interface PackageGraphVisitor {
+    (pkg: string, dependencies: string[], dependents: string[]): void;
+}

package/lib/types/PackageGraph.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workspace-tools",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -38,6 +38,7 @@
     "@types/yarnpkg__lockfile": "^1.1.3",
     "beachball": "^2.17.0",
     "jest": "^25.0.0",
+    "prettier": "^2.7.1",
     "tmp": "^0.2.1",
     "ts-jest": "^25.5.1",
     "typedoc": "^0.22.15",