nx 19.8.0-beta.0 → 19.8.0-beta.1

package/src/native/index.d.ts

@@ -35,6 +35,7 @@ export declare class NxCache {
   getTaskOutputsPath(hash: string): string
   copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): void
   removeOldCacheRecords(): void
+  checkCacheFsInSync(): boolean
 }
 
 export declare class NxTaskHistory {
@@ -96,7 +97,7 @@ export interface CachedResult {
   outputsPath: string
 }
 
-export declare export function connectToNxDb(cacheDir: string, nxVersion: string): ExternalObject<Connection>
+export declare export function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<Connection>
 
 export declare export function copy(src: string, dest: string): void
 

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

@@ -16,10 +16,10 @@ export declare class DbCache {
     private cache;
     private remoteCache;
     private remoteCachePromise;
-    setup(): Promise<void>;
     constructor(options: {
         nxCloudRemoteCache: RemoteCache;
     });
+    init(): Promise<void>;
     get(task: Task): Promise<CachedResult | null>;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
@@ -28,6 +28,10 @@ export declare class DbCache {
     temporaryOutputPath(task: Task): string;
     private getRemoteCache;
     private _getRemoteCache;
+    private getPowerpackS3Cache;
+    private getPowerpackSharedCache;
+    private resolvePackage;
+    private assertCacheIsValid;
 }
 /**
  * @deprecated Use the {@link DbCache} class instead. This will be removed in Nx 21.

package/src/tasks-runner/cache.js

@@ -16,6 +16,7 @@ const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const nx_json_1 = require("../config/nx-json");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
+const is_ci_1 = require("../utils/is-ci");
 function getCache(options) {
     return process.env.NX_DISABLE_DB !== 'true' &&
         process.env.NX_DB_CACHE === 'true'
@@ -28,13 +29,17 @@ function getCache(options) {
         : new Cache(options);
 }
 class DbCache {
-    async setup() {
-        this.remoteCache = await this.getRemoteCache();
-    }
     constructor(options) {
         this.options = options;
         this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
     }
+    async init() {
+        // This should be cheap because we've already loaded
+        this.remoteCache = await this.getRemoteCache();
+        if (!this.remoteCache) {
+            this.assertCacheIsValid();
+        }
+    }
     async get(task) {
         const res = this.cache.get(task.hash);
         if (res) {
@@ -43,7 +48,6 @@ class DbCache {
                 remote: false,
             };
         }
-        await this.setup();
         if (this.remoteCache) {
             // didn't find it locally but we have a remote cache
             // attempt remote cache
@@ -67,9 +71,9 @@ class DbCache {
         return this.cache.applyRemoteCacheResults(hash, res);
     }
     async put(task, terminalOutput, outputs, code) {
+        await this.assertCacheIsValid();
         return tryAndRetry(async () => {
             this.cache.put(task.hash, terminalOutput, outputs, code);
-            await this.setup();
             if (this.remoteCache) {
                 await this.remoteCache.store(task.hash, this.cache.cacheDirectory, terminalOutput, code);
             }
@@ -105,9 +109,51 @@ class DbCache {
             }
         }
         else {
+            return ((await this.getPowerpackS3Cache()) ??
+                (await this.getPowerpackSharedCache()) ??
+                null);
+        }
+    }
+    async getPowerpackS3Cache() {
+        try {
+            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-s3-cache')}`).then(s => require(s));
+            return getRemoteCache();
+        }
+        catch {
             return null;
         }
     }
+    async getPowerpackSharedCache() {
+        try {
+            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-shared-cache')}`).then(s => require(s));
+            return getRemoteCache();
+        }
+        catch {
+            return null;
+        }
+    }
+    resolvePackage(pkg) {
+        return require.resolve(pkg, {
+            paths: [process.cwd(), workspace_root_1.workspaceRoot, __dirname],
+        });
+    }
+    assertCacheIsValid() {
+        // User has customized the cache directory - this could be because they
+        // are using a shared cache in the custom directory. The db cache is not
+        // stored in the cache directory, and is keyed by machine ID so they would
+        // hit issues. If we detect this, we can create a fallback db cache in the
+        // custom directory, and check if the entries are there when the main db
+        // cache misses.
+        if ((0, is_ci_1.isCI)() && !this.cache.checkCacheFsInSync()) {
+            const warning = [
+                `Nx found unrecognized artifacts in the cache directory and will not be able to use them.`,
+                `Nx can only restore artifacts it has metadata about.`,
+                `Read about this warning and how to address it here: https://nx.dev/troubleshooting/unknown-local-cache`,
+                ``,
+            ].join('\n');
+            console.warn(warning);
+        }
+    }
 }
 exports.DbCache = DbCache;
 /**

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

@@ -36,6 +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");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -124,6 +125,7 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         initiatingProject,
     });
     await renderIsDone;
+    await (0, powerpack_1.printPowerpackLicense)();
     return taskResults;
 }
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {

package/src/utils/db-connection.d.ts

@@ -1,2 +1,5 @@
 import { ExternalObject } from '../native';
-export declare function getDbConnection(directory?: string): ExternalObject<any>;
+export declare function getDbConnection(opts?: {
+    directory?: string;
+    dbName?: string;
+}): ExternalObject<Connection>;

package/src/utils/db-connection.js

@@ -4,8 +4,19 @@ exports.getDbConnection = getDbConnection;
 const native_1 = require("../native");
 const cache_directory_1 = require("./cache-directory");
 const package_json_1 = require("../../package.json");
-let dbConnection;
-function getDbConnection(directory = cache_directory_1.workspaceDataDirectory) {
-    dbConnection ??= (0, native_1.connectToNxDb)(directory, package_json_1.version);
-    return dbConnection;
+const dbConnectionMap = new Map();
+function getDbConnection(opts = {}) {
+    opts.directory ??= cache_directory_1.workspaceDataDirectory;
+    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, package_json_1.version, opts.dbName));
+    return connection;
+}
+function getEntryOrSet(map, key, defaultValue) {
+    const existing = map.get(key);
+    if (existing) {
+        return existing;
+    }
+    const val = defaultValue();
+    map.set(key, val);
+    return val;
 }

package/src/utils/plugins/output.d.ts

@@ -2,4 +2,5 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PluginCapabilities } from './plugin-capabilities';
 export declare function listPlugins(plugins: Map<string, PluginCapabilities>, title: string): void;
 export declare function listAlsoAvailableCorePlugins(installedPlugins: Map<string, PluginCapabilities>): void;
+export declare function listPowerpackPlugins(): void;
 export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>): Promise<void>;

package/src/utils/plugins/output.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listPlugins = listPlugins;
 exports.listAlsoAvailableCorePlugins = listAlsoAvailableCorePlugins;
+exports.listPowerpackPlugins = listPowerpackPlugins;
 exports.listPluginCapabilities = listPluginCapabilities;
 const chalk = require("chalk");
 const output_1 = require("../output");
@@ -45,6 +46,12 @@ function listAlsoAvailableCorePlugins(installedPlugins) {
         });
     }
 }
+function listPowerpackPlugins() {
+    const powerpackLink = 'https://nx.dev/plugin-registry';
+    output_1.output.log({
+        title: `Available Powerpack Plugins: ${powerpackLink}`,
+    });
+}
 async function listPluginCapabilities(pluginName, projects) {
     const plugin = await (0, plugin_capabilities_1.getPluginCapabilities)(workspace_root_1.workspaceRoot, pluginName, projects);
     if (!plugin) {

package/src/utils/powerpack.d.ts

@@ -0,0 +1,5 @@
+export declare function printPowerpackLicense(): Promise<void>;
+export declare function getPowerpackLicenseInformation(): Promise<any>;
+export declare class NxPowerpackNotInstalledError extends Error {
+    constructor(e: Error);
+}

package/src/utils/powerpack.js

@@ -0,0 +1,38 @@
+"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} workspace${workspaceCount > 1 ? '' : 's'}`);
+    }
+    catch { }
+}
+async function getPowerpackLicenseInformation() {
+    try {
+        const { getPowerpackLicenseInformation } = (await Promise.resolve().then(() => require(
+        // @ts-ignore
+        '@nx/powerpack-license'
+        // TODO(@FrozenPandaz): Provide the right type here.
+        )));
+        // )) as typeof import('@nx/powerpack-license');
+        return getPowerpackLicenseInformation(workspace_root_1.workspaceRoot);
+    }
+    catch (e) {
+        if ('code' in e && e.code === 'ERR_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;