@depup/nx 23.2.1-depup.8 → 23.3.0-depup.1

package/dist/src/utils/command-line-utils.js

@@ -198,12 +198,13 @@ function getUncommittedFiles() {
         '--name-only',
         '--no-renames',
         '--relative',
+        '-z',
         'HEAD',
         '.',
     ]);
 }
 function getUntrackedFiles() {
-    return parseGitOutput(['ls-files', '--others', '--exclude-standard']);
+    return parseGitOutput(['ls-files', '--others', '--exclude-standard', '-z']);
 }
 function getMergeBase(base, head = 'HEAD') {
     (0, git_revision_1.assertValidGitRevision)(base);
@@ -230,6 +231,7 @@ function getFilesUsingBaseAndHead(base, head) {
         '--name-only',
         '--no-renames',
         '--relative',
+        '-z',
         base,
         head,
     ]);
@@ -242,11 +244,16 @@ function runGit(args) {
         windowsHide: true,
     });
 }
+/**
+ * Parses NUL-terminated paths, so callers must pass `-z`, and must pass it
+ * before the pathspec — git fatals on a `-z` that follows one. Without `-z` git
+ * escapes paths that contain non-ASCII or quoting characters, and honours
+ * `core.quotepath`, which is on by default.
+ */
 function parseGitOutput(args) {
     return runGit(args)
         .toString('utf-8')
-        .split('\n')
-        .map((a) => a.trim())
+        .split('\0')
         .filter((a) => a.length > 0);
 }
 function getProjectRoots(projectNames, { nodes }) {

package/dist/src/utils/create-cli-options.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns options into CLI flags: `{ maxWarnings: 0, fix: true }` gives
+ * `--max-warnings=0 --fix`. Arrays repeat the flag; `false`, `null` and
+ * `undefined` give none.
+ */
+export declare function createCliOptions(obj: Record<string, string | number | boolean | string[] | undefined | null>): string[];

package/dist/src/utils/create-cli-options.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliOptions = createCliOptions;
+/**
+ * Turns options into CLI flags: `{ maxWarnings: 0, fix: true }` gives
+ * `--max-warnings=0 --fix`. Arrays repeat the flag; `false`, `null` and
+ * `undefined` give none.
+ */
+function createCliOptions(obj) {
+    const args = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined || value === null || value === false) {
+            continue;
+        }
+        const flag = `--${key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase())}`;
+        if (value === true) {
+            args.push(flag);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                args.push(`${flag}=${item}`);
+            }
+        }
+        else {
+            args.push(`${flag}=${value}`);
+        }
+    }
+    return args;
+}

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

@@ -1,4 +1,5 @@
 import { ExternalObject } from '../native';
+export declare function sharedWorkspaceDataDirectory(root: string): string;
 export declare function getDbConnection(opts?: {
     directory?: string;
     dbName?: string;
@@ -12,3 +13,4 @@ export declare function getDbConnection(opts?: {
 export declare function getLocalDbConnection(opts?: {
     dbName?: string;
 }): ExternalObject<any>;
+export declare function removeDbConnections(): void;

package/dist/src/utils/db-connection.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedWorkspaceDataDirectory = sharedWorkspaceDataDirectory;
 exports.getDbConnection = getDbConnection;
 exports.getLocalDbConnection = getLocalDbConnection;
+exports.removeDbConnections = removeDbConnections;
 const native_1 = require("../native");
 const cache_directory_1 = require("./cache-directory");
 const workspace_root_1 = require("./workspace-root");

package/dist/src/utils/formatters/index.d.ts

@@ -1,4 +1,6 @@
 import type { Tree } from '../../generators/tree';
+import { getOxfmtBinPath } from './oxfmt';
+import { getPrettierPath } from './prettier';
 /**
  * Adding a member here does NOT reliably break compilation: the repo builds
  * with `strict: false`, so a `switch` that omits one is not an error. The
@@ -7,6 +9,10 @@ import type { Tree } from '../../generators/tree';
  * its emitted declarations, so those only fail once it has been rebuilt.
  */
 export type FormatterType = 'prettier' | 'oxfmt';
+export declare const resolveFormatterBin: {
+    oxfmt: typeof getOxfmtBinPath;
+    prettier: typeof getPrettierPath;
+};
 /** Test-only: the warn-once flag is module state and would leak between cases. */
 export declare function resetFormatterWarningsForTesting(): void;
 export declare function detectFormatter(root: string): FormatterType | null;

package/dist/src/utils/formatters/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFormatterBin = void 0;
 exports.resetFormatterWarningsForTesting = resetFormatterWarningsForTesting;
 exports.detectFormatter = detectFormatter;
 exports.detectFormatterInTree = detectFormatterInTree;
@@ -10,6 +11,10 @@ const fileutils_1 = require("../fileutils");
 const oxfmt_1 = require("./oxfmt");
 const prettier_1 = require("./prettier");
 const logger_1 = require("../logger");
+exports.resolveFormatterBin = {
+    oxfmt: oxfmt_1.getOxfmtBinPath,
+    prettier: prettier_1.getPrettierPath,
+};
 // Once per process: detection runs on every one of 200+ `formatFiles` call sites.
 let warnedBothConfigured = false;
 function warnBothConfigured() {

package/dist/src/utils/formatters/prettier.d.ts

@@ -16,11 +16,3 @@ export declare function filterToPrettierSupportedFiles(files: string[]): Promise
 export declare function writeWithPrettier(patterns: string[], cwd?: string): void;
 export declare function checkWithPrettier(patterns: string[]): Promise<string[]>;
 export declare function getPrettierPath(): string;
-/**
- * Quote a pattern for prettier's shell-based exec calls; oxfmt uses execFile
- * and takes raw paths.
- *
- * Exported so `nx format` can size its chunks against the quoted length -
- * patterns are chunked before they get here, and quoting grows each one.
- */
-export declare function quoteForShell(pattern: string): string;

package/dist/src/utils/formatters/prettier.js

@@ -7,7 +7,6 @@ exports.filterToPrettierSupportedFiles = filterToPrettierSupportedFiles;
 exports.writeWithPrettier = writeWithPrettier;
 exports.checkWithPrettier = checkWithPrettier;
 exports.getPrettierPath = getPrettierPath;
-exports.quoteForShell = quoteForShell;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -98,19 +97,17 @@ cwd) {
     if (patterns.length === 0) {
         // Prettier with no file arguments reads stdin, and `stdio: [0, 1, 2]` hands
         // it nx's own - from a terminal it blocks forever with nothing on screen. At
-        // EOF it exits 0 under `--list-different` and 2 (which `execSync` throws on)
+        // EOF it exits 0 under `--list-different` and 2 (which `execFileSync` throws on)
         // without it, so which failure you get depends on `shouldUseListDifferent`.
         return;
     }
     const prettierPath = getPrettierPath();
-    const listDifferentArg = shouldUseListDifferent() ? '--list-different ' : '';
+    const listDifferentArg = shouldUseListDifferent() ? ['--list-different'] : [];
     // No `--parser json` special case for `.swcrc`: prettier's own language table
     // maps it to the json parser, so it formats correctly on its own (measured).
     // Splitting the batch also meant one of the two spawns could receive zero
     // files, which is the error above.
-    (0, node_child_process_1.execSync)(`node ${quoteForShell(prettierPath)} --write ${listDifferentArg}-- ${patterns
-        .map(quoteForShell)
-        .join(' ')}`, {
+    (0, node_child_process_1.execFileSync)(process.execPath, [prettierPath, '--write', ...listDifferentArg, '--', ...patterns], {
         cwd,
         stdio: [0, 1, 2],
         windowsHide: true,
@@ -119,9 +116,7 @@ cwd) {
 function checkWithPrettier(patterns) {
     const prettierPath = getPrettierPath();
     return new Promise((resolve, reject) => {
-        (0, node_child_process_1.exec)(`node ${quoteForShell(prettierPath)} --list-different -- ${patterns
-            .map(quoteForShell)
-            .join(' ')}`, { encoding: 'utf-8', windowsHide: true, maxBuffer: shared_1.FORMATTER_MAX_BUFFER }, (error, stdout) => {
+        (0, node_child_process_1.execFile)(process.execPath, [prettierPath, '--list-different', '--', ...patterns], { encoding: 'utf-8', windowsHide: true, maxBuffer: shared_1.FORMATTER_MAX_BUFFER }, (error, stdout) => {
             if (error) {
                 // As the oxfmt sibling: a spawn failure, kill or maxBuffer overrun reports a
                 // string `code` or none. Prettier signals "files differ" numerically, so
@@ -182,20 +177,3 @@ function shouldUseListDifferent() {
     }
     return useListDifferent;
 }
-/**
- * Quote a pattern for prettier's shell-based exec calls; oxfmt uses execFile
- * and takes raw paths.
- *
- * Exported so `nx format` can size its chunks against the quoted length -
- * patterns are chunked before they get here, and quoting grows each one.
- */
-function quoteForShell(pattern) {
-    // Interpolated into a command string, so every character special *inside
-    // double quotes* needs escaping, not just `$`: a backtick substitutes, `"`
-    // closes the quoting, `\` escapes what follows. One pass over the original,
-    // since `String.replace` never re-scans what it inserted.
-    const escaped = process.platform !== 'win32'
-        ? pattern.replace(/([\\"`$])/g, '\\$1')
-        : pattern;
-    return `"${escaped}"`;
-}

package/dist/src/utils/git-utils.d.ts

@@ -90,6 +90,18 @@ export declare function commitChanges(commitMessage: string, directory?: string)
  * callers' own constants, never from user input.
  */
 export declare function tryCommitChanges(commitMessage: string, directory: string, excludePaths?: string[]): string | null;
+/**
+ * `tryCommitChanges` for a process that has to stay responsive while git
+ * runs: a signing prompt or a hook can hold the commit for minutes.
+ */
+export declare function tryCommitChangesAsync(commitMessage: string, directory: string, excludePaths?: string[]): Promise<string | null>;
+/**
+ * `git reset --hard <ref>` then `git clean -fd`, keeping `keepPaths` (git
+ * exclusion patterns, repo-relative) out of the clean. Throws with git's
+ * stderr when either fails. `ref` is a sha a caller validated with `GIT_SHA`,
+ * never user input.
+ */
+export declare function resetWorkingTree(ref: string, keepPaths: string[], directory: string): void;
 export declare function getLatestCommitSha(directory?: string): string | null;
 /**
  * The shape of a recorded `git rev-parse` output: 40 hex chars, or 64 in a
@@ -97,6 +109,13 @@ export declare function getLatestCommitSha(directory?: string): string | null;
  * command line has to be checked against this first.
  */
 export declare const GIT_SHA: RegExp;
+export type AncestorStatus = 'ancestor' | 'not-ancestor' | 'unknown';
+/**
+ * Whether `ancestor` is reachable from `descendant`. 'unknown' means the
+ * answer could not be established (invalid input, not a repository, a commit
+ * git does not know), which is distinct from a verified 'not-ancestor'.
+ */
+export declare function getAncestorStatus(ancestor: string, descendant: string, directory?: string): AncestorStatus;
 /**
  * Whether `ancestor` is reachable from `descendant`, i.e. resetting to
  * `descendant` keeps `ancestor` in history. Returns false when the answer

package/dist/src/utils/git-utils.js

@@ -19,7 +19,10 @@ exports.getPathCommitExposure = getPathCommitExposure;
 exports.getUncommittedChangesSnapshot = getUncommittedChangesSnapshot;
 exports.commitChanges = commitChanges;
 exports.tryCommitChanges = tryCommitChanges;
+exports.tryCommitChangesAsync = tryCommitChangesAsync;
+exports.resetWorkingTree = resetWorkingTree;
 exports.getLatestCommitSha = getLatestCommitSha;
+exports.getAncestorStatus = getAncestorStatus;
 exports.isAncestorCommit = isAncestorCommit;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
@@ -849,47 +852,91 @@ function commitChanges(commitMessage, directory) {
  */
 function tryCommitChanges(commitMessage, directory, excludePaths = []) {
     try {
-        (0, child_process_1.execSync)('git add -A', {
-            encoding: 'utf8',
-            stdio: 'pipe',
-            cwd: directory,
-            windowsHide: true,
-        });
-        // Exclusion happens as an unstage rather than an add-time pathspec:
-        // `git add` refuses a pathspec naming an ignored directory (exit 1) even
-        // as an exclusion, and an add-time pathspec cannot cover entries that
-        // were already staged before this call. The reset is relative to cwd, so
-        // a workspace nested inside a larger repo excludes its own path; a path
-        // with no index entry is a quiet no-op, unborn HEAD included.
-        for (const excludePath of excludePaths) {
-            (0, child_process_1.execSync)(`git reset -q -- "${excludePath}"`, {
+        for (const { command, input } of commitCommands(commitMessage, excludePaths)) {
+            (0, child_process_1.execSync)(command, {
                 encoding: 'utf8',
                 stdio: 'pipe',
+                input,
                 cwd: directory,
                 windowsHide: true,
             });
         }
-        (0, child_process_1.execSync)('git commit --no-verify -F -', {
-            encoding: 'utf8',
-            stdio: 'pipe',
-            input: commitMessage,
-            cwd: directory,
-            windowsHide: true,
-        });
     }
     catch (err) {
-        const stderr = err?.stderr?.toString();
-        const stdout = err?.stdout?.toString();
-        const detail = [stderr, stdout]
-            .map((s) => s?.trim())
-            .filter(Boolean)
-            .join('\n');
-        // `{ cause }` preserves structured fields (.signal, .status, .code)
-        // for callers to inspect; otherwise only stderr/stdout text survives.
-        throw new Error(detail || (err instanceof Error ? err.message : String(err)), { cause: err });
+        throw commitFailure(err);
+    }
+    return getLatestCommitSha(directory);
+}
+/**
+ * `tryCommitChanges` for a process that has to stay responsive while git
+ * runs: a signing prompt or a hook can hold the commit for minutes.
+ */
+async function tryCommitChangesAsync(commitMessage, directory, excludePaths = []) {
+    try {
+        for (const { command, input } of commitCommands(commitMessage, excludePaths)) {
+            await execAsync(command, directory, input);
+        }
+    }
+    catch (err) {
+        throw commitFailure(err);
     }
     return getLatestCommitSha(directory);
 }
+function commitCommands(commitMessage, excludePaths) {
+    return [
+        { command: 'git add -A' },
+        // Exclusion happens as an unstage rather than an add-time pathspec:
+        // `git add` refuses a pathspec naming an ignored directory (exit 1) even
+        // as an exclusion, and an add-time pathspec cannot cover entries that
+        // were already staged before this call. The reset is relative to cwd, so
+        // a workspace nested inside a larger repo excludes its own path; a path
+        // with no index entry is a quiet no-op, unborn HEAD included.
+        ...excludePaths.map((excludePath) => ({
+            command: `git reset -q -- "${excludePath}"`,
+        })),
+        { command: 'git commit --no-verify -F -', input: commitMessage },
+    ];
+}
+function commitFailure(err) {
+    const stderr = err?.stderr?.toString();
+    const stdout = err?.stdout?.toString();
+    const detail = [stderr, stdout]
+        .map((s) => s?.trim())
+        .filter(Boolean)
+        .join('\n');
+    // `{ cause }` preserves structured fields (.signal, .status, .code)
+    // for callers to inspect; otherwise only stderr/stdout text survives.
+    return new Error(detail || (err instanceof Error ? err.message : String(err)), { cause: err });
+}
+function execAsync(command, cwd, input) {
+    return new Promise((res, rej) => {
+        const child = (0, child_process_1.exec)(command, { encoding: 'utf8', cwd, windowsHide: true }, 
+        // The streams ride on the error as `execSync` reports them, so
+        // `commitFailure` shapes both the same way.
+        (err, stdout, stderr) => err ? rej(Object.assign(err, { stdout, stderr })) : res());
+        // Closed for every command, since `git commit -F -` reads to end of
+        // input. A child that exits before reading raises EPIPE here, which the
+        // exit callback already reports.
+        child.stdin?.on('error', () => { });
+        child.stdin?.end(input ?? '');
+    });
+}
+/**
+ * `git reset --hard <ref>` then `git clean -fd`, keeping `keepPaths` (git
+ * exclusion patterns, repo-relative) out of the clean. Throws with git's
+ * stderr when either fails. `ref` is a sha a caller validated with `GIT_SHA`,
+ * never user input.
+ */
+function resetWorkingTree(ref, keepPaths, directory) {
+    const options = {
+        encoding: 'utf8',
+        stdio: 'pipe',
+        cwd: directory,
+        windowsHide: true,
+    };
+    (0, child_process_1.execFileSync)('git', ['reset', '--hard', ref], options);
+    (0, child_process_1.execFileSync)('git', ['clean', '-fd', ...keepPaths.flatMap((keepPath) => ['-e', keepPath])], options);
+}
 function getLatestCommitSha(directory) {
     try {
         return (0, child_process_1.execSync)('git rev-parse HEAD', {
@@ -910,14 +957,13 @@ function getLatestCommitSha(directory) {
  */
 exports.GIT_SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
 /**
- * Whether `ancestor` is reachable from `descendant`, i.e. resetting to
- * `descendant` keeps `ancestor` in history. Returns false when the answer
- * cannot be established (invalid input, not a repository, unknown commits),
- * so callers treat an unverifiable commit as not preserved.
+ * Whether `ancestor` is reachable from `descendant`. 'unknown' means the
+ * answer could not be established (invalid input, not a repository, a commit
+ * git does not know), which is distinct from a verified 'not-ancestor'.
  */
-function isAncestorCommit(ancestor, descendant, directory) {
+function getAncestorStatus(ancestor, descendant, directory) {
     if (!exports.GIT_SHA.test(ancestor) || !exports.GIT_SHA.test(descendant)) {
-        return false;
+        return 'unknown';
     }
     try {
         (0, child_process_1.execSync)(`git merge-base --is-ancestor ${ancestor} ${descendant}`, {
@@ -925,9 +971,21 @@ function isAncestorCommit(ancestor, descendant, directory) {
             windowsHide: true,
             cwd: directory,
         });
-        return true;
+        return 'ancestor';
     }
-    catch {
-        return false;
+    catch (e) {
+        // Exit 1 is git's verified "no"; anything else is a failed probe.
+        return e?.status === 1
+            ? 'not-ancestor'
+            : 'unknown';
     }
 }
+/**
+ * Whether `ancestor` is reachable from `descendant`, i.e. resetting to
+ * `descendant` keeps `ancestor` in history. Returns false when the answer
+ * cannot be established (invalid input, not a repository, unknown commits),
+ * so callers treat an unverifiable commit as not preserved.
+ */
+function isAncestorCommit(ancestor, descendant, directory) {
+    return getAncestorStatus(ancestor, descendant, directory) === 'ancestor';
+}

package/dist/src/utils/handle-errors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleErrors = handleErrors;
+const error_types_1 = require("../project-graph/error-types");
 const logger_1 = require("./logger");
 const output_1 = require("./output");
 const handle_import_1 = require("./handle-import");
@@ -17,35 +18,9 @@ async function handleErrors(isVerbose, fn) {
         if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
             logger_1.logger.error('The generator workflow failed. See above.');
         }
-        else if (err.name === 'ProjectGraphError') {
-            const projectGraphError = err;
-            let title = projectGraphError.message;
-            if (projectGraphError.cause &&
-                typeof projectGraphError.cause === 'object' &&
-                'message' in projectGraphError.cause) {
-                title += ' ' + projectGraphError.cause.message + '.';
-            }
-            output_1.output.error({
-                title,
-                bodyLines: isVerbose
-                    ? formatErrorStackAndCause(projectGraphError, isVerbose)
-                    : projectGraphError.getErrors().map((e) => e.message),
-            });
-        }
-        else if (err.name === 'ProjectConfigurationsError') {
-            const projectConfigurationsError = err;
-            let title = projectConfigurationsError.message;
-            if (projectConfigurationsError.cause &&
-                typeof projectConfigurationsError.cause === 'object' &&
-                'message' in projectConfigurationsError.cause) {
-                title += ' ' + projectConfigurationsError.cause.message + '.';
-            }
-            output_1.output.error({
-                title,
-                bodyLines: isVerbose
-                    ? formatErrorStackAndCause(projectConfigurationsError, isVerbose)
-                    : projectConfigurationsError.errors.map((e) => e.message),
-            });
+        else if (err.name === 'ProjectGraphError' ||
+            err.name === 'ProjectConfigurationsError') {
+            output_1.output.error((0, error_types_1.formatProjectGraphError)(err, isVerbose));
         }
         else if (err.name === 'MinReleaseAgeViolationError') {
             // A cooldown violation already carries a user-shaped headline plus
@@ -59,7 +34,7 @@ async function handleErrors(isVerbose, fn) {
             const lines = (err.message ? err.message : err.toString()).split('\n');
             const bodyLines = lines.slice(1);
             if (isVerbose) {
-                bodyLines.push(...formatErrorStackAndCause(err, isVerbose));
+                bodyLines.push((0, error_types_1.formatErrorStackAndCause)(err));
             }
             else if (err.stack) {
                 bodyLines.push('Pass --verbose to see the stacktrace.');
@@ -76,16 +51,3 @@ async function handleErrors(isVerbose, fn) {
         return 1;
     }
 }
-function formatErrorStackAndCause(error, verbose) {
-    return [
-        verbose ? error.stack || error.message : error.message,
-        ...(error.cause && typeof error.cause === 'object'
-            ? [
-                'Caused by:',
-                verbose && 'stack' in error.cause
-                    ? error.cause.stack.toString()
-                    : error.cause.toString(),
-            ]
-            : []),
-    ];
-}

package/dist/src/utils/http-client.d.ts

@@ -0,0 +1,27 @@
+export interface HttpRequestConfig {
+    method?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean | null | undefined>;
+    data?: unknown;
+    timeout?: number;
+    responseType?: 'json' | 'stream';
+    signal?: AbortSignal;
+}
+export interface HttpResponse<T = any> {
+    status: number;
+    headers: Record<string, string>;
+    data: T;
+}
+export declare class HttpError extends Error {
+    readonly response: HttpResponse;
+    readonly status: number;
+    constructor(response: HttpResponse);
+}
+export interface HttpClient {
+    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    get<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    post<T = any>(url: string, data?: unknown, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+}
+export declare function createHttpClient(defaults?: HttpRequestConfig): HttpClient;
+export declare function httpRequest<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;