@nx/js 0.0.0-pr-22179-271588f

package/src/executors/node/node.impl.d.ts

@@ -0,0 +1,7 @@
+import { ExecutorContext } from '@nx/devkit';
+import { NodeExecutorOptions } from './schema';
+export declare function nodeExecutor(options: NodeExecutorOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    options?: Record<string, any>;
+}, void, undefined>;
+export default nodeExecutor;

package/src/executors/node/node.impl.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeExecutor = void 0;
+const chalk = require("chalk");
+const child_process_1 = require("child_process");
+const devkit_1 = require("@nx/devkit");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const client_1 = require("nx/src/daemon/client/client");
+const crypto_1 = require("crypto");
+const path = require("path");
+const path_1 = require("path");
+const buildable_libs_utils_1 = require("../../utils/buildable-libs-utils");
+const kill_tree_1 = require("./lib/kill-tree");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const get_main_file_dir_1 = require("../../utils/get-main-file-dir");
+function debounce(fn, wait) {
+    let timeoutId;
+    return () => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(fn, wait);
+    };
+}
+async function* nodeExecutor(options, context) {
+    process.env.NODE_ENV ??= context?.configurationName ?? 'development';
+    const project = context.projectGraph.nodes[context.projectName];
+    const buildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+    if (!project.data.targets[buildTarget.target]) {
+        throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
+    }
+    const buildTargetExecutor = project.data.targets[buildTarget.target]?.executor;
+    if (buildTargetExecutor === 'nx:run-commands' ||
+        buildTargetExecutor === '@nrwl/workspace:run-commands') {
+        // Run commands does not emit build event, so we have to switch to run entire build through Nx CLI.
+        options.runBuildTargetDependencies = true;
+    }
+    const buildOptions = {
+        ...(0, devkit_1.readTargetOptions)(buildTarget, context),
+        ...options.buildTargetOptions,
+    };
+    if (options.waitUntilTargets && options.waitUntilTargets.length > 0) {
+        const results = await runWaitUntilTargets(options, context);
+        for (const [i, result] of results.entries()) {
+            if (!result.success) {
+                throw new Error(`Wait until target failed: ${options.waitUntilTargets[i]}.`);
+            }
+        }
+    }
+    // Re-map buildable workspace projects to their output directory.
+    const mappings = calculateResolveMappings(context, options);
+    const fileToRun = getFileToRun(context, project, buildOptions, buildTargetExecutor);
+    let additionalExitHandler = null;
+    let currentTask = null;
+    const tasks = [];
+    yield* (0, async_iterable_1.createAsyncIterable)(async ({ done, next, error }) => {
+        const processQueue = async () => {
+            if (tasks.length === 0)
+                return;
+            const previousTask = currentTask;
+            const task = tasks.shift();
+            currentTask = task;
+            await previousTask?.stop('SIGTERM');
+            await task.start();
+        };
+        const debouncedProcessQueue = debounce(processQueue, options.debounce ?? 1000);
+        const addToQueue = async (childProcess, buildResult) => {
+            const task = {
+                id: (0, crypto_1.randomUUID)(),
+                killed: false,
+                childProcess,
+                promise: null,
+                start: async () => {
+                    // Wait for build to finish.
+                    const result = await buildResult;
+                    if (!result.success) {
+                        // If in watch-mode, don't throw or else the process exits.
+                        if (options.watch) {
+                            if (!task.killed) {
+                                // Only log build error if task was not killed by a new change.
+                                devkit_1.logger.error(`Build failed, waiting for changes to restart...`);
+                            }
+                            return;
+                        }
+                        else {
+                            throw new Error(`Build failed. See above for errors.`);
+                        }
+                    }
+                    // Before running the program, check if the task has been killed (by a new change during watch).
+                    if (task.killed)
+                        return;
+                    // Run the program
+                    task.promise = new Promise((resolve, reject) => {
+                        task.childProcess = (0, child_process_1.fork)((0, devkit_1.joinPathFragments)(__dirname, 'node-with-require-overrides'), options.args ?? [], {
+                            execArgv: getExecArgv(options),
+                            stdio: [0, 1, 'pipe', 'ipc'],
+                            env: {
+                                ...process.env,
+                                NX_FILE_TO_RUN: fileToRunCorrectPath(fileToRun),
+                                NX_MAPPINGS: JSON.stringify(mappings),
+                            },
+                        });
+                        const handleStdErr = (data) => {
+                            // Don't log out error if task is killed and new one has started.
+                            // This could happen if a new build is triggered while new process is starting, since the operation is not atomic.
+                            // Log the error in normal mode
+                            if (!options.watch || !task.killed) {
+                                devkit_1.logger.error(data.toString());
+                            }
+                        };
+                        task.childProcess.stderr.on('data', handleStdErr);
+                        task.childProcess.once('exit', (code) => {
+                            task.childProcess.off('data', handleStdErr);
+                            if (options.watch && !task.killed) {
+                                devkit_1.logger.info(`NX Process exited with code ${code}, waiting for changes to restart...`);
+                            }
+                            if (!options.watch)
+                                done();
+                            resolve();
+                        });
+                        next({ success: true, options: buildOptions });
+                    });
+                },
+                stop: async (signal = 'SIGTERM') => {
+                    task.killed = true;
+                    // Request termination and wait for process to finish gracefully.
+                    // NOTE: `childProcess` may not have been set yet if the task did not have a chance to start.
+                    // e.g. multiple file change events in a short time (like git checkout).
+                    if (task.childProcess) {
+                        await (0, kill_tree_1.killTree)(task.childProcess.pid, signal);
+                    }
+                    try {
+                        await task.promise;
+                    }
+                    catch {
+                        // Doesn't matter if task fails, we just need to wait until it finishes.
+                    }
+                },
+            };
+            tasks.push(task);
+        };
+        if (options.runBuildTargetDependencies) {
+            // If a all dependencies need to be rebuild on changes, then register with watcher
+            // and run through CLI, otherwise only the current project will rebuild.
+            const runBuild = async () => {
+                let childProcess = null;
+                const whenReady = new Promise(async (resolve) => {
+                    childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
+                        'run',
+                        `${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`,
+                    ], {
+                        cwd: context.root,
+                        stdio: 'inherit',
+                    });
+                    childProcess.once('exit', (code) => {
+                        if (code === 0)
+                            resolve({ success: true });
+                        // If process is killed due to current task being killed, then resolve with success.
+                        else
+                            resolve({ success: !!currentTask?.killed });
+                    });
+                });
+                await addToQueue(childProcess, whenReady);
+                await debouncedProcessQueue();
+            };
+            additionalExitHandler = await client_1.daemonClient.registerFileWatcher({
+                watchProjects: [context.projectName],
+                includeDependentProjects: true,
+            }, async (err, data) => {
+                if (err === 'closed') {
+                    devkit_1.logger.error(`Watch error: Daemon closed the connection`);
+                    process.exit(1);
+                }
+                else if (err) {
+                    devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
+                }
+                else {
+                    devkit_1.logger.info(`NX File change detected. Restarting...`);
+                    await runBuild();
+                }
+            });
+            await runBuild(); // run first build
+        }
+        else {
+            // Otherwise, run the build executor, which will not run task dependencies.
+            // This is mostly fine for bundlers like webpack that should already watch for dependency libs.
+            // For tsc/swc or custom build commands, consider using `runBuildTargetDependencies` instead.
+            const output = await (0, devkit_1.runExecutor)(buildTarget, {
+                ...options.buildTargetOptions,
+                watch: options.watch,
+            }, context);
+            while (true) {
+                const event = await output.next();
+                await addToQueue(null, Promise.resolve(event.value));
+                await debouncedProcessQueue();
+                if (event.done || !options.watch) {
+                    break;
+                }
+            }
+        }
+        const stopAllTasks = (signal = 'SIGTERM') => {
+            additionalExitHandler?.();
+            for (const task of tasks) {
+                task.stop(signal);
+            }
+        };
+        process.on('SIGTERM', async () => {
+            stopAllTasks('SIGTERM');
+            process.exit(128 + 15);
+        });
+        process.on('SIGINT', async () => {
+            stopAllTasks('SIGINT');
+            process.exit(128 + 2);
+        });
+        process.on('SIGHUP', async () => {
+            stopAllTasks('SIGHUP');
+            process.exit(128 + 1);
+        });
+    });
+}
+exports.nodeExecutor = nodeExecutor;
+function getExecArgv(options) {
+    const args = (options.runtimeArgs ??= []);
+    args.push('-r', require.resolve('source-map-support/register'));
+    if (options.inspect === true) {
+        options.inspect = "inspect" /* InspectType.Inspect */;
+    }
+    if (options.inspect) {
+        args.push(`--${options.inspect}=${options.host}:${options.port}`);
+    }
+    return args;
+}
+function calculateResolveMappings(context, options) {
+    const parsed = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, parsed.project, parsed.target, parsed.configuration);
+    return dependencies.reduce((m, c) => {
+        if (c.node.type !== 'npm' && c.outputs[0] != null) {
+            m[c.name] = (0, devkit_1.joinPathFragments)(context.root, c.outputs[0]);
+        }
+        return m;
+    }, {});
+}
+function runWaitUntilTargets(options, context) {
+    return Promise.all(options.waitUntilTargets.map(async (waitUntilTarget) => {
+        const target = (0, devkit_1.parseTargetString)(waitUntilTarget, context);
+        const output = await (0, devkit_1.runExecutor)(target, {}, context);
+        return new Promise(async (resolve) => {
+            let event = await output.next();
+            // Resolve after first event
+            resolve(event.value);
+            // Continue iterating
+            while (!event.done) {
+                event = await output.next();
+            }
+        });
+    }));
+}
+function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
+    // If using run-commands or another custom executor, then user should set
+    // outputFileName, but we can try the default value that we use.
+    if (!buildOptions?.outputPath && !buildOptions?.outputFileName) {
+        const fallbackFile = path.join('dist', project.data.root, 'main.js');
+        devkit_1.logger.warn(`Build option ${chalk.bold('outputFileName')} not set for ${chalk.bold(project.name)}. Using fallback value of ${chalk.bold(fallbackFile)}.`);
+        return (0, path_1.join)(context.root, fallbackFile);
+    }
+    let outputFileName = buildOptions.outputFileName;
+    if (!outputFileName) {
+        const fileName = `${path.parse(buildOptions.main).name}.js`;
+        if (buildTargetExecutor === '@nx/js:tsc' ||
+            buildTargetExecutor === '@nx/js:swc') {
+            outputFileName = path.join((0, get_main_file_dir_1.getRelativeDirectoryToProjectRoot)(buildOptions.main, project.data.root), fileName);
+        }
+        else {
+            outputFileName = fileName;
+        }
+    }
+    return (0, path_1.join)(context.root, buildOptions.outputPath, outputFileName);
+}
+function fileToRunCorrectPath(fileToRun) {
+    if ((0, fileutils_1.fileExists)(fileToRun))
+        return fileToRun;
+    const extensionsToTry = ['.cjs', '.mjs', 'cjs.js', '.esm.js'];
+    for (const ext of extensionsToTry) {
+        const file = fileToRun.replace(/\.js$/, ext);
+        if ((0, fileutils_1.fileExists)(file))
+            return file;
+    }
+    throw new Error(`Could not find ${fileToRun}. Make sure your build succeeded.`);
+}
+exports.default = nodeExecutor;

package/src/executors/node/schema.d.ts

@@ -0,0 +1,18 @@
+export const enum InspectType {
+  Inspect = 'inspect',
+  InspectBrk = 'inspect-brk',
+}
+
+export interface NodeExecutorOptions {
+  inspect: boolean | InspectType;
+  runtimeArgs: string[];
+  args: string[];
+  waitUntilTargets: string[];
+  buildTarget: string;
+  buildTargetOptions: Record<string, any>;
+  host: string;
+  port: number;
+  watch?: boolean;
+  debounce?: number;
+  runBuildTargetDependencies?: boolean;
+}

package/src/executors/node/schema.json

@@ -0,0 +1,92 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "title": "Node executor",
+  "description": "Execute Nodejs applications.",
+  "type": "object",
+  "properties": {
+    "buildTarget": {
+      "type": "string",
+      "description": "The target to run to build you the app."
+    },
+    "buildTargetOptions": {
+      "type": "object",
+      "description": "Additional options to pass into the build target.",
+      "default": {}
+    },
+    "waitUntilTargets": {
+      "type": "array",
+      "description": "The targets to run before starting the node app. Listed in the form <project>:<target>. The main target will run once all listed targets have output something to the console.",
+      "default": [],
+      "items": {
+        "type": "string"
+      }
+    },
+    "host": {
+      "type": "string",
+      "default": "localhost",
+      "description": "The host to inspect the process on.",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "default": 9229,
+      "description": "The port to inspect the process on. Setting port to 0 will assign random free ports to all forked processes.",
+      "x-priority": "important"
+    },
+    "inspect": {
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["inspect", "inspect-brk"]
+        },
+        {
+          "type": "boolean"
+        }
+      ],
+      "description": "Ensures the app is starting with debugging.",
+      "default": "inspect",
+      "x-priority": "important"
+    },
+    "runtimeArgs": {
+      "type": "array",
+      "description": "Extra args passed to the node process.",
+      "default": [],
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
+    },
+    "args": {
+      "type": "array",
+      "description": "Extra args when starting the app.",
+      "default": [],
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Enable re-building when files change.",
+      "default": true,
+      "x-priority": "important"
+    },
+    "debounce": {
+      "type": "number",
+      "description": "Delay in milliseconds to wait before restarting. Useful to batch multiple file changes events together. Set to zero (0) to disable.",
+      "default": 500,
+      "x-priority": "important"
+    },
+    "runBuildTargetDependencies": {
+      "type": "boolean",
+      "description": "Whether to run dependencies before running the build. Set this to true if the project does not build libraries from source (e.g. 'buildLibsFromSource: false').",
+      "default": false
+    }
+  },
+  "additionalProperties": false,
+  "required": ["buildTarget"],
+  "examplesFile": "../../../docs/node-examples.md"
+}

package/src/executors/release-publish/format-bytes.d.ts

@@ -0,0 +1 @@
+export declare const formatBytes: (bytes: any, space?: boolean) => string;

package/src/executors/release-publish/format-bytes.js

@@ -0,0 +1,28 @@
+"use strict";
+// Taken from https://github.com/npm/cli/blob/c736b622b8504b07f5a19f631ade42dd40063269/lib/utils/format-bytes.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = void 0;
+// Convert bytes to printable output, for file reporting in tarballs
+// Only supports up to GB because that's way larger than anything the registry
+// supports anyways.
+const formatBytes = (bytes, space = true) => {
+    let spacer = '';
+    if (space) {
+        spacer = ' ';
+    }
+    if (bytes < 1000) {
+        // B
+        return `${bytes}${spacer}B`;
+    }
+    if (bytes < 1000000) {
+        // kB
+        return `${(bytes / 1000).toFixed(1)}${spacer}kB`;
+    }
+    if (bytes < 1000000000) {
+        // MB
+        return `${(bytes / 1000000).toFixed(1)}${spacer}MB`;
+    }
+    // GB
+    return `${(bytes / 1000000000).toFixed(1)}${spacer}GB`;
+};
+exports.formatBytes = formatBytes;

package/src/executors/release-publish/log-tar.d.ts

@@ -0,0 +1 @@
+export declare const logTar: (tarball: any, opts?: {}) => void;

package/src/executors/release-publish/log-tar.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTar = void 0;
+// Adapted from https://github.com/npm/cli/blob/c736b622b8504b07f5a19f631ade42dd40063269/lib/utils/tar.js
+const chalk = require("chalk");
+const columnify = require("columnify");
+const format_bytes_1 = require("./format-bytes");
+const logTar = (tarball, opts = {}) => {
+    // @ts-ignore
+    const { unicode = true } = opts;
+    console.log('');
+    console.log(`${unicode ? '📦 ' : 'package:'} ${tarball.name}@${tarball.version}`);
+    console.log(chalk.magenta('=== Tarball Contents ==='));
+    if (tarball.files.length) {
+        console.log('');
+        const columnData = columnify(tarball.files
+            .map((f) => {
+            const bytes = (0, format_bytes_1.formatBytes)(f.size, false);
+            return /^node_modules\//.test(f.path)
+                ? null
+                : { path: f.path, size: `${bytes}` };
+        })
+            .filter((f) => f), {
+            include: ['size', 'path'],
+            showHeaders: false,
+        });
+        columnData.split('\n').forEach((line) => {
+            console.log(line);
+        });
+    }
+    if (tarball.bundled.length) {
+        console.log(chalk.magenta('=== Bundled Dependencies ==='));
+        tarball.bundled.forEach((name) => console.log('', name));
+    }
+    console.log(chalk.magenta('=== Tarball Details ==='));
+    console.log(columnify([
+        { name: 'name:', value: tarball.name },
+        { name: 'version:', value: tarball.version },
+        tarball.filename && { name: 'filename:', value: tarball.filename },
+        { name: 'package size:', value: (0, format_bytes_1.formatBytes)(tarball.size) },
+        { name: 'unpacked size:', value: (0, format_bytes_1.formatBytes)(tarball.unpackedSize) },
+        { name: 'shasum:', value: tarball.shasum },
+        {
+            name: 'integrity:',
+            value: tarball.integrity.toString().slice(0, 20) +
+                '[...]' +
+                tarball.integrity.toString().slice(80),
+        },
+        tarball.bundled.length && {
+            name: 'bundled deps:',
+            value: tarball.bundled.length,
+        },
+        tarball.bundled.length && {
+            name: 'bundled files:',
+            value: tarball.entryCount - tarball.files.length,
+        },
+        tarball.bundled.length && {
+            name: 'own files:',
+            value: tarball.files.length,
+        },
+        { name: 'total files:', value: tarball.entryCount },
+    ].filter((x) => x), {
+        include: ['name', 'value'],
+        showHeaders: false,
+    }));
+    console.log('', '');
+};
+exports.logTar = logTar;

package/src/executors/release-publish/release-publish.impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { PublishExecutorSchema } from './schema';
+export default function runExecutor(options: PublishExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;