nx 20.5.0 → 20.6.0-beta.0

package/src/native/index.d.ts

@@ -37,12 +37,12 @@ export declare class ImportResult {
 
 export declare class NxCache {
   cacheDirectory: string
-  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null)
+  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
   get(hash: string): CachedResult | null
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): void
-  applyRemoteCacheResults(hash: string, result: CachedResult): void
+  applyRemoteCacheResults(hash: string, result: CachedResult, outputs: Array<string>): void
   getTaskOutputsPath(hash: string): string
-  copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): void
+  copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): number
   removeOldCacheRecords(): void
   checkCacheFsInSync(): boolean
 }
@@ -112,13 +112,14 @@ export interface CachedResult {
   code: number
   terminalOutput: string
   outputsPath: string
+  size?: number
 }
 
 export declare export function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
 
 export declare export function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
 
-export declare export function copy(src: string, dest: string): void
+export declare export function copy(src: string, dest: string): number
 
 export interface DepsOutputsInput {
   dependentTasksOutputFiles: string

package/src/tasks-runner/cache.d.ts

@@ -15,6 +15,7 @@ export declare function dbCacheEnabled(nxJson?: NxJsonConfiguration): boolean;
 export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;
+    private nxJson;
     private cache;
     private remoteCache;
     private remoteCachePromise;
@@ -27,16 +28,16 @@ export declare class DbCache {
     get(task: Task): Promise<CachedResult | null>;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
-    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<number>;
     removeOldCacheRecords(): void;
     temporaryOutputPath(task: Task): string;
     private getRemoteCache;
     private _getRemoteCache;
-    private getPowerpackS3Cache;
-    private getPowerpackSharedCache;
-    private getPowerpackGcsCache;
-    private getPowerpackAzureCache;
-    private getPowerpackCache;
+    private getS3Cache;
+    private getSharedCache;
+    private getGcsCache;
+    private getAzureCache;
+    private resolveRemoteCache;
     private resolvePackage;
     private assertCacheIsValid;
 }
@@ -66,3 +67,13 @@ export declare class Cache {
     private createCacheDir;
     private createTerminalOutputsDir;
 }
+/**
+ * Converts a string representation of a max cache size to a number.
+ *
+ * e.g. '1GB' -> 1024 * 1024 * 1024
+ *      '1MB' -> 1024 * 1024
+ *      '1KB' -> 1024
+ *
+ * @param maxCacheSize Max cache size as specified in nx.json
+ */
+export declare function parseMaxCacheSize(maxCacheSize: string): number | undefined;

package/src/tasks-runner/cache.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
+exports.parseMaxCacheSize = parseMaxCacheSize;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -68,7 +69,8 @@ function getCache(options) {
 class DbCache {
     constructor(options) {
         this.options = options;
-        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
+        this.nxJson = (0, nx_json_1.readNxJson)();
+        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)(), undefined, parseMaxCacheSize(this.nxJson.maxCacheSize));
         this.isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
     }
     async init() {
@@ -91,7 +93,7 @@ class DbCache {
             // attempt remote cache
             const res = await this.remoteCache.retrieve(task.hash, this.cache.cacheDirectory);
             if (res) {
-                this.applyRemoteCacheResults(task.hash, res);
+                this.applyRemoteCacheResults(task.hash, res, task.outputs);
                 return {
                     ...res,
                     remote: true,
@@ -105,8 +107,8 @@ class DbCache {
             return null;
         }
     }
-    applyRemoteCacheResults(hash, res) {
-        return this.cache.applyRemoteCacheResults(hash, res);
+    applyRemoteCacheResults(hash, res, outputs) {
+        return this.cache.applyRemoteCacheResults(hash, res, outputs);
     }
     async put(task, terminalOutput, outputs, code) {
         return tryAndRetry(async () => {
@@ -155,26 +157,38 @@ class DbCache {
             }
         }
         else {
-            return ((await this.getPowerpackS3Cache()) ??
-                (await this.getPowerpackSharedCache()) ??
-                (await this.getPowerpackGcsCache()) ??
-                (await this.getPowerpackAzureCache()) ??
+            return ((await this.getS3Cache()) ??
+                (await this.getSharedCache()) ??
+                (await this.getGcsCache()) ??
+                (await this.getAzureCache()) ??
                 null);
         }
     }
-    getPowerpackS3Cache() {
-        return this.getPowerpackCache('@nx/powerpack-s3-cache');
-    }
-    getPowerpackSharedCache() {
-        return this.getPowerpackCache('@nx/powerpack-shared-fs-cache');
-    }
-    getPowerpackGcsCache() {
-        return this.getPowerpackCache('@nx/powerpack-gcs-cache');
-    }
-    getPowerpackAzureCache() {
-        return this.getPowerpackCache('@nx/powerpack-azure-cache');
-    }
-    async getPowerpackCache(pkg) {
+    async getS3Cache() {
+        const cache = await this.resolveRemoteCache('@nx/s3-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-s3-cache');
+    }
+    async getSharedCache() {
+        const cache = await this.resolveRemoteCache('@nx/shared-fs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-shared-fs-cache');
+    }
+    async getGcsCache() {
+        const cache = await this.resolveRemoteCache('@nx/gcs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-gcs-cache');
+    }
+    async getAzureCache() {
+        const cache = await this.resolveRemoteCache('@nx/azure-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-azure-cache');
+    }
+    async resolveRemoteCache(pkg) {
         let getRemoteCache = null;
         try {
             getRemoteCache = (await Promise.resolve(`${this.resolvePackage(pkg)}`).then(s => require(s))).getRemoteCache;
@@ -455,3 +469,40 @@ function tryAndRetry(fn) {
     };
     return _try();
 }
+/**
+ * Converts a string representation of a max cache size to a number.
+ *
+ * e.g. '1GB' -> 1024 * 1024 * 1024
+ *      '1MB' -> 1024 * 1024
+ *      '1KB' -> 1024
+ *
+ * @param maxCacheSize Max cache size as specified in nx.json
+ */
+function parseMaxCacheSize(maxCacheSize) {
+    if (!maxCacheSize) {
+        return undefined;
+    }
+    let regexResult = maxCacheSize.match(/^(?<size>[\d|.]+)\s?((?<unit>[KMG]?B)?)$/);
+    if (!regexResult) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize}. Must be a number followed by an optional unit (KB, MB, GB)`);
+    }
+    let sizeString = regexResult.groups.size;
+    let unit = regexResult.groups.unit;
+    if ([...sizeString].filter((c) => c === '.').length > 1) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (multiple decimal points in size)`);
+    }
+    let size = parseFloat(sizeString);
+    if (isNaN(size)) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (${sizeString} is not a number)`);
+    }
+    switch (unit) {
+        case 'KB':
+            return size * 1024;
+        case 'MB':
+            return size * 1024 * 1024;
+        case 'GB':
+            return size * 1024 * 1024 * 1024;
+        default:
+            return size;
+    }
+}

package/src/tasks-runner/run-command.js

@@ -36,7 +36,7 @@ const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
-const powerpack_1 = require("../utils/powerpack");
+const nx_key_1 = require("../utils/nx-key");
 const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
@@ -141,7 +141,7 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         initiatingProject,
     });
     await renderIsDone;
-    await (0, powerpack_1.printPowerpackLicense)();
+    await (0, nx_key_1.printNxKey)();
     return taskResults;
 }
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {

package/src/tasks-runner/task-orchestrator.js

@@ -131,7 +131,12 @@ class TaskOrchestrator {
         if (!cachedResult || cachedResult.code !== 0)
             return null;
         const outputs = task.outputs;
-        const shouldCopyOutputsFromCache = !!outputs.length &&
+        const shouldCopyOutputsFromCache = 
+        // No output files to restore
+        !!outputs.length &&
+            // Remote caches are restored to output dirs when applied
+            !cachedResult.remote &&
+            // Output files have not been touched since last run
             (await this.shouldCopyOutputsFromCache(outputs, task.hash));
         if (shouldCopyOutputsFromCache) {
             await this.cache.copyFilesFromCache(task.hash, cachedResult, outputs);

package/src/utils/nx-key.d.ts

@@ -0,0 +1,7 @@
+import type { NxKey } from '@nx/key';
+export declare function createNxKeyLicenseeInformation(nxKey: NxKey): string;
+export declare function printNxKey(): Promise<void>;
+export declare function getNxKeyInformation(): Promise<NxKey | null>;
+export declare class NxKeyNotInstalledError extends Error {
+    constructor(e: Error);
+}

package/src/utils/nx-key.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxKeyNotInstalledError = void 0;
+exports.createNxKeyLicenseeInformation = createNxKeyLicenseeInformation;
+exports.printNxKey = printNxKey;
+exports.getNxKeyInformation = getNxKeyInformation;
+const logger_1 = require("./logger");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+function createNxKeyLicenseeInformation(nxKey) {
+    if ('isPowerpack' in nxKey && nxKey.isPowerpack) {
+        return `Licensed to ${nxKey.organizationName} for ${nxKey.seatCount} user${nxKey.seatCount > 1 ? 's' : ''} in ${nxKey.workspaceCount === 9999
+            ? 'an unlimited number of'
+            : nxKey.workspaceCount} workspace${nxKey.workspaceCount > 1 ? 's' : ''}.`;
+    }
+    else {
+        return `Licensed to ${nxKey.organizationName}.`;
+    }
+}
+async function printNxKey() {
+    try {
+        const key = await getNxKeyInformation();
+        if (key) {
+            logger_1.logger.log(createNxKeyLicenseeInformation(key));
+        }
+    }
+    catch { }
+}
+async function getNxKeyInformation() {
+    try {
+        const { getPowerpackLicenseInformation, getPowerpackLicenseInformationAsync, } = (await Promise.resolve().then(() => require('@nx/powerpack-license')));
+        return (getPowerpackLicenseInformationAsync ?? getPowerpackLicenseInformation)(workspace_root_1.workspaceRoot);
+    }
+    catch (e) {
+        try {
+            const { getNxKeyInformationAsync } = (await Promise.resolve().then(() => require('@nx/key')));
+            return getNxKeyInformationAsync(workspace_root_1.workspaceRoot);
+        }
+        catch (e) {
+            if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+                throw new NxKeyNotInstalledError(e);
+            }
+            throw e;
+        }
+    }
+}
+class NxKeyNotInstalledError extends Error {
+    constructor(e) {
+        super(`The "@nx/key" package is needed to use Nx key enabled features. Please install it with ${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/key`, { cause: e });
+    }
+}
+exports.NxKeyNotInstalledError = NxKeyNotInstalledError;

package/src/utils/require-nx-key.d.ts

@@ -0,0 +1 @@
+export declare function requireNxKey(): Promise<typeof import('@nx/key')>;

package/src/utils/require-nx-key.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNxKey = requireNxKey;
+const child_process_1 = require("child_process");
+const package_manager_1 = require("./package-manager");
+async function requireNxKey() {
+    // @ts-ignore
+    return Promise.resolve().then(() => require('@nx/key')).catch(async (e) => {
+        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+            try {
+                (0, child_process_1.execSync)(`${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/key@latest`, {
+                    windowsHide: false,
+                });
+                // @ts-ignore
+                return await Promise.resolve().then(() => require('@nx/key'));
+            }
+            catch (e) {
+                throw new Error('Failed to install @nx/key. Please install @nx/key and try again.');
+            }
+        }
+    });
+}

package/src/command-line/activate-powerpack/activate-powerpack.d.ts

@@ -1,2 +0,0 @@
-import { ActivatePowerpackOptions } from './command-object';
-export declare function handleActivatePowerpack(options: ActivatePowerpackOptions): Promise<void>;

package/src/command-line/activate-powerpack/activate-powerpack.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleActivatePowerpack = handleActivatePowerpack;
-const workspace_root_1 = require("../../utils/workspace-root");
-const enquirer_1 = require("enquirer");
-const child_process_1 = require("child_process");
-const package_manager_1 = require("../../utils/package-manager");
-async function handleActivatePowerpack(options) {
-    const license = options.license ??
-        (await (0, enquirer_1.prompt)({
-            type: 'input',
-            name: 'license',
-            message: 'Enter your License Key',
-        }));
-    const { activatePowerpack } = await requirePowerpack();
-    activatePowerpack(workspace_root_1.workspaceRoot, license);
-}
-async function requirePowerpack() {
-    // @ts-ignore
-    return Promise.resolve().then(() => require('@nx/powerpack-license')).catch(async (e) => {
-        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
-            try {
-                (0, child_process_1.execSync)(`${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/powerpack-license@latest`, {
-                    windowsHide: false,
-                });
-                // @ts-ignore
-                return await Promise.resolve().then(() => require('@nx/powerpack-license'));
-            }
-            catch (e) {
-                throw new Error('Failed to install @nx/powerpack-license. Please install @nx/powerpack-license and try again.');
-            }
-        }
-    });
-}

package/src/command-line/activate-powerpack/command-object.d.ts

@@ -1,6 +0,0 @@
-import { CommandModule } from 'yargs';
-export interface ActivatePowerpackOptions {
-    license: string;
-    verbose: boolean;
-}
-export declare const yargsActivatePowerpackCommand: CommandModule<{}, ActivatePowerpackOptions>;

package/src/utils/powerpack.d.ts

@@ -1,5 +0,0 @@
-export declare function printPowerpackLicense(): Promise<void>;
-export declare function getPowerpackLicenseInformation(): Promise<import("@nx/powerpack-license").PowerpackLicense>;
-export declare class NxPowerpackNotInstalledError extends Error {
-    constructor(e: Error);
-}

package/src/utils/powerpack.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NxPowerpackNotInstalledError = void 0;
-exports.printPowerpackLicense = printPowerpackLicense;
-exports.getPowerpackLicenseInformation = getPowerpackLicenseInformation;
-const logger_1 = require("./logger");
-const package_manager_1 = require("./package-manager");
-const workspace_root_1 = require("./workspace-root");
-async function printPowerpackLicense() {
-    try {
-        const { organizationName, seatCount, workspaceCount } = await getPowerpackLicenseInformation();
-        logger_1.logger.log(`Nx Powerpack Licensed to ${organizationName} for ${seatCount} user${seatCount > 1 ? 's' : ''} in ${workspaceCount === 9999 ? 'an unlimited number of' : workspaceCount} workspace${workspaceCount > 1 ? 's' : ''}`);
-    }
-    catch { }
-}
-async function getPowerpackLicenseInformation() {
-    try {
-        const { getPowerpackLicenseInformation, getPowerpackLicenseInformationAsync, } = (await Promise.resolve().then(() => require('@nx/powerpack-license')));
-        return (getPowerpackLicenseInformationAsync ?? getPowerpackLicenseInformation)(workspace_root_1.workspaceRoot);
-    }
-    catch (e) {
-        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
-            throw new NxPowerpackNotInstalledError(e);
-        }
-        throw e;
-    }
-}
-class NxPowerpackNotInstalledError extends Error {
-    constructor(e) {
-        super(`The "@nx/powerpack-license" package is needed to use Nx Powerpack enabled features. Please install the @nx/powerpack-license with ${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/powerpack-license`, { cause: e });
-    }
-}
-exports.NxPowerpackNotInstalledError = NxPowerpackNotInstalledError;