lage 1.1.4 → 1.2.0

package/CHANGELOG.json

@@ -2,7 +2,22 @@
   "name": "lage",
   "entries": [
     {
-      "date": "Sat, 04 Dec 2021 00:24:05 GMT",
+      "date": "Mon, 03 Jan 2022 23:13:39 GMT",
+      "tag": "lage_v1.2.0",
+      "version": "1.2.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "mhuan13@gmail.com",
+            "package": "lage",
+            "comment": "Allow explicit parralel scheduling of transitive dependencies with ^^ prefix",
+            "commit": "c3c1c7378f5fdc1e77fbe1aad38627d5d23a8d30"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sat, 04 Dec 2021 00:24:11 GMT",
       "tag": "lage_v1.1.4",
       "version": "1.1.4",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,20 @@
 # Change Log - lage
 
-This log was last generated on Sat, 04 Dec 2021 00:24:05 GMT and should not be manually modified.
+This log was last generated on Mon, 03 Jan 2022 23:13:39 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 1.2.0
+
+Mon, 03 Jan 2022 23:13:39 GMT
+
+### Minor changes
+
+- Allow explicit parralel scheduling of transitive dependencies with ^^ prefix (mhuan13@gmail.com)
+
 ## 1.1.4
 
-Sat, 04 Dec 2021 00:24:05 GMT
+Sat, 04 Dec 2021 00:24:11 GMT
 
 ### Patches
 

package/lib/task/Pipeline.d.ts

@@ -14,6 +14,7 @@ export declare const START_TARGET_ID = "__start";
 export declare class Pipeline {
     private workspace;
     private config;
+    private cachedTransitiveTaskDependencies;
     /** Target represent a unit of work and the configuration of how to run it */
     targets: Map<string, PipelineTarget>;
     /** Target dependencies determine the run order of the targets  */
@@ -63,6 +64,12 @@ export declare class Pipeline {
      * Adds all the target dependencies to the graph
      */
     addDependencies(): void;
+    /**
+     * Gets a list of package names that are direct or indirect dependencies of rootPackageName in this.graph,
+     * and caches them on the Pipeline.
+     * @param packageName the root package to begin walking from
+     */
+    getTransitiveGraphDependencies(packageName: string): Set<string>;
     generateTargetGraph(): [string, string][];
     loadConfig(config: Config): void;
     private getTargetPriority;

package/lib/task/Pipeline.js

@@ -23,6 +23,7 @@ class Pipeline {
     constructor(workspace, config) {
         this.workspace = workspace;
         this.config = config;
+        this.cachedTransitiveTaskDependencies = new Map();
         /** Target represent a unit of work and the configuration of how to run it */
         this.targets = new Map([
             [
@@ -197,6 +198,8 @@ class Pipeline {
              * - for any deps like package#task, we simply add the singular dependency (source could be a single package or all packages)
              * - for anything that starts with a "^", we add the package-tasks according to the topological package graph
              *    NOTE: in a non-strict mode (TODO), the dependencies can come from transitive task dependencies
+             * - for anything that starts with a "^^", we add the package-tasks from the transitive dependencies in the topological
+             *    package graph.
              * - for {"pkgA#task": ["dep"]}, we interpret to add "pkgA#dep"
              * - for anything that is a string without a "^", we treat that string as the name of a task, adding all targets that way
              *    NOTE: in a non-strict mode (TODO), the dependencies can come from transitive task dependencies
@@ -210,11 +213,13 @@ class Pipeline {
                 }
                 else if (dep.startsWith("^") && packageName) {
                     // topo dep -> build: ['^build']
-                    const depTask = dep.substr(1);
+                    const [depTask, dependencySet] = dep.startsWith("^^") ?
+                        [dep.substr(2), [...this.getTransitiveGraphDependencies(packageName)]]
+                        : [dep.substr(1), this.graph[packageName].dependencies];
                     const dependencyIds = targets
                         .filter((needle) => {
                         const { task, packageName: needlePackageName } = needle;
-                        return (task === depTask && this.graph[packageName].dependencies.some((depPkg) => depPkg === needlePackageName));
+                        return (task === depTask && dependencySet.some((depPkg) => depPkg === needlePackageName));
                     })
                         .map((needle) => needle.id);
                     for (const dependencyId of dependencyIds) {
@@ -239,6 +244,44 @@ class Pipeline {
             }
         }
     }
+    /**
+     * Gets a list of package names that are direct or indirect dependencies of rootPackageName in this.graph,
+     * and caches them on the Pipeline.
+     * @param packageName the root package to begin walking from
+     */
+    getTransitiveGraphDependencies(packageName) {
+        var _a, _b;
+        const cachedResult = this.cachedTransitiveTaskDependencies.get(packageName);
+        if (cachedResult) {
+            return (cachedResult === "walk-in-progress")
+                // There is a recursive walk over this set of dependencies in progress.
+                // If we hit this case, that means that a dependency of this package depends on it.
+                //
+                // In this case we return an empty set to omit this package and it's downstream from its
+                // dependency
+                ? new Set()
+                // we already computed this for this package, return the cached result.
+                : cachedResult;
+        }
+        else {
+            // No cached result. Compute now with a recursive walk
+            // mark that we are traversing this package to prevent infinite recursion
+            // in cases of circular dependencies
+            this.cachedTransitiveTaskDependencies.set(packageName, 'walk-in-progress');
+            let immediateDependencies = (_b = (_a = this.graph[packageName]) === null || _a === void 0 ? void 0 : _a.dependencies) !== null && _b !== void 0 ? _b : [];
+            // build the set of transitive dependencies by recursively walking the
+            // immediate dependencies' dependencies.
+            let transitiveDepSet = new Set(immediateDependencies);
+            for (let immediateDependency of immediateDependencies) {
+                for (let transitiveSubDependency of this.getTransitiveGraphDependencies(immediateDependency)) {
+                    transitiveDepSet.add(transitiveSubDependency);
+                }
+            }
+            // Cache the result and return
+            this.cachedTransitiveTaskDependencies.set(packageName, transitiveDepSet);
+            return transitiveDepSet;
+        }
+    }
     generateTargetGraph() {
         const scope = (0, getPipelinePackages_1.getPipelinePackages)(this.workspace, this.config);
         const tasks = this.config.command;

package/lib/types/ConfigOptions.d.ts

@@ -6,7 +6,8 @@ import { QueueOptions } from "bullmq";
 export declare type NpmClient = "npm" | "yarn" | "pnpm";
 export interface ConfigOptions {
     /**
-     * Defines the task pipeline, prefix with "^" character to denote a topological dependency
+     * Defines the task pipeline, prefix with "^" character to denote a direct topological dependency,
+     * prefix with ^^ to denote a transitive topological dependency.
      *
      * Example:
      *
@@ -15,6 +16,8 @@ export interface ConfigOptions {
      *   build: ["^build"],
      *   test: ["build"],
      *   lint: []
+     *   bundle: ["^^transpile"],
+     *   transpile: [],
      * }
      * ```
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lage",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "A monorepo task runner",
   "repository": {
     "url": "https://github.com/microsoft/lage"