@nx/js 16.8.0-beta.3 → 16.8.0-beta.5

package/babel.js

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 module.exports = function (api, options = {}) {
-    var _a, _b, _c;
     api.assertVersion(7);
-    const isModern = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isModern);
+    const isModern = api.caller((caller) => caller?.isModern);
     // use by @nx/cypress react component testing to prevent core js build issues
-    const isTest = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isTest);
+    const isTest = api.caller((caller) => caller?.isTest);
     // This is set by `@nx/rollup:rollup` executor
-    const isNxPackage = api.caller((caller) => caller === null || caller === void 0 ? void 0 : caller.isNxPackage);
-    const emitDecoratorMetadata = api.caller((caller) => { var _a; return (_a = caller === null || caller === void 0 ? void 0 : caller.emitDecoratorMetadata) !== null && _a !== void 0 ? _a : true; });
+    const isNxPackage = api.caller((caller) => caller?.isNxPackage);
+    const emitDecoratorMetadata = api.caller((caller) => caller?.emitDecoratorMetadata ?? true);
     // Determine settings  for `@babel/plugin-proposal-class-properties`,
     // so that we can sync the `loose` option with `@babel/preset-env`.
-    const classProperties = (_a = options.classProperties) !== null && _a !== void 0 ? _a : { loose: true };
+    const classProperties = options.classProperties ?? { loose: true };
     return {
         presets: [
             // Support module/nomodule pattern.
@@ -25,7 +24,7 @@ module.exports = function (api, options = {}) {
                     ? { targets: { node: 'current' }, loose: true }
                     : {
                         // Allow importing core-js in entrypoint and use browserslist to select polyfills.
-                        useBuiltIns: (_b = options.useBuiltIns) !== null && _b !== void 0 ? _b : 'entry',
+                        useBuiltIns: options.useBuiltIns ?? 'entry',
                         corejs: 3,
                         // Do not transform modules to CJS
                         modules: false,
@@ -64,7 +63,7 @@ module.exports = function (api, options = {}) {
             // Must use legacy decorators to remain compatible with TypeScript.
             [
                 require.resolve('@babel/plugin-proposal-decorators'),
-                (_c = options.decorators) !== null && _c !== void 0 ? _c : { legacy: true },
+                options.decorators ?? { legacy: true },
             ],
             [
                 require.resolve('@babel/plugin-proposal-class-properties'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.8.0-beta.3",
+  "version": "16.8.0-beta.5",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,9 +39,9 @@
     "@babel/preset-env": "^7.22.9",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nrwl/js": "16.8.0-beta.3",
-    "@nx/devkit": "16.8.0-beta.3",
-    "@nx/workspace": "16.8.0-beta.3",
+    "@nrwl/js": "16.8.0-beta.5",
+    "@nx/devkit": "16.8.0-beta.5",
+    "@nx/workspace": "16.8.0-beta.5",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -71,5 +71,5 @@
     "access": "public"
   },
   "type": "commonjs",
-  "gitHead": "dcd48165a485bc8db57a1fb02b96a0772de3b7e9"
+  "gitHead": "ad2d1e8a55b2d1b358bb5e7483343d9757ff2c53"
 }

package/src/executors/node/lib/kill-tree.js

@@ -1,54 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.killTree = void 0;
-const tslib_1 = require("tslib");
 // Adapted from https://raw.githubusercontent.com/pkrumins/node-tree-kill/deee138/index.js
 const child_process_1 = require("child_process");
-function killTree(pid, signal) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const tree = {};
-        const pidsToProcess = {};
-        tree[pid] = [];
-        pidsToProcess[pid] = 1;
-        return new Promise((resolve, reject) => {
-            const callback = (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            };
-            switch (process.platform) {
-                case 'win32':
-                    (0, child_process_1.exec)('taskkill /pid ' + pid + ' /T /F', (error) => {
-                        // Ignore Fatal errors (128) because it might be due to the process already being killed.
-                        // On Linux/Mac we can check ESRCH (no such process), but on Windows we can't.
-                        callback((error === null || error === void 0 ? void 0 : error.code) !== 128 ? error : null);
-                    });
-                    break;
-                case 'darwin':
-                    buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                        return (0, child_process_1.spawn)('pgrep', ['-P', parentPid]);
-                    }, function () {
-                        killAll(tree, signal, callback);
-                    });
-                    break;
-                default: // Linux
-                    buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                        return (0, child_process_1.spawn)('ps', [
-                            '-o',
-                            'pid',
-                            '--no-headers',
-                            '--ppid',
-                            parentPid,
-                        ]);
-                    }, function () {
-                        killAll(tree, signal, callback);
-                    });
-                    break;
+async function killTree(pid, signal) {
+    const tree = {};
+    const pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+    return new Promise((resolve, reject) => {
+        const callback = (error) => {
+            if (error) {
+                reject(error);
             }
-        });
+            else {
+                resolve();
+            }
+        };
+        switch (process.platform) {
+            case 'win32':
+                (0, child_process_1.exec)('taskkill /pid ' + pid + ' /T /F', (error) => {
+                    // Ignore Fatal errors (128) because it might be due to the process already being killed.
+                    // On Linux/Mac we can check ESRCH (no such process), but on Windows we can't.
+                    callback(error?.code !== 128 ? error : null);
+                });
+                break;
+            case 'darwin':
+                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+                    return (0, child_process_1.spawn)('pgrep', ['-P', parentPid]);
+                }, function () {
+                    killAll(tree, signal, callback);
+                });
+                break;
+            default: // Linux
+                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+                    return (0, child_process_1.spawn)('ps', [
+                        '-o',
+                        'pid',
+                        '--no-headers',
+                        '--ppid',
+                        parentPid,
+                    ]);
+                }, function () {
+                    killAll(tree, signal, callback);
+                });
+                break;
+        }
     });
 }
 exports.killTree = killTree;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeExecutor = void 0;
-const tslib_1 = require("tslib");
 const chalk = require("chalk");
 const child_process_1 = require("child_process");
 const devkit_1 = require("@nx/devkit");
@@ -21,203 +20,205 @@ function debounce(fn, wait) {
         timeoutId = setTimeout(fn, wait);
     };
 }
-function nodeExecutor(options, context) {
-    var _a, _b, _c;
-    var _d;
-    return tslib_1.__asyncGenerator(this, arguments, function* nodeExecutor_1() {
-        (_a = (_d = process.env).NODE_ENV) !== null && _a !== void 0 ? _a : (_d.NODE_ENV = (_b = context === null || context === void 0 ? void 0 : context.configurationName) !== null && _b !== void 0 ? _b : 'development');
-        const project = context.projectGraph.nodes[context.projectName];
-        const buildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph);
-        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 = (_c = project.data.targets[buildTarget.target]) === null || _c === void 0 ? void 0 : _c.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 = Object.assign(Object.assign({}, (0, devkit_1.readTargetOptions)(buildTarget, context)), options.buildTargetOptions);
-        if (options.waitUntilTargets && options.waitUntilTargets.length > 0) {
-            const results = yield tslib_1.__await(runWaitUntilTargets(options, context));
-            for (const [i, result] of results.entries()) {
-                if (!result.success) {
-                    throw new Error(`Wait until target failed: ${options.waitUntilTargets[i]}.`);
-                }
+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.projectGraph);
+    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 tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _e;
-            const processQueue = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                if (tasks.length === 0)
-                    return;
-                const previousTask = currentTask;
-                const task = tasks.shift();
-                currentTask = task;
-                yield (previousTask === null || previousTask === void 0 ? void 0 : previousTask.stop('SIGTERM'));
-                yield task.start();
-            });
-            const debouncedProcessQueue = debounce(processQueue, (_e = options.debounce) !== null && _e !== void 0 ? _e : 1000);
-            const addToQueue = (childProcess, buildResult) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                const task = {
-                    id: (0, crypto_1.randomUUID)(),
-                    killed: false,
-                    childProcess,
-                    promise: null,
-                    start: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        // Wait for build to finish.
-                        const result = yield 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.`);
+    }
+    // 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...`);
                             }
-                        }
-                        // 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) => {
-                            var _a;
-                            task.childProcess = (0, child_process_1.fork)((0, devkit_1.joinPathFragments)(__dirname, 'node-with-require-overrides'), (_a = options.args) !== null && _a !== void 0 ? _a : [], {
-                                execArgv: getExecArgv(options),
-                                stdio: [0, 1, 'pipe', 'ipc'],
-                                env: Object.assign(Object.assign({}, 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: (signal = 'SIGTERM') => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        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) {
-                            yield (0, kill_tree_1.killTree)(task.childProcess.pid, signal);
-                        }
-                        try {
-                            yield task.promise;
                         }
-                        catch (_f) {
-                            // Doesn't matter if task fails, we just need to wait until it finishes.
+                        else {
+                            throw new Error(`Build failed. See above for errors.`);
                         }
-                    }),
-                };
-                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 = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    let childProcess = null;
-                    const whenReady = new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
-                            'run',
-                            `${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`,
-                        ], {
-                            cwd: context.root,
-                            stdio: 'inherit',
+                    }
+                    // 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),
+                            },
                         });
-                        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 === null || currentTask === void 0 ? void 0 : currentTask.killed) });
+                        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();
                         });
-                    }));
-                    yield addToQueue(childProcess, whenReady);
-                    yield debouncedProcessQueue();
-                });
-                additionalExitHandler = yield client_1.daemonClient.registerFileWatcher({
-                    watchProjects: [context.projectName],
-                    includeDependentProjects: true,
-                }, (err, data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _g;
-                    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: ${(_g = err === null || err === void 0 ? void 0 : err.message) !== null && _g !== void 0 ? _g : 'Unknown'}`);
+                        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);
                     }
-                    else {
-                        devkit_1.logger.info(`NX File change detected. Restarting...`);
-                        yield runBuild();
+                    try {
+                        await task.promise;
                     }
-                }));
-                yield 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 = yield (0, devkit_1.runExecutor)(buildTarget, Object.assign(Object.assign({}, options.buildTargetOptions), { watch: options.watch }), context);
-                while (true) {
-                    const event = yield output.next();
-                    yield addToQueue(null, Promise.resolve(event.value));
-                    yield debouncedProcessQueue();
-                    if (event.done || !options.watch) {
-                        break;
+                    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);
                 }
-            }
-            const stopAllTasks = (signal = 'SIGTERM') => {
-                additionalExitHandler === null || additionalExitHandler === void 0 ? void 0 : additionalExitHandler();
-                for (const task of tasks) {
-                    task.stop(signal);
+                else if (err) {
+                    devkit_1.logger.error(`Watch error: ${err?.message ?? 'Unknown'}`);
                 }
-            };
-            process.on('SIGTERM', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                stopAllTasks('SIGTERM');
-                process.exit(128 + 15);
-            }));
-            process.on('SIGINT', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                stopAllTasks('SIGINT');
-                process.exit(128 + 2);
-            }));
-            process.on('SIGHUP', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                stopAllTasks('SIGHUP');
-                process.exit(128 + 1);
-            }));
-        })))));
+                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) {
-    var _a;
-    const args = ((_a = options.runtimeArgs) !== null && _a !== void 0 ? _a : (options.runtimeArgs = []));
+    const args = (options.runtimeArgs ??= []);
     args.push('-r', require.resolve('source-map-support/register'));
     if (options.inspect === true) {
         options.inspect = "inspect" /* InspectType.Inspect */;
@@ -238,24 +239,24 @@ function calculateResolveMappings(context, options) {
     }, {});
 }
 function runWaitUntilTargets(options, context) {
-    return Promise.all(options.waitUntilTargets.map((waitUntilTarget) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+    return Promise.all(options.waitUntilTargets.map(async (waitUntilTarget) => {
         const target = (0, devkit_1.parseTargetString)(waitUntilTarget, context.projectGraph);
-        const output = yield (0, devkit_1.runExecutor)(target, {}, context);
-        return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let event = yield output.next();
+        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 = yield output.next();
+                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 === null || buildOptions === void 0 ? void 0 : buildOptions.outputPath) && !(buildOptions === null || buildOptions === void 0 ? void 0 : buildOptions.outputFileName)) {
+    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);

package/src/executors/node/schema.json

@@ -18,7 +18,7 @@
     },
     "waitUntilTargets": {
       "type": "array",
-      "description": "The targets to run before starting the node app.",
+      "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"