@rushstack/rush-sdk 5.101.0 → 5.102.0-pr3949.4

package/lib/logic/operations/IOperationRunner.d.ts

@@ -35,6 +35,25 @@ export interface IOperationRunnerContext {
      * Object used to track elapsed time.
      */
     stopwatch: IStopwatchResult;
+    /**
+     * The current execution status of an operation. Operations start in the 'ready' state,
+     * but can be 'blocked' if an upstream operation failed. It is 'executing' when
+     * the operation is executing. Once execution is complete, it is either 'success' or
+     * 'failure'.
+     */
+    status: OperationStatus;
+    /**
+     * Error which occurred while executing this operation, this is stored in case we need
+     * it later (for example to re-print errors at end of execution).
+     */
+    error?: Error;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
@@ -48,10 +67,6 @@ export interface IOperationRunner {
      * Name of the operation, for logging.
      */
     readonly name: string;
-    /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
-     */
-    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -66,9 +81,9 @@ export interface IOperationRunner {
      */
     warningsAreAllowed: boolean;
     /**
-     * Indicates if the output of this operation may be written to the cache
+     * Full shell command string to run by this runner.
      */
-    isCacheWriteAllowed: boolean;
+    commandToRun?: string;
     /**
      * Method to be executed for the operation.
      */

package/lib/logic/operations/OperationExecutionManager.d.ts

@@ -1,5 +1,6 @@
 import { TerminalWritable } from '@rushstack/terminal';
 import { Operation } from './Operation';
+import { OperationStatus } from './OperationStatus';
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 import { IExecutionResult } from './IOperationExecutionResult';
 export interface IOperationExecutionManagerOptions {
@@ -8,6 +9,8 @@ export interface IOperationExecutionManagerOptions {
     parallelism: number;
     changedProjectsOnly: boolean;
     destination?: TerminalWritable;
+    beforeExecuteOperation?: (operation: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
+    afterExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     beforeExecuteOperations?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
 }
@@ -27,11 +30,14 @@ export declare class OperationExecutionManager {
     private readonly _colorsNewlinesTransform;
     private readonly _streamCollator;
     private readonly _terminal;
+    private readonly _beforeExecuteOperation?;
+    private readonly _afterExecuteOperation?;
     private readonly _onOperationStatusChanged?;
     private readonly _beforeExecuteOperations?;
     private _hasAnyFailures;
     private _hasAnyNonAllowedWarnings;
     private _completedOperations;
+    private _executionQueue;
     constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
     private _streamCollator_onWriterActive;
     /**

package/lib/logic/operations/OperationExecutionRecord.d.ts

@@ -5,14 +5,19 @@ import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 import { Operation } from './Operation';
 import { Stopwatch } from '../../utilities/Stopwatch';
 import { OperationMetadataManager } from './OperationMetadataManager';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 export interface IOperationExecutionRecordContext {
     streamCollator: StreamCollator;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     debugMode: boolean;
     quietMode: boolean;
+    changedProjectsOnly: boolean;
 }
 /**
  * Internal class representing everything about executing an operation
+ *
+ * @internal
  */
 export declare class OperationExecutionRecord implements IOperationRunnerContext {
     /**
@@ -37,6 +42,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * operation to execute, the operation with the highest criticalPathLength is chosen.
      *
      * Example:
+     * ```
      *        (0) A
      *             \
      *          (1) B     C (0)         (applications)
@@ -53,6 +59,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * X has a score of 1, since the only package which depends on it is A
      * Z has a score of 2, since only X depends on it, and X has a score of 1
      * Y has a score of 2, since the chain Y->X->C is longer than Y->C
+     * ```
      *
      * The algorithm is implemented in AsyncOperationQueue.ts as calculateCriticalPathLength()
      */
@@ -69,6 +76,8 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     readonly stdioSummarizer: StdioSummarizer;
     readonly runner: IOperationRunner;
     readonly weight: number;
+    readonly associatedPhase: IPhase | undefined;
+    readonly associatedProject: RushConfigurationProject | undefined;
     readonly _operationMetadataManager: OperationMetadataManager | undefined;
     private readonly _context;
     private _collatedWriter;
@@ -76,8 +85,13 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get name(): string;
     get debugMode(): boolean;
     get quietMode(): boolean;
+    get changedProjectsOnly(): boolean;
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
-    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
+    get cobuildRunnerId(): string | undefined;
+    executeAsync({ onStart, onResult }: {
+        onStart: (record: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
+        onResult: (record: OperationExecutionRecord) => Promise<void>;
+    }): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

package/lib/logic/operations/OperationMetadataManager.d.ts

@@ -16,6 +16,8 @@ export interface IOperationMetaData {
     durationInSeconds: number;
     logPath: string;
     errorLogPath: string;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the meta files of a operation.
@@ -38,7 +40,7 @@ export declare class OperationMetadataManager {
      * Example: `.rush/temp/operation/_phase_build/error.log`
      */
     get relativeFilepaths(): string[];
-    saveAsync({ durationInSeconds, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
+    saveAsync({ durationInSeconds, cobuildContextId, cobuildRunnerId, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
     tryRestoreAsync({ terminal, logPath, errorLogPath }: {
         terminal: ITerminal;
         logPath: string;

package/lib/logic/operations/OperationStateFile.d.ts

@@ -10,6 +10,8 @@ export interface IOperationStateFileOptions {
  */
 export interface IOperationStateJson {
     nonCachedDurationMs: number;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the state file of a operation.

package/lib/logic/operations/OperationStatus.d.ts

@@ -7,10 +7,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */

package/lib/logic/operations/PeriodicCallback.d.ts

@@ -0,0 +1,20 @@
+export type ICallbackFn = () => Promise<void> | void;
+export interface IPeriodicCallbackOptions {
+    interval: number;
+}
+/**
+ * A help class to run callbacks in a loop with a specified interval.
+ *
+ * @beta
+ */
+export declare class PeriodicCallback {
+    private _callbacks;
+    private _interval;
+    private _intervalId;
+    private _isRunning;
+    constructor(options: IPeriodicCallbackOptions);
+    addCallback(callback: ICallbackFn): void;
+    start(): void;
+    stop(): void;
+}
+//# sourceMappingURL=PeriodicCallback.d.ts.map

package/lib/logic/operations/PeriodicCallback.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/operations/PeriodicCallback");

package/lib/logic/operations/ProjectLogWritable.d.ts

@@ -11,6 +11,17 @@ export declare class ProjectLogWritable extends TerminalWritable {
     private _logWriter;
     private _errorLogWriter;
     constructor(project: RushConfigurationProject, terminal: CollatedTerminal, logFilenameIdentifier: string);
+    static getLogFilePaths({ project, logFilenameIdentifier, isLegacyLog }: {
+        project: RushConfigurationProject;
+        logFilenameIdentifier: string;
+        isLegacyLog?: boolean;
+    }): {
+        logPath: string;
+        errorLogPath: string;
+        relativeLogPath: string;
+        relativeErrorLogPath: string;
+    };
+    writeChunk(chunk: ITerminalChunk): void;
     protected onWriteChunk(chunk: ITerminalChunk): void;
     protected onClose(): void;
 }

package/lib/logic/operations/ShellOperationRunner.d.ts

@@ -3,20 +3,11 @@ import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 import type { RushConfiguration } from '../../api/RushConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
-import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 import type { IPhase } from '../../api/CommandLineConfiguration';
-export interface IProjectDeps {
-    files: {
-        [filePath: string]: string;
-    };
-    arguments: string;
-}
 export interface IOperationRunnerOptions {
     rushProject: RushConfigurationProject;
     rushConfiguration: RushConfiguration;
-    buildCacheConfiguration: BuildCacheConfiguration | undefined;
     commandToRun: string;
-    isIncrementalBuildAllowed: boolean;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     displayName: string;
     phase: IPhase;
@@ -32,31 +23,16 @@ export interface IOperationRunnerOptions {
  */
 export declare class ShellOperationRunner implements IOperationRunner {
     readonly name: string;
-    isCacheWriteAllowed: boolean;
-    isSkipAllowed: boolean;
     readonly reportTiming: boolean;
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
+    readonly commandToRun: string;
+    private readonly _logFilenameIdentifier;
     private readonly _rushProject;
-    private readonly _phase;
     private readonly _rushConfiguration;
-    private readonly _buildCacheConfiguration;
-    private readonly _commandName;
-    private readonly _commandToRun;
-    private readonly _isCacheReadAllowed;
-    private readonly _projectChangeAnalyzer;
-    private readonly _packageDepsFilename;
-    private readonly _logFilenameIdentifier;
-    private readonly _selectedPhases;
-    /**
-     * UNINITIALIZED === we haven't tried to initialize yet
-     * undefined === we didn't create one because the feature is not enabled
-     */
-    private _projectBuildCache;
     constructor(options: IOperationRunnerOptions);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     private _executeAsync;
-    private _tryGetProjectBuildCacheAsync;
 }
 /**
  * When running a command from the "scripts" block in package.json, if the command

package/lib/logic/versionMismatch/VersionMismatchFinder.d.ts

@@ -1,3 +1,4 @@
+import { ITerminal } from '@rushstack/node-core-library';
 import { RushConfiguration } from '../../api/RushConfiguration';
 import { VersionMismatchFinderEntity } from './VersionMismatchFinderEntity';
 export interface IVersionMismatchFinderOptions {
@@ -27,8 +28,8 @@ export declare class VersionMismatchFinder {
     private _mismatches;
     private _projects;
     constructor(projects: VersionMismatchFinderEntity[], allowedAlternativeVersions?: Map<string, ReadonlyArray<string>>);
-    static rushCheck(rushConfiguration: RushConfiguration, options?: IVersionMismatchFinderRushCheckOptions): void;
-    static ensureConsistentVersions(rushConfiguration: RushConfiguration, options?: IVersionMismatchFinderEnsureConsistentVersionsOptions): void;
+    static rushCheck(rushConfiguration: RushConfiguration, terminal: ITerminal, options?: IVersionMismatchFinderRushCheckOptions): void;
+    static ensureConsistentVersions(rushConfiguration: RushConfiguration, terminal: ITerminal, options?: IVersionMismatchFinderEnsureConsistentVersionsOptions): void;
     /**
      * Populates a version mismatch finder object given a Rush Configuration.
      * Intentionally considers preferred versions.

package/lib/pluginFramework/PhasedCommandHooks.d.ts

@@ -1,4 +1,4 @@
-import { AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } from 'tapable';
+import { AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } from 'tapable';
 import type { CommandLineParameter } from '@rushstack/ts-command-line';
 import type { BuildCacheConfiguration } from '../api/BuildCacheConfiguration';
 import type { IPhase } from '../api/CommandLineConfiguration';
@@ -6,8 +6,11 @@ import type { RushConfiguration } from '../api/RushConfiguration';
 import type { RushConfigurationProject } from '../api/RushConfigurationProject';
 import type { Operation } from '../logic/operations/Operation';
 import type { ProjectChangeAnalyzer } from '../logic/ProjectChangeAnalyzer';
-import { ITelemetryData } from '../logic/Telemetry';
-import { IExecutionResult, IOperationExecutionResult } from '../logic/operations/IOperationExecutionResult';
+import type { IExecutionResult, IOperationExecutionResult } from '../logic/operations/IOperationExecutionResult';
+import type { CobuildConfiguration } from '../api/CobuildConfiguration';
+import type { IOperationRunnerContext } from '../logic/operations/IOperationRunner';
+import type { ITelemetryData } from '../logic/Telemetry';
+import type { OperationStatus } from '../logic/operations/OperationStatus';
 /**
  * A plugin that interacts with a phased commands.
  * @alpha
@@ -27,6 +30,10 @@ export interface ICreateOperationsContext {
      * The configuration for the build cache, if the feature is enabled.
      */
     readonly buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    /**
+     * The configuration for the cobuild, if cobuild feature and build cache feature are both enabled.
+     */
+    readonly cobuildConfiguration: CobuildConfiguration | undefined;
     /**
      * The set of custom parameters for the executing command.
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
@@ -86,7 +93,10 @@ export declare class PhasedCommandHooks {
      * Hook invoked before operation start
      * Hook is series for stable output.
      */
-    readonly beforeExecuteOperations: AsyncSeriesHook<[Map<Operation, IOperationExecutionResult>]>;
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+        Map<Operation, IOperationExecutionResult>,
+        ICreateOperationsContext
+    ]>;
     /**
      * Hook invoked when operation status changed
      * Hook is series for stable output.
@@ -98,6 +108,16 @@ export declare class PhasedCommandHooks {
      * Hook is series for stable output.
      */
     readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesBailHook<[
+        IOperationRunnerContext
+    ], OperationStatus | undefined>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
     /**
      * Hook invoked after a run has finished and the command is watching for changes.
      * May be used to display additional relevant data to the user.

package/lib/pluginFramework/RushSession.d.ts

@@ -1,8 +1,10 @@
 import { ITerminalProvider } from '@rushstack/node-core-library';
-import { IBuildCacheJson } from '../api/BuildCacheConfiguration';
-import { ICloudBuildCacheProvider } from '../logic/buildCache/ICloudBuildCacheProvider';
 import { ILogger } from './logging/Logger';
 import { RushLifecycleHooks } from './RushLifeCycle';
+import type { IBuildCacheJson } from '../api/BuildCacheConfiguration';
+import type { ICloudBuildCacheProvider } from '../logic/buildCache/ICloudBuildCacheProvider';
+import type { ICobuildJson } from '../api/CobuildConfiguration';
+import type { ICobuildLockProvider } from '../logic/cobuild/ICobuildLockProvider';
 /**
  * @beta
  */
@@ -14,17 +16,24 @@ export interface IRushSessionOptions {
  * @beta
  */
 export type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider | Promise<ICloudBuildCacheProvider>;
+/**
+ * @beta
+ */
+export type CobuildLockProviderFactory = (cobuildJson: ICobuildJson) => ICobuildLockProvider | Promise<ICobuildLockProvider>;
 /**
  * @beta
  */
 export declare class RushSession {
     private readonly _options;
     private readonly _cloudBuildCacheProviderFactories;
+    private readonly _cobuildLockProviderFactories;
     readonly hooks: RushLifecycleHooks;
     constructor(options: IRushSessionOptions);
     getLogger(name: string): ILogger;
     get terminalProvider(): ITerminalProvider;
     registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
     getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+    registerCobuildLockProviderFactory(cobuildLockProviderName: string, factory: CobuildLockProviderFactory): void;
+    getCobuildLockProviderFactory(cobuildLockProviderName: string): CobuildLockProviderFactory | undefined;
 }
 //# sourceMappingURL=RushSession.d.ts.map

package/lib/utilities/NullTerminalProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ITerminalProvider } from '@rushstack/node-core-library';
+/**
+ * A terminal provider like /dev/null
+ */
+export declare class NullTerminalProvider implements ITerminalProvider {
+    supportsColor: boolean;
+    eolCharacter: string;
+    write(): void;
+}
+//# sourceMappingURL=NullTerminalProvider.d.ts.map

package/lib/utilities/NullTerminalProvider.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/NullTerminalProvider");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rushstack/rush-sdk",
-  "version": "5.101.0",
+  "version": "5.102.0-pr3949.4",
   "description": "An API for interacting with the Rush engine",
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
     "@types/node": "14.18.36",
     "@types/semver": "7.5.0",
     "@types/webpack-env": "1.18.0",
-    "@microsoft/rush-lib": "5.101.0",
+    "@microsoft/rush-lib": "5.102.0-pr3949.4",
     "@rushstack/eslint-config": "3.3.3",
     "@rushstack/heft": "0.58.2",
     "@rushstack/heft-node-rig": "2.2.22",