@lage-run/config 0.1.1

package/CHANGELOG.json

@@ -0,0 +1,26 @@
+{
+  "name": "@lage-run/config",
+  "entries": [
+    {
+      "date": "Wed, 29 Mar 2023 22:41:31 GMT",
+      "tag": "@lage-run/config_v0.1.1",
+      "version": "0.1.1",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/config",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c",
+            "comment": "moving config to its own package"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/config",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.5",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c"
+          }
+        ]
+      }
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change Log - @lage-run/config
+
+This log was last generated on Wed, 29 Mar 2023 22:41:31 GMT and should not be manually modified.
+
+<!-- Start content -->
+
+## 0.1.1
+
+Wed, 29 Mar 2023 22:41:31 GMT
+
+### Patches
+
+- moving config to its own package (kchau@microsoft.com)
+- Bump @lage-run/scheduler-types to v0.3.5

package/jest.config.js

@@ -0,0 +1 @@
+module.exports = require("monorepo-scripts/config/jest.config.js");

package/lib/getConcurrency.d.ts

@@ -0,0 +1 @@
+export declare function getConcurrency(optionsConcurrency: number | undefined, configConcurrency: number | undefined): number;

package/lib/getConcurrency.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getConcurrency", {
+    enumerable: true,
+    get: ()=>getConcurrency
+});
+const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getConcurrency(optionsConcurrency, configConcurrency) {
+    return optionsConcurrency || configConcurrency || _os.default.cpus().length - 1;
+}

package/lib/getConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigOptions } from "./types/ConfigOptions.js";
+export declare function getConfig(cwd: string): Promise<ConfigOptions>;

package/lib/getConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getConfig", {
+    enumerable: true,
+    get: ()=>getConfig
+});
+const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
+const _cosmiconfig = require("cosmiconfig");
+const _workspaceTools = require("workspace-tools");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getConfig(cwd) {
+    // Verify presence of git
+    const root = (0, _workspaceTools.getWorkspaceRoot)(cwd);
+    if (!root) {
+        throw new Error("This must be called inside a codebase that is part of a JavaScript workspace.");
+    }
+    // Search for lage.config.js file
+    const ConfigModuleName = "lage";
+    const configExplorer = await (0, _cosmiconfig.cosmiconfig)(ConfigModuleName);
+    const results = await configExplorer.search(root ?? cwd);
+    const config = results?.config;
+    return {
+        cacheOptions: config?.cacheOptions ?? {},
+        ignore: config?.ignore ?? [],
+        npmClient: config?.npmClient ?? "npm",
+        pipeline: config?.pipeline ?? {},
+        priorities: config?.priorities ?? [],
+        repoWideChanges: config?.repoWideChanges ?? [
+            "lage.config.js",
+            "package-lock.json",
+            "yarn.lock",
+            "pnpm-lock.yaml",
+            "lerna.json",
+            "rush.json"
+        ],
+        loggerOptions: config?.loggerOptions ?? {},
+        runners: config?.runners ?? {},
+        workerIdleMemoryLimit: config?.workerIdleMemoryLimit ?? _os.default.totalmem(),
+        concurrency: config?.concurrency ?? _os.default.cpus().length - 1,
+        allowNoTargetRuns: config?.allowNoTargetRuns ?? false
+    };
+}

package/lib/getMaxWorkersPerTask.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigOptions } from "./types/ConfigOptions.js";
+export declare function getMaxWorkersPerTask(pipelineConfig: ConfigOptions["pipeline"], concurrency: number): Map<string, number>;
+export declare function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask: string[]): Map<string, number>;

package/lib/getMaxWorkersPerTask.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getMaxWorkersPerTask: ()=>getMaxWorkersPerTask,
+    getMaxWorkersPerTaskFromOptions: ()=>getMaxWorkersPerTaskFromOptions
+});
+function getMaxWorkersPerTask(pipelineConfig, concurrency) {
+    const maxWorkersPerTask = new Map();
+    let generalPoolCount = 0;
+    let generatelPoolMaxWorkers = 0;
+    let dedicatedPoolCount = 0;
+    let dedicatedPoolMaxWorkers = 0;
+    for (const [task, taskConfig] of Object.entries(pipelineConfig)){
+        if (!Array.isArray(taskConfig) && !task.includes("#")) {
+            const maxWorkerOption = taskConfig.maxWorkers ?? taskConfig.options?.maxWorkers;
+            if (typeof maxWorkerOption === "undefined") {
+                generalPoolCount++;
+                continue;
+            }
+            let maxWorkers = 0;
+            if (typeof maxWorkerOption !== "number") {
+                throw new Error(`Invalid maxWorkers value: ${maxWorkerOption}`);
+            } else {
+                maxWorkers = maxWorkerOption;
+            }
+            maxWorkersPerTask.set(task, maxWorkers);
+            dedicatedPoolCount++;
+            dedicatedPoolMaxWorkers += maxWorkers;
+        }
+    }
+    if (dedicatedPoolCount > 0 && generalPoolCount > 0) {
+        const avgMaxWorkers = dedicatedPoolMaxWorkers / dedicatedPoolCount;
+        generatelPoolMaxWorkers = Math.max(1, Math.floor(avgMaxWorkers * generalPoolCount));
+    }
+    const grandTotal = dedicatedPoolMaxWorkers + generatelPoolMaxWorkers;
+    // try to adjust the maxWorkersPerTask to fit the concurrency
+    if (grandTotal > concurrency) {
+        let newTotal = 0;
+        for (const [task, maxWorkers] of maxWorkersPerTask.entries()){
+            const newMaxWorkers = Math.max(1, Math.floor(maxWorkers / grandTotal * concurrency));
+            newTotal += newMaxWorkers;
+            maxWorkersPerTask.set(task, newMaxWorkers);
+        }
+        if (newTotal > concurrency) {
+            throw new Error("Could not adjust maxWorkers per task to fit the concurrency, try reducing the maxWorkers, or increasing the --concurrency CLI argument, or separate the tasks to be run");
+        }
+    }
+    return maxWorkersPerTask;
+}
+function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask) {
+    return new Map([
+        ...maxWorkersPerTask.map((setting)=>{
+            const [task, maxWorkers] = setting.split(/[=:]/);
+            return [
+                task,
+                parseInt(maxWorkers, 10)
+            ];
+        })
+    ]);
+}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export { getConfig } from "./getConfig.js";
+export { getConcurrency } from "./getConcurrency.js";
+export { getMaxWorkersPerTask, getMaxWorkersPerTaskFromOptions } from "./getMaxWorkersPerTask.js";
+export type { PipelineDefinition } from "./types/PipelineDefinition.js";
+export type { ConfigOptions } from "./types/ConfigOptions.js";
+export type { CacheOptions } from "./types/CacheOptions.js";
+export type { LoggerOptions } from "./types/LoggerOptions.js";
+export type { Priority } from "./types/Priority.js";

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getConfig: ()=>_getConfigJs.getConfig,
+    getConcurrency: ()=>_getConcurrencyJs.getConcurrency,
+    getMaxWorkersPerTask: ()=>_getMaxWorkersPerTaskJs.getMaxWorkersPerTask,
+    getMaxWorkersPerTaskFromOptions: ()=>_getMaxWorkersPerTaskJs.getMaxWorkersPerTaskFromOptions
+});
+const _getConfigJs = require("./getConfig.js");
+const _getConcurrencyJs = require("./getConcurrency.js");
+const _getMaxWorkersPerTaskJs = require("./getMaxWorkersPerTask.js");

package/lib/types/CacheOptions.d.ts

@@ -0,0 +1,7 @@
+import type { Config as BackfillCacheOptions } from "backfill-config";
+export type CacheOptions = BackfillCacheOptions & {
+    environmentGlob: string[];
+    cacheKey: string;
+    writeRemoteCache: boolean;
+    skipLocalCache: boolean;
+};

package/lib/types/CacheOptions.js

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

package/lib/types/ConfigOptions.d.ts

@@ -0,0 +1,56 @@
+import type { CacheOptions } from "./CacheOptions.js";
+import type { Priority } from "./Priority.js";
+import type { PipelineDefinition } from "./PipelineDefinition.js";
+import type { LoggerOptions } from "./LoggerOptions.js";
+import type { TargetRunnerPickerOptions } from "@lage-run/scheduler-types";
+export type NpmClient = "npm" | "yarn" | "pnpm";
+export interface ConfigOptions {
+    /**
+     * Defines the task pipeline, prefix with "^" character to denote a direct topological dependency,
+     * prefix with ^^ to denote a transitive topological dependency.
+     *
+     * Example:
+     *
+     * ```
+     * {
+     *   build: ["^build"],
+     *   test: ["build"],
+     *   lint: []
+     *   bundle: ["^^transpile"],
+     *   transpile: [],
+     * }
+     * ```
+     */
+    pipeline: PipelineDefinition;
+    /** Backfill cache options */
+    cacheOptions: CacheOptions;
+    /** Which files to ignore when calculating scopes with --since */
+    ignore: string[];
+    /** disables --since flag when any of this list of files changed */
+    repoWideChanges: string[];
+    /** Which NPM Client to use when running npm lifecycle scripts */
+    npmClient: NpmClient;
+    /** Optional priority to set on tasks in a package to make the scheduler give priority to tasks on the critical path for high priority tasks */
+    priorities: Priority[];
+    /**
+     * Options that will be sent to all log reporters.
+     */
+    loggerOptions: LoggerOptions;
+    /**
+     * Custom runners for tasks in the pipeline. The key is the task name, and the value is a configuration describing what would be
+     * passed to the runner constructor.
+     */
+    runners: TargetRunnerPickerOptions;
+    /**
+     * Maximum worker idle memory, this would cause workers to restart if they exceed this limit. This is useful to prevent memory leaks.
+     */
+    workerIdleMemoryLimit: number;
+    /**
+     * Maximum number of concurrent tasks to run
+     */
+    concurrency: number;
+    /**
+     * Allows for no targets run
+     */
+    allowNoTargetRuns: boolean;
+}

package/lib/types/ConfigOptions.js

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

package/lib/types/LoggerOptions.d.ts

@@ -0,0 +1,15 @@
+import type { LogLevel } from "@lage-run/logger";
+export interface LoggerOptions {
+    disp?: {
+        [level: string]: string;
+    };
+    style?: {
+        [level: string]: {
+            fg?: string;
+            bg?: string;
+        };
+    };
+    levels?: {
+        [level: string]: LogLevel;
+    };
+}

package/lib/types/LoggerOptions.js

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

package/lib/types/PipelineDefinition.d.ts

@@ -0,0 +1,12 @@
+import type { TargetConfig } from "@lage-run/target-graph";
+import type { ConfigOptions } from "./ConfigOptions.js";
+export interface FactoryArgs {
+    cwd: string;
+    config: ConfigOptions;
+}
+export interface TargetConfigFactory {
+    (args: FactoryArgs): TargetConfig | TargetConfig[];
+}
+export interface PipelineDefinition {
+    [task: string]: string[] | TargetConfig;
+}

package/lib/types/PipelineDefinition.js

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

package/lib/types/Priority.d.ts

@@ -0,0 +1,8 @@
+export interface Priority {
+    /** package name, as in package.json */
+    package?: string;
+    /** task name, as listed in the `scripts` section of package.json */
+    task: string;
+    /** priority, the higher the more priority; undefined priority means lowest priority*/
+    priority: number;
+}

package/lib/types/Priority.js

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

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lage-run/config",
+  "version": "0.1.1",
+  "description": "Config management for Lage",
+  "repository": {
+    "url": "https://github.com/microsoft/lage"
+  },
+  "bin": {
+    "lage": "./bin/lage"
+  },
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "tsc -w --preserveWatchOutput",
+    "test": "jest",
+    "lint": "monorepo-scripts lint"
+  },
+  "dependencies": {
+    "@lage-run/logger": "^1.2.2",
+    "@lage-run/scheduler-types": "^0.3.5",
+    "@lage-run/target-graph": "^0.8.1",
+    "workspace-tools": "^0.30.0",
+    "cosmiconfig": "^7.0.0"
+  },
+  "devDependencies": {
+    "monorepo-scripts": "*",
+    "backfill-config": "6.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.lage2.json",
+  "compilerOptions": {
+    "outDir": "./lib"
+  },
+  "include": ["src"]
+}