nx 22.7.0-beta.11 → 22.7.0-beta.13

package/dist/src/command-line/show/show-target/index.d.ts

@@ -0,0 +1,3 @@
+export { showTargetInfoHandler } from './info';
+export { showTargetInputsHandler } from './inputs';
+export { showTargetOutputsHandler } from './outputs';

package/dist/src/command-line/show/show-target/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetOutputsHandler = exports.showTargetInputsHandler = exports.showTargetInfoHandler = void 0;
+var info_1 = require("./info");
+Object.defineProperty(exports, "showTargetInfoHandler", { enumerable: true, get: function () { return info_1.showTargetInfoHandler; } });
+var inputs_1 = require("./inputs");
+Object.defineProperty(exports, "showTargetInputsHandler", { enumerable: true, get: function () { return inputs_1.showTargetInputsHandler; } });
+var outputs_1 = require("./outputs");
+Object.defineProperty(exports, "showTargetOutputsHandler", { enumerable: true, get: function () { return outputs_1.showTargetOutputsHandler; } });

package/dist/src/command-line/show/show-target/info.d.ts

@@ -0,0 +1,27 @@
+import type { InputDefinition } from '../../../config/workspace-json-project-json';
+import type { ShowTargetBaseOptions } from '../command-object';
+import { type ResolvedTarget } from './utils';
+export declare function showTargetInfoHandler(args: ShowTargetBaseOptions): Promise<void>;
+export type TargetInfoData = ReturnType<typeof resolveTargetInfoData>;
+declare function resolveTargetInfoData(t: ResolvedTarget): {
+    sourceMap?: Record<string, [file: string, plugin: string]>;
+    defaultConfiguration?: string;
+    configurations?: string[];
+    options: any;
+    outputs?: string[];
+    inputs?: (string | InputDefinition)[];
+    _inputSources?: number[];
+    parallelism: boolean;
+    continuous: boolean;
+    cache: boolean;
+    dependsOn?: string[];
+    _depSources?: number[];
+    customHasher?: boolean;
+    command?: string;
+    _commandSourceKey?: string;
+    executor: string;
+    configuration?: string;
+    project: string;
+    target: string;
+};
+export {};

package/dist/src/command-line/show/show-target/info.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetInfoHandler = showTargetInfoHandler;
+const task_hasher_1 = require("../../../hasher/task-hasher");
+const utils_1 = require("../../../tasks-runner/utils");
+const utils_2 = require("./utils");
+// ── Handler ─────────────────────────────────────────────────────────
+async function showTargetInfoHandler(args) {
+    const t = await (0, utils_2.resolveTarget)(args, { withSourceMaps: true });
+    const data = resolveTargetInfoData(t);
+    renderTargetInfo(data, args);
+}
+function resolveTargetInfoData(t) {
+    const { projectName, targetName, configuration, node, graph, nxJson, sourceMaps, } = t;
+    const targetConfig = node.data.targets[targetName];
+    const allTargetNames = new Set();
+    for (const n of Object.values(graph.nodes)) {
+        for (const name of Object.keys(n.data.targets ?? {})) {
+            allTargetNames.add(name);
+        }
+    }
+    const extraTargetDeps = Object.fromEntries(Object.entries(nxJson.targetDefaults ?? {})
+        .filter(([, config]) => config.dependsOn)
+        .map(([name, config]) => [name, config.dependsOn]));
+    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, extraTargetDeps, graph, [...allTargetNames]);
+    // Determine the hoisted command value and which option key it came from
+    let command;
+    let commandSourceKey;
+    if (targetConfig.metadata?.scriptContent) {
+        command = targetConfig.metadata.scriptContent;
+        commandSourceKey = 'options.script';
+    }
+    else if (targetConfig.options?.command) {
+        command = targetConfig.options.command;
+        commandSourceKey = 'options.command';
+    }
+    else if (targetConfig.options?.commands?.length === 1) {
+        command = targetConfig.options.commands[0];
+        commandSourceKey = 'options.commands';
+    }
+    else if (targetConfig.executor === 'nx:run-script' &&
+        targetConfig.options?.script) {
+        command = targetConfig.options.script;
+        commandSourceKey = 'options.script';
+    }
+    const dependsOn = [];
+    const depSourceIndices = [];
+    if (depConfigs && depConfigs.length > 0) {
+        for (let i = 0; i < depConfigs.length; i++) {
+            const dep = depConfigs[i];
+            const projects = resolveDependencyProjects(dep, projectName, graph);
+            for (const p of projects) {
+                dependsOn.push(`${p}:${dep.target}`);
+                depSourceIndices.push(i);
+            }
+        }
+    }
+    const configurations = Object.keys(targetConfig.configurations ?? {});
+    const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
+    const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);
+    return {
+        project: projectName,
+        target: targetName,
+        ...(configuration ? { configuration } : {}),
+        executor: targetConfig.executor,
+        ...(command ? { command, _commandSourceKey: commandSourceKey } : {}),
+        ...(usesCustomHasher ? { customHasher: true } : {}),
+        ...(dependsOn.length > 0
+            ? { dependsOn, _depSources: depSourceIndices }
+            : {}),
+        parallelism: targetConfig.parallelism ?? true,
+        continuous: targetConfig.continuous ?? false,
+        cache: targetConfig.cache ?? false,
+        ...(targetConfig.inputs
+            ? (() => {
+                const expanded = expandInputsForDisplay(targetConfig.inputs, node, nxJson);
+                return {
+                    inputs: expanded.map((e) => e.value),
+                    _inputSources: expanded.map((e) => e.originalIndex),
+                };
+            })()
+            : {}),
+        ...(targetConfig.outputs
+            ? { outputs: targetConfig.outputs }
+            : {}),
+        options: {
+            ...targetConfig.options,
+            ...(configuration
+                ? targetConfig.configurations?.[configuration]
+                : undefined),
+        },
+        ...(configurations.length > 0 ? { configurations } : {}),
+        ...(targetConfig.defaultConfiguration
+            ? { defaultConfiguration: targetConfig.defaultConfiguration }
+            : {}),
+        ...(targetSourceMap ? { sourceMap: targetSourceMap } : {}),
+    };
+}
+function resolveDependencyProjects(dep, projectName, graph) {
+    if (dep.projects && dep.projects.length > 0)
+        return dep.projects;
+    if (dep.dependencies) {
+        const depEdges = graph.dependencies[projectName] ?? [];
+        return depEdges
+            .filter((edge) => {
+            const depNode = graph.nodes[edge.target];
+            return depNode && depNode.data.targets?.[dep.target];
+        })
+            .map((edge) => edge.target);
+    }
+    return [projectName];
+}
+/**
+ * Expands named inputs (e.g. "production") to their definitions while
+ * tracking which original input index each expanded item came from.
+ * This lets the renderer look up `inputs.${originalIndex}` in the source map.
+ */
+function expandInputsForDisplay(inputs, node, nxJson) {
+    const namedInputs = (0, task_hasher_1.getNamedInputs)(nxJson, node);
+    const result = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        if (typeof input === 'string') {
+            if (input.startsWith('^')) {
+                result.push({ value: input, originalIndex: i });
+            }
+            else if (namedInputs[input]) {
+                for (const expanded of namedInputs[input]) {
+                    result.push({ value: expanded, originalIndex: i });
+                }
+            }
+            else {
+                result.push({ value: input, originalIndex: i });
+            }
+        }
+        else if ('input' in input) {
+            const name = input.input;
+            // Don't expand when the input has additional qualifiers (e.g. projects)
+            // since those scopes are meaningful and would be lost by expansion
+            const hasQualifiers = Object.keys(input).length > 1;
+            if (!hasQualifiers && !name.startsWith('^') && namedInputs[name]) {
+                for (const expanded of namedInputs[name]) {
+                    result.push({ value: expanded, originalIndex: i });
+                }
+            }
+            else {
+                result.push({ value: input, originalIndex: i });
+            }
+        }
+        else {
+            result.push({ value: input, originalIndex: i });
+        }
+    }
+    return result;
+}
+function extractTargetSourceMap(projectRoot, targetName, sourceMaps) {
+    if (!sourceMaps)
+        return undefined;
+    const projectSourceMap = sourceMaps[projectRoot];
+    if (!projectSourceMap)
+        return undefined;
+    const prefix = `targets.${targetName}.`;
+    const targetEntry = `targets.${targetName}`;
+    const result = {};
+    for (const [key, value] of Object.entries(projectSourceMap)) {
+        if (key === targetEntry) {
+            result['target'] = value;
+        }
+        else if (key.startsWith(prefix)) {
+            result[key.slice(prefix.length)] = value;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+// ── Render ──────────────────────────────────────────────────────────
+function renderTargetInfo(data, args) {
+    if (args.json) {
+        // Strip internal renderer-only fields from JSON output
+        const { _inputSources, _depSources, _commandSourceKey, ...jsonData } = data;
+        console.log(JSON.stringify(jsonData, null, 2));
+        return;
+    }
+    const c = (0, utils_2.pc)();
+    const sm = data.sourceMap;
+    const sourceHint = (key, fallbackKey) => {
+        if (!args.verbose)
+            return '';
+        const entry = sm?.[key] ?? (fallbackKey ? sm?.[fallbackKey] : undefined);
+        if (!entry)
+            return '';
+        const [file, plugin] = entry;
+        if (file && plugin)
+            return ` ${c.dim(`(from ${file} by ${plugin})`)}`;
+        if (file)
+            return ` ${c.dim(`(from ${file})`)}`;
+        if (plugin)
+            return ` ${c.dim(`(by ${plugin})`)}`;
+        return '';
+    };
+    console.log(`${c.bold('Target')}: ${c.cyan(data.project)}:${c.green(data.target)}${sourceHint('target')}`);
+    if (data.command) {
+        const label = data.executor === 'nx:run-script' ? 'Script' : 'Command';
+        const cmdHint = data._commandSourceKey
+            ? sourceHint(data._commandSourceKey)
+            : '';
+        console.log(`${c.bold(label)}: ${data.command}${cmdHint}`);
+    }
+    else if (data.executor) {
+        console.log(`${c.bold('Executor')}: ${data.executor}${sourceHint('executor')}`);
+    }
+    if (data.customHasher) {
+        console.log(`${c.bold('Hasher')}: ${c.yellow('custom')} ${c.dim('(inputs do not affect cache hash)')}`);
+    }
+    if (data.configuration)
+        console.log(`${c.bold('Configuration')}: ${data.configuration}`);
+    if (data.dependsOn && data.dependsOn.length > 0) {
+        console.log(`${c.bold('Depends On')}:`);
+        for (let i = 0; i < data.dependsOn.length; i++) {
+            const hint = data._depSources?.[i] !== undefined
+                ? sourceHint(`dependsOn.${data._depSources[i]}`, 'dependsOn')
+                : '';
+            console.log(`  ${data.dependsOn[i]}${hint}`);
+        }
+    }
+    console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
+    console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);
+    console.log(`${c.bold('Cache')}: ${data.cache}${sourceHint('cache')}`);
+    if (data.inputs && data.inputs.length > 0) {
+        console.log(`${c.bold('Inputs')}:`);
+        const inputSources = data._inputSources;
+        // Build sortable entries with their source index
+        const entries = data.inputs.map((input, i) => ({
+            value: input,
+            sourceIndex: inputSources?.[i],
+        }));
+        entries.sort((a, b) => {
+            const aIsString = typeof a.value === 'string';
+            const bIsString = typeof b.value === 'string';
+            if (!aIsString && bIsString)
+                return 1;
+            if (aIsString && !bIsString)
+                return -1;
+            if (aIsString && bIsString) {
+                const aStr = a.value;
+                const bStr = b.value;
+                const aIsDep = aStr.startsWith('^');
+                const bIsDep = bStr.startsWith('^');
+                if (aIsDep && !bIsDep)
+                    return 1;
+                if (!aIsDep && bIsDep)
+                    return -1;
+                return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
+            }
+            return 0;
+        });
+        for (const { value, sourceIndex } of entries) {
+            const display = typeof value === 'string' ? value : JSON.stringify(value);
+            const hint = sourceIndex !== undefined
+                ? sourceHint(`inputs.${sourceIndex}`, 'inputs')
+                : '';
+            console.log(`  - ${display}${hint}`);
+        }
+    }
+    if (data.outputs && data.outputs.length > 0) {
+        console.log(`${c.bold('Outputs')}:`);
+        for (let i = 0; i < data.outputs.length; i++) {
+            const hint = sourceHint(`outputs.${i}`, 'outputs');
+            console.log(`  - ${data.outputs[i]}${hint}`);
+        }
+    }
+    // When command is hoisted, hide the corresponding option key from display
+    const hoistedOptionKey = data._commandSourceKey?.startsWith('options.')
+        ? data._commandSourceKey.slice('options.'.length)
+        : undefined;
+    const displayOptions = Object.entries(data.options).filter(([key]) => key !== hoistedOptionKey);
+    if (displayOptions.length > 0) {
+        console.log(`${c.bold('Options')}:`);
+        for (const [key, value] of displayOptions) {
+            const hint = sourceHint(`options.${key}`);
+            if (typeof value === 'object' && value !== null) {
+                console.log(`  ${key}:${hint}`);
+                const lines = JSON.stringify(value, null, 2).split('\n');
+                for (const line of lines) {
+                    console.log(`    ${line}`);
+                }
+            }
+            else {
+                console.log(`  ${key}: ${JSON.stringify(value)}${hint}`);
+            }
+        }
+    }
+    if (data.configurations && data.configurations.length > 0) {
+        const configList = data.configurations
+            .map((cfg) => cfg === data.defaultConfiguration ? `${cfg} ${c.dim('(default)')}` : cfg)
+            .join(', ');
+        console.log(`${c.bold('Configurations')}: ${configList}`);
+    }
+    console.log('');
+}

package/dist/src/command-line/show/show-target/inputs.d.ts

@@ -0,0 +1,2 @@
+import type { ShowTargetInputsOptions } from '../command-object';
+export declare function showTargetInputsHandler(args: ShowTargetInputsOptions): Promise<void>;

package/dist/src/command-line/show/show-target/inputs.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetInputsHandler = showTargetInputsHandler;
+const workspace_root_1 = require("../../../utils/workspace-root");
+const handle_import_1 = require("../../../utils/handle-import");
+const utils_1 = require("./utils");
+// ── Handler ─────────────────────────────────────────────────────────
+async function showTargetInputsHandler(args) {
+    const t = await (0, utils_1.resolveTarget)(args);
+    const usesCustomHasher = (0, utils_1.hasCustomHasher)(t.projectName, t.targetName, t.graph);
+    if (usesCustomHasher) {
+        renderCustomHasherWarning(t.projectName, t.targetName, args);
+        process.exitCode = 1;
+        return;
+    }
+    const hashInputs = await resolveInputFiles(t);
+    if (args.check !== undefined) {
+        const checkItems = (0, utils_1.deduplicateFolderEntries)(args.check);
+        const results = checkItems.map((input) => resolveCheckFromInputs(input, t.projectName, t.targetName, hashInputs));
+        if (results.length >= 2) {
+            renderBatchCheckInputs(results, t.projectName, t.targetName);
+        }
+        else {
+            for (const data of results)
+                renderCheckInput(data);
+        }
+        for (const data of results) {
+            process.exitCode ||=
+                data.isInput || data.containedInputFiles.length ? 0 : 1;
+        }
+        return;
+    }
+    renderInputs({ project: t.projectName, target: t.targetName, ...hashInputs }, t.node.data.targets[t.targetName].inputs, args);
+}
+async function resolveInputFiles(t) {
+    const { projectName, targetName, configuration, graph, nxJson } = t;
+    const { HashPlanInspector } = (await (0, handle_import_1.handleImport)('../../../hasher/hash-plan-inspector.js', __dirname));
+    const inspector = new HashPlanInspector(graph, workspace_root_1.workspaceRoot, nxJson);
+    await inspector.init();
+    const plan = inspector.inspectTaskInputs({
+        project: projectName,
+        target: targetName,
+        configuration,
+    });
+    const targetConfig = graph.nodes[projectName]?.data?.targets?.[targetName];
+    const effectiveConfig = configuration ?? targetConfig?.defaultConfiguration;
+    const taskId = effectiveConfig
+        ? `${projectName}:${targetName}:${effectiveConfig}`
+        : `${projectName}:${targetName}`;
+    const result = plan[taskId];
+    if (!result) {
+        throw new Error(`Could not find hash plan for task "${taskId}". Available tasks: ${Object.keys(plan).join(', ')}`);
+    }
+    return result;
+}
+function resolveCheckFromInputs(rawValue, projectName, targetName, inputs) {
+    for (const [category, arr] of [
+        ['environment', inputs.environment],
+        ['runtime', inputs.runtime],
+        ['external', inputs.external],
+        ['depOutputs', inputs.depOutputs],
+    ]) {
+        if (arr.includes(rawValue)) {
+            return {
+                value: rawValue,
+                file: rawValue,
+                project: projectName,
+                target: targetName,
+                isInput: true,
+                matchedCategory: category,
+                containedInputFiles: [],
+            };
+        }
+    }
+    const fileToCheck = (0, utils_1.normalizePath)(rawValue);
+    const isFile = inputs.files.includes(fileToCheck);
+    let containedInputFiles = [];
+    if (!isFile) {
+        if (fileToCheck === '') {
+            containedInputFiles = inputs.files;
+        }
+        else {
+            const dirPrefix = fileToCheck.endsWith('/')
+                ? fileToCheck
+                : fileToCheck + '/';
+            containedInputFiles = inputs.files.filter((f) => f.startsWith(dirPrefix));
+        }
+    }
+    return {
+        value: rawValue,
+        file: fileToCheck,
+        project: projectName,
+        target: targetName,
+        isInput: isFile,
+        matchedCategory: isFile || containedInputFiles.length > 0
+            ? 'files'
+            : null,
+        containedInputFiles,
+    };
+}
+// ── Render ──────────────────────────────────────────────────────────
+function renderInputs(data, configuredInputs, args) {
+    if (args.json) {
+        const jsonData = data;
+        const result = {};
+        for (const [k, v] of Object.entries(jsonData)) {
+            if (Array.isArray(v) && v.length === 0)
+                continue;
+            result[k] = v;
+        }
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const c = (0, utils_1.pc)();
+    console.log(`${c.bold('Inputs for')} ${c.cyan(data.project)}:${c.green(data.target)}`);
+    if (configuredInputs && configuredInputs.length > 0) {
+        (0, utils_1.printList)('Configured inputs', configuredInputs.map((i) => typeof i === 'string' ? i : JSON.stringify(i)));
+    }
+    (0, utils_1.printList)('External dependencies', [...data.external].sort());
+    (0, utils_1.printList)('Runtime inputs', [...data.runtime].sort());
+    (0, utils_1.printList)('Environment variables', [...data.environment].sort());
+    (0, utils_1.printList)(`Files (${data.files.length})`, [...data.files, ...data.depOutputs].sort());
+}
+function renderCheckInput(data) {
+    const c = (0, utils_1.pc)();
+    const categoryLabel = data.matchedCategory
+        ? ` (${data.matchedCategory})`
+        : '';
+    if (data.isInput) {
+        console.log(`${c.green('✓')} ${c.bold(data.value)} is an input for ${c.cyan(data.project)}:${c.green(data.target)}${categoryLabel}`);
+    }
+    else if (data.containedInputFiles.length > 0) {
+        console.log(`${c.yellow('~')} ${c.bold(data.file)} is a directory containing ${c.bold(String(data.containedInputFiles.length))} input file(s) for ${c.cyan(data.project)}:${c.green(data.target)}`);
+        for (const f of [...data.containedInputFiles].sort())
+            console.log(`  ${f}`);
+    }
+    else {
+        console.log(`${c.red('✗')} ${c.bold(data.value)} is ${c.red('not')} an input for ${c.cyan(data.project)}:${c.green(data.target)}`);
+    }
+}
+function renderBatchCheckInputs(results, projectName, targetName) {
+    const c = (0, utils_1.pc)();
+    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
+    const matched = [];
+    const directories = [];
+    const unmatched = [];
+    for (const r of results) {
+        if (r.isInput) {
+            matched.push(r.value);
+        }
+        else if (r.containedInputFiles.length > 0) {
+            directories.push({ value: r.file, count: r.containedInputFiles.length });
+        }
+        else {
+            unmatched.push(r.value);
+        }
+    }
+    if (matched.length > 0 || directories.length > 0) {
+        console.log(`\n${c.green('✓')} These arguments were inputs for ${label}:`);
+        for (const v of matched)
+            console.log(`  ${v}`);
+        for (const d of directories) {
+            console.log(`  ${d.value} (directory containing ${d.count} input files)`);
+        }
+    }
+    if (unmatched.length > 0) {
+        console.log(`\n${c.red('✗')} These arguments were ${c.red('not')} inputs for ${label}:`);
+        for (const v of unmatched)
+            console.log(`  ${v}`);
+    }
+}
+function renderCustomHasherWarning(projectName, targetName, args) {
+    const c = (0, utils_1.pc)();
+    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
+    if (args.json) {
+        console.log(JSON.stringify({
+            project: projectName,
+            target: targetName,
+            warning: 'This target uses a custom hasher. Configured inputs do not affect the cache hash.',
+        }, null, 2));
+        return;
+    }
+    console.log(`\n${c.yellow('⚠')} ${label} uses a ${c.yellow('custom hasher')}.`);
+    console.log(`  Configured inputs do not affect the cache hash for this target.`);
+    console.log(`  The executor's hasher determines what is included in the hash.`);
+}

package/dist/src/command-line/show/show-target/outputs.d.ts

@@ -0,0 +1,2 @@
+import type { ShowTargetOutputsOptions } from '../command-object';
+export declare function showTargetOutputsHandler(args: ShowTargetOutputsOptions): Promise<void>;