@depup/nx 22.5.4-depup.0

package/src/migrations/update-22-0-0/release-version-config-changes.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const node_path_1 = require("node:path");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("../../generators/utils/json");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+async function update(tree) {
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    // Note: Any's have been used as LegacyVersioning Options have been removed
+    function updateProperties(versionConfig) {
+        // These options used to live inside of generatorOptions, but are now like for like top-level nx core options
+        const coreOptionsToPromoteToTopLevel = [
+            'specifierSource',
+            'currentVersionResolver',
+            'currentVersionResolverMetadata',
+            'fallbackCurrentVersionResolver',
+            'versionPrefix',
+            'updateDependents',
+            'logUnchangedProjects',
+        ];
+        if ('generatorOptions' in versionConfig) {
+            for (const option of coreOptionsToPromoteToTopLevel) {
+                if (versionConfig.generatorOptions[option]) {
+                    versionConfig[option] = versionConfig.generatorOptions[option];
+                }
+            }
+            // preserveLocalDependencyProtocols has changed to true by default, so remove it if explicitly true, otherwise set to false explicitly
+            if (versionConfig.generatorOptions.preserveLocalDependencyProtocols) {
+                delete versionConfig.generatorOptions.preserveLocalDependencyProtocols;
+            }
+            else {
+                versionConfig.preserveLocalDependencyProtocols = false;
+            }
+            // packageRoot has been replaced by manifestRootsToUpdate
+            if (typeof versionConfig.generatorOptions.packageRoot === 'string') {
+                versionConfig.manifestRootsToUpdate =
+                    [versionConfig.generatorOptions.packageRoot];
+                delete versionConfig.generatorOptions.packageRoot;
+            }
+            // These options have been moved to versionActionsOptions
+            const versionActionsOptions = [
+                'skipLockFileUpdate',
+                'installArgs',
+                'installIgnoreScripts',
+            ];
+            for (const option of versionActionsOptions) {
+                if (versionConfig.generatorOptions[option]) {
+                    versionConfig.versionActionsOptions =
+                        versionConfig
+                            .versionActionsOptions || {};
+                    versionConfig.versionActionsOptions[option] =
+                        versionConfig.generatorOptions[option];
+                    delete versionConfig.generatorOptions[option];
+                }
+            }
+            delete versionConfig.generatorOptions;
+        }
+    }
+    // nx.json
+    if (nxJson.release) {
+        // Top level version config
+        if (nxJson.release.version) {
+            updateProperties(nxJson.release.version);
+        }
+        // Version config for each group
+        if (nxJson.release.groups) {
+            for (const group of Object.values(nxJson.release.groups)) {
+                if (group.version) {
+                    updateProperties(group.version);
+                }
+            }
+        }
+    }
+    // project.json or package.json
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    for (const project of projects.values()) {
+        const projectJsonPath = (0, node_path_1.join)(project.root, 'project.json');
+        if (tree.exists(projectJsonPath)) {
+            const projectJson = (0, json_1.readJson)(tree, projectJsonPath);
+            if (projectJson.release?.version) {
+                updateProperties(projectJson.release.version);
+                (0, json_1.writeJson)(tree, projectJsonPath, projectJson);
+            }
+        }
+        const packageJsonPath = (0, node_path_1.join)(project.root, 'package.json');
+        if (tree.exists(packageJsonPath)) {
+            const packageJson = (0, json_1.readJson)(tree, packageJsonPath);
+            if (packageJson.nx?.release?.version) {
+                updateProperties(packageJson.nx.release.version);
+                (0, json_1.writeJson)(tree, packageJsonPath, packageJson);
+            }
+        }
+    }
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/src/migrations/update-22-1-0/update-nx-wrapper.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '../../generators/tree';
+export default function (tree: Tree): Promise<void>;
+//# sourceMappingURL=update-nx-wrapper.d.ts.map

package/src/migrations/update-22-1-0/update-nx-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-nx-wrapper.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/migrations/update-22-1-0/update-nx-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAGlD,yBAA+B,IAAI,EAAE,IAAI,iBAExC"}

package/src/migrations/update-22-1-0/update-nx-wrapper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const update_nxw_1 = require("../../utils/update-nxw");
+async function default_1(tree) {
+    (0, update_nxw_1.updateNxw)(tree);
+}

package/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '../../generators/tree';
+export default function addPolygraphToGitIgnore(tree: Tree): void;
+//# sourceMappingURL=add-polygraph-to-git-ignore.d.ts.map

package/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-polygraph-to-git-ignore.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,IAAI,EAAE,IAAI,QASzD"}

package/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addPolygraphToGitIgnore;
+const ignore_1 = require("../../utils/ignore");
+function addPolygraphToGitIgnore(tree) {
+    if (!tree.exists('.gitignore')) {
+        return;
+    }
+    // Lerna users that don't use nx.json may not expect .nx directory changes
+    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/polygraph');
+}

package/src/native/assert-supported-platform.d.ts

@@ -0,0 +1,2 @@
+export declare function assertSupportedPlatform(): void;
+//# sourceMappingURL=assert-supported-platform.d.ts.map

package/src/native/assert-supported-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-supported-platform.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/native/assert-supported-platform.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,SAqCtC"}

package/src/native/assert-supported-platform.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedPlatform = assertSupportedPlatform;
+const output_1 = require("../utils/output");
+function assertSupportedPlatform() {
+    try {
+        require('./index.js');
+    }
+    catch (e) {
+        let title = '';
+        let bodyLines = [];
+        if (process.platform == 'win32' ||
+            process.platform == 'darwin' ||
+            process.platform == 'linux' ||
+            process.platform == 'freebsd') {
+            title = 'Missing Platform Dependency';
+            bodyLines = [
+                `The Nx CLI could not find or load the native binary for your supported platform (${process.platform}-${process.arch}).`,
+                'This likely means that optional dependencies were not installed correctly, or your system is missing some system dependencies.',
+            ];
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                bodyLines.push('', 'Additional error information:', e.message);
+            }
+        }
+        else {
+            title = 'Platform not supported';
+            bodyLines = [
+                `This platform (${process.platform}-${process.arch}) is currently not supported by Nx.`,
+            ];
+        }
+        bodyLines.push('For more information please see https://nx.dev/troubleshooting/troubleshoot-nx-install-issues');
+        output_1.output.error({
+            title,
+            bodyLines,
+        });
+        process.exit(1);
+    }
+}

package/src/native/browser.js

@@ -0,0 +1 @@
+export * from '@nx/nx-wasm32-wasi'

package/src/native/index.js

@@ -0,0 +1,173 @@
+const { join, basename } = require('path');
+const {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+} = require('fs');
+const Module = require('module');
+const { nxVersion } = require('../utils/versions');
+const { getNativeFileCacheLocation } = require('./native-file-cache-location');
+
+const MAX_COPY_RETRIES = 3;
+
+// WASI is still experimental and throws a warning when used
+// We spawn many many processes so the warning gets printed a lot
+// We have a different warning elsewhere to warn people using WASI
+const originalEmit = process.emit;
+process.emit = function (eventName, eventData) {
+  if (
+    eventName === `warning` &&
+    typeof eventData === `object` &&
+    eventData?.name === `ExperimentalWarning` &&
+    eventData?.message?.includes(`WASI`)
+  ) {
+    return false;
+  }
+  return originalEmit.apply(process, arguments);
+};
+
+const nxPackages = new Set([
+  '@nx/nx-android-arm64',
+  '@nx/nx-android-arm-eabi',
+  '@nx/nx-win32-x64-msvc',
+  '@nx/nx-win32-ia32-msvc',
+  '@nx/nx-win32-arm64-msvc',
+  '@nx/nx-darwin-universal',
+  '@nx/nx-darwin-x64',
+  '@nx/nx-darwin-arm64',
+  '@nx/nx-freebsd-x64',
+  '@nx/nx-linux-x64-musl',
+  '@nx/nx-linux-x64-gnu',
+  '@nx/nx-linux-arm64-musl',
+  '@nx/nx-linux-arm64-gnu',
+  '@nx/nx-linux-arm-gnueabihf',
+]);
+
+const localNodeFiles = [
+  'nx.android-arm64.node',
+  'nx.android-arm-eabi.node',
+  'nx.win32-x64-msvc.node',
+  'nx.win32-ia32-msvc.node',
+  'nx.win32-arm64-msvc.node',
+  'nx.darwin-universal.node',
+  'nx.darwin-x64.node',
+  'nx.darwin-arm64.node',
+  'nx.freebsd-x64.node',
+  'nx.linux-x64-musl.node',
+  'nx.linux-x64-gnu.node',
+  'nx.linux-arm64-musl.node',
+  'nx.linux-arm64-gnu.node',
+  'nx.linux-arm-gnueabihf.node',
+];
+
+const originalLoad = Module._load;
+
+function statsOrNull(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function isNoExecError(e) {
+  return e.code === 'EACCES' || e.code === 'EPERM';
+}
+
+// We override the _load function so that when a native file is required,
+// we copy it to a cache directory and require it from there.
+// This prevents the file being loaded from node_modules and causing file locking issues.
+// Will only be called once because the require cache takes over afterwards.
+Module._load = function (request, parent, isMain) {
+  const modulePath = request;
+  // Check if we should use the native file cache (enabled by default)
+  const useNativeFileCache = process.env.NX_SKIP_NATIVE_FILE_CACHE !== 'true';
+  // Check if this is an Nx native module (either from npm or local file)
+  const isNxNativeModule =
+    nxPackages.has(modulePath) ||
+    localNodeFiles.some((file) => modulePath.endsWith(file));
+
+  // Only use the file cache for Nx native modules when caching is enabled
+  if (useNativeFileCache && isNxNativeModule) {
+    const nativeLocation = require.resolve(modulePath);
+    const fileName = basename(nativeLocation);
+
+    // we copy the file to a workspace-scoped tmp directory and prefix with nxVersion to avoid stale files being loaded
+    const nativeFileCacheLocation = getNativeFileCacheLocation();
+    // This is a path to copy to, not the one that gets loaded
+    const tmpTmpFile = join(
+      nativeFileCacheLocation,
+      nxVersion + '-' + Math.random() + fileName
+    );
+    // This is the path that will get loaded
+    const tmpFile = join(nativeFileCacheLocation, nxVersion + '-' + fileName);
+    const expectedFileSize = statSync(nativeLocation).size;
+    const existingFileStats = statsOrNull(tmpFile);
+
+    // If the file to be loaded already exists, just load it
+    if (existingFileStats?.size === expectedFileSize) {
+      try {
+        return originalLoad.apply(this, [tmpFile, parent, isMain]);
+      } catch (e) {
+        // If loading from cache fails due to noexec, fall back to original location
+        if (isNoExecError(e)) {
+          return originalLoad.apply(this, [nativeLocation, parent, isMain]);
+        }
+        throw e;
+      }
+    }
+    if (!existsSync(nativeFileCacheLocation)) {
+      mkdirSync(nativeFileCacheLocation, { recursive: true });
+    }
+
+    // Retry copying up to 3 times, validating after each copy
+    for (let attempt = 1; attempt <= MAX_COPY_RETRIES; attempt++) {
+      // First copy to a unique location for each process
+      copyFileSync(nativeLocation, tmpTmpFile);
+
+      // Validate the copy - check file size matches expected
+      const copiedFileStats = statsOrNull(tmpTmpFile);
+      if (copiedFileStats?.size === expectedFileSize) {
+        // Copy succeeded, rename to final location and load
+        renameSync(tmpTmpFile, tmpFile);
+        try {
+          return originalLoad.apply(this, [tmpFile, parent, isMain]);
+        } catch (e) {
+          // If loading from cache fails due to noexec, fall back to original location
+          if (isNoExecError(e)) {
+            return originalLoad.apply(this, [nativeLocation, parent, isMain]);
+          }
+          throw e;
+        }
+      }
+
+      // Copy failed validation, clean up the malformed file
+      try {
+        unlinkSync(tmpTmpFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+
+    // All retries failed - warn and load from original location
+    console.warn(
+      `Warning: Failed to copy native module to cache after ${MAX_COPY_RETRIES} attempts. ` +
+        `Loading from original location instead. ` +
+        `This may cause file locking issues on Windows.`
+    );
+    return originalLoad.apply(this, [nativeLocation, parent, isMain]);
+  } else {
+    // call the original _load function for everything else
+    return originalLoad.apply(this, arguments);
+  }
+};
+
+const indexModulePath = require.resolve('./native-bindings.js');
+delete require.cache[indexModulePath];
+const indexModule = require('./native-bindings.js');
+
+module.exports = indexModule;
+Module._load = originalLoad;