nx 20.8.4 → 22.7.7

package/dist/src/utils/find-matching-projects.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMatchingStringsWithCache = void 0;
+exports.findMatchingProjects = findMatchingProjects;
+const minimatch_1 = require("minimatch");
+const globs_1 = require("./globs");
+const validPatternTypes = [
+    'name', // Pattern is based on the project's name
+    'tag', // Pattern is based on the project's tags
+    'directory', // Pattern is based on the project's root directory
+    'unlabeled', // Pattern was passed without specifying a type
+];
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projects A map of {@link ProjectGraphProjectNode} by project name.
+ * @returns
+ */
+function findMatchingProjects(patterns = [], projects) {
+    if (!patterns.length || patterns.filter((p) => p.length).length === 0) {
+        return []; // Short circuit if called with no patterns
+    }
+    const projectNames = Object.keys(projects);
+    const matchedProjects = new Set();
+    // If the first pattern is an exclude pattern,
+    // we add a wildcard pattern at the first to select
+    // all projects, except the ones that match the exclude pattern.
+    // e.g. ['!tag:someTag', 'project2'] will match all projects except
+    // the ones with the tag 'someTag', and also match the project 'project2',
+    // regardless of its tags.
+    if (isExcludePattern(patterns[0])) {
+        patterns.unshift('*');
+    }
+    for (const stringPattern of patterns) {
+        // Do not waste time attempting to look up cross-workspace references which will never match
+        if (!stringPattern.length || stringPattern.startsWith('nx-cloud:')) {
+            continue;
+        }
+        const pattern = parseStringPattern(stringPattern, projects);
+        // Handle wildcard with short-circuit, as its a common case with potentially
+        // large project sets and we can avoid the more expensive glob matching.
+        if (pattern.value === '*') {
+            for (const projectName of projectNames) {
+                if (pattern.exclude) {
+                    matchedProjects.delete(projectName);
+                }
+                else {
+                    matchedProjects.add(projectName);
+                }
+            }
+            continue;
+        }
+        switch (pattern.type) {
+            case 'tag': {
+                addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'name': {
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'directory': {
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            // Same thing as `type:unlabeled`. If no specific type is set,
+            // we can waterfall through the different types until we find a match
+            default: {
+                // The size of the selected and excluded projects set, before we
+                // start updating it with this pattern. If the size changes, we
+                // know we found a match and can skip the other types.
+                const originalSize = matchedProjects.size;
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by name, don't check other types
+                    continue;
+                }
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by directory, don't check other types
+                    // Note - this doesn't do anything currently, but preps for future
+                    // types
+                    continue;
+                }
+            }
+        }
+    }
+    return Array.from(matchedProjects);
+}
+function addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const root = projects[projectName].data.root;
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, [root]).length > 0) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects) {
+    if (projects[pattern.value]) {
+        if (pattern.exclude) {
+            matchedProjects.delete(pattern.value);
+        }
+        else {
+            matchedProjects.add(pattern.value);
+        }
+        return;
+    }
+    if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+        // Custom regex that is basically \b but includes hyphens (-) and excludes underscores (_), so "foo" pattern matches "foo_bar" but not "foo-e2e".
+        const regex = new RegExp(`(?<![@a-zA-Z0-9-])${pattern.value}(?![@a-zA-Z0-9-])`, 'i');
+        const matchingProjects = Object.keys(projects).filter((name) => regex.test(name));
+        for (const projectName of matchingProjects) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+        return;
+    }
+    const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);
+    for (const projectName of matchedProjectNames) {
+        if (pattern.exclude) {
+            matchedProjects.delete(projectName);
+        }
+        else {
+            matchedProjects.add(projectName);
+        }
+    }
+}
+function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const tags = projects[projectName].data.tags || [];
+        if (tags.includes(pattern.value)) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+            continue;
+        }
+        if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+            continue;
+        }
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, tags).length) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function isExcludePattern(pattern) {
+    return pattern.startsWith('!');
+}
+function parseStringPattern(pattern, projects) {
+    const isExclude = isExcludePattern(pattern);
+    // Support for things like: `!{type}:value`
+    if (isExclude) {
+        pattern = pattern.substring(1);
+    }
+    const indexOfFirstPotentialSeparator = pattern.indexOf(':');
+    // There is a project that matches directly
+    if (projects[pattern]) {
+        return { type: 'name', value: pattern, exclude: isExclude };
+        // The pattern does not contain a label
+    }
+    else if (indexOfFirstPotentialSeparator === -1) {
+        return { type: 'unlabeled', value: pattern, exclude: isExclude };
+        // The pattern may contain a label
+    }
+    else {
+        const potentialType = pattern.substring(0, indexOfFirstPotentialSeparator);
+        return {
+            type: isValidPatternType(potentialType) ? potentialType : 'unlabeled',
+            value: pattern.substring(indexOfFirstPotentialSeparator + 1),
+            exclude: isExclude,
+        };
+    }
+}
+function isValidPatternType(type) {
+    return validPatternTypes.includes(type);
+}
+exports.getMatchingStringsWithCache = (() => {
+    // Map< Pattern, Map< Item, Result >>
+    const minimatchCache = new Map();
+    const regexCache = new Map();
+    return (pattern, items) => {
+        if (!minimatchCache.has(pattern)) {
+            minimatchCache.set(pattern, new Map());
+        }
+        const patternCache = minimatchCache.get(pattern);
+        if (!regexCache.has(pattern)) {
+            const regex = minimatch_1.minimatch.makeRe(pattern, { dot: true });
+            if (regex) {
+                regexCache.set(pattern, regex);
+            }
+            else {
+                throw new Error('Invalid glob pattern ' + pattern);
+            }
+        }
+        const matcher = regexCache.get(pattern);
+        return items.filter((item) => {
+            let entry = patternCache.get(item);
+            if (entry === undefined || entry === null) {
+                entry = item === pattern ? true : matcher.test(item);
+                patternCache.set(item, entry);
+            }
+            return entry;
+        });
+    };
+})();

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

@@ -0,0 +1,42 @@
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
+    originName: string;
+    depth?: number;
+}): Promise<GitRepository>;
+export declare class GitRepository {
+    private directory;
+    root: string;
+    constructor(directory: string);
+    getGitRootPath(cwd: string): string;
+    hasUncommittedChanges(): Promise<boolean>;
+    addFetchRemote(remoteName: string, branch: string): Promise<string>;
+    showStat(): Promise<string>;
+    listBranches(): Promise<string[]>;
+    getGitFiles(path: string): Promise<string[]>;
+    reset(ref: string): Promise<string>;
+    mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
+    fetch(remote: string, ref?: string): Promise<string>;
+    checkout(branch: string, opts: {
+        new: boolean;
+        base: string;
+    }): Promise<string>;
+    move(path: string, destination: string): Promise<string>;
+    push(ref: string, remoteName: string): Promise<string>;
+    commit(message: string): Promise<string>;
+    amendCommit(): Promise<string>;
+    deleteGitRemote(name: string): Promise<string>;
+    addGitRemote(name: string, url: string): Promise<string>;
+    hasFilterRepoInstalled(): Promise<boolean>;
+    filterRepo(source: string, destination: string): Promise<void>;
+    filterBranch(source: string, destination: string, branchName: string): Promise<void>;
+    private execAsync;
+    private quotePath;
+    private quoteArg;
+}
+export interface VcsRemoteInfo {
+    domain: string;
+    slug: string;
+}
+export declare function parseVcsRemoteUrl(url: string): VcsRemoteInfo | null;
+export declare function getVcsRemoteInfo(directory?: string): VcsRemoteInfo | null;
+export declare function commitChanges(commitMessage: string, directory?: string): string | null;
+export declare function getLatestCommitSha(directory?: string): string | null;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * This is meant to be used with `git filter-branch --index-filter` to rewrite
+ * history such that only commits related to the subdirectory is kept.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> git filter-branch --index-filter 'node git-utils.index-filter.js' --prune-empty -- --all
+ */
+try {
+    const { execSync } = require('child_process');
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    execSync('git read-tree --empty', { stdio: 'inherit', windowsHide: true });
+    execSync(`git reset ${process.env.GIT_COMMIT} -- "${src}"`, {
+        stdio: 'inherit',
+        windowsHide: true,
+    });
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}

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

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRepository = void 0;
+exports.cloneFromUpstream = cloneFromUpstream;
+exports.parseVcsRemoteUrl = parseVcsRemoteUrl;
+exports.getVcsRemoteInfo = getVcsRemoteInfo;
+exports.commitChanges = commitChanges;
+exports.getLatestCommitSha = getLatestCommitSha;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const logger_1 = require("./logger");
+function execAsync(command, execOptions) {
+    return new Promise((res, rej) => {
+        (0, child_process_1.exec)(command, { ...execOptions, windowsHide: true }, (err, stdout, stderr) => {
+            if (err) {
+                return rej(err);
+            }
+            res(stdout.toString());
+        });
+    });
+}
+async function cloneFromUpstream(url, destination, { originName, depth } = {
+    originName: 'origin',
+}) {
+    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
+        cwd: (0, path_1.dirname)(destination),
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return new GitRepository(destination);
+}
+class GitRepository {
+    constructor(directory) {
+        this.directory = directory;
+        this.root = this.getGitRootPath(this.directory);
+    }
+    getGitRootPath(cwd) {
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd,
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    async hasUncommittedChanges() {
+        const data = await this.execAsync(`git status --porcelain`);
+        return data.trim() !== '';
+    }
+    async addFetchRemote(remoteName, branch) {
+        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
+    }
+    async showStat() {
+        return await this.execAsync(`git show --stat`);
+    }
+    async listBranches() {
+        return (await this.execAsync(`git ls-remote --heads --quiet`))
+            .trim()
+            .split('\n')
+            .map((s) => s
+            .trim()
+            .substring(s.indexOf('\t') + 1)
+            .replace('refs/heads/', ''));
+    }
+    async getGitFiles(path) {
+        // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+        // This avoids problems with special characters in file names.
+        return (await this.execAsync(`git ls-files -z ${path}`))
+            .trim()
+            .split('\x00')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    async reset(ref) {
+        return await this.execAsync(`git reset ${ref} --hard`);
+    }
+    async mergeUnrelatedHistories(ref, message) {
+        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+    }
+    async fetch(remote, ref) {
+        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    }
+    async checkout(branch, opts) {
+        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+    }
+    async move(path, destination) {
+        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
+    }
+    async push(ref, remoteName) {
+        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    }
+    async commit(message) {
+        return await this.execAsync(`git commit -am "${message}"`);
+    }
+    async amendCommit() {
+        return await this.execAsync(`git commit --amend -a --no-edit`);
+    }
+    async deleteGitRemote(name) {
+        return await this.execAsync(`git remote rm ${name}`);
+    }
+    async addGitRemote(name, url) {
+        return await this.execAsync(`git remote add ${name} ${url}`);
+    }
+    async hasFilterRepoInstalled() {
+        try {
+            await this.execAsync(`git filter-repo --help`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // git-filter-repo is much faster than filter-branch, but needs to be installed by user
+    // Use `hasFilterRepoInstalled` to check if it's installed
+    async filterRepo(source, destination) {
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        await this.execAsync(`git filter-repo -f ${source !== '' ? `--path ${this.quotePath(sourcePosixPath)}` : ''} ${source !== destination
+            ? `--path-rename ${this.quotePath(sourcePosixPath, true)}:${this.quotePath(destinationPosixPath, true)}`
+            : ''}`);
+    }
+    async filterBranch(source, destination, branchName) {
+        // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
+        await this.execAsync(`git config core.quotepath false`);
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        // First, if the source is not a root project, then only include commits relevant to the subdirectory.
+        if (source !== '') {
+            const indexFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.index-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --index-filter ${indexFilterCommand} --prune-empty -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+        // Then, move files to their new location if necessary.
+        if (source === '' || source !== destination) {
+            const treeFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.tree-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --tree-filter ${treeFilterCommand} -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+    }
+    execAsync(command, env) {
+        return execAsync(command, {
+            cwd: this.root,
+            maxBuffer: 10 * 1024 * 1024,
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+    }
+    quotePath(path, ensureTrailingSlash) {
+        return this.quoteArg(ensureTrailingSlash && path !== '' && !path.endsWith('/')
+            ? `${path}/`
+            : path);
+    }
+    quoteArg(arg) {
+        return process.platform === 'win32'
+            ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
+                // Bash and other shells will substitute `$` in file names with a variable value.
+                `"${arg
+                    // Need to keep two slashes for Windows or else the path will be invalid.
+                    // e.g. 'C:\Users\bob\projects\repo' is invalid, but 'C:\\Users\\bob\\projects\\repo' is valid
+                    .replaceAll('\\', '\\\\')}"`
+            : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
+                // Using single-quotes prevents this substitution.
+                `'${arg}'`;
+    }
+}
+exports.GitRepository = GitRepository;
+function parseVcsRemoteUrl(url) {
+    // Remove whitespace and handle common URL formats
+    const cleanUrl = url.trim();
+    // SSH format: git@domain:owner/repo.git
+    const sshMatch = cleanUrl.match(/^git@([^:]+):([^\/]+)\/(.+?)(\.git)?$/);
+    if (sshMatch) {
+        const [, domain, owner, repo] = sshMatch;
+        return {
+            domain,
+            slug: `${owner}/${repo}`,
+        };
+    }
+    // HTTPS with authentication: https://user@domain/owner/repo.git
+    const httpsAuthMatch = cleanUrl.match(/^https?:\/\/[^@]+@([^\/]+)\/([^\/]+)\/(.+?)(\.git)?$/);
+    if (httpsAuthMatch) {
+        const [, domain, owner, repo] = httpsAuthMatch;
+        return {
+            domain,
+            slug: `${owner}/${repo}`,
+        };
+    }
+    // HTTPS format: https://domain/owner/repo.git (without authentication)
+    const httpsMatch = cleanUrl.match(/^https?:\/\/([^@\/]+)\/([^\/]+)\/(.+?)(\.git)?$/);
+    if (httpsMatch) {
+        const [, domain, owner, repo] = httpsMatch;
+        return {
+            domain,
+            slug: `${owner}/${repo}`,
+        };
+    }
+    // SSH alternative format: ssh://git@domain/owner/repo.git or ssh://git@domain:port/owner/repo.git
+    const sshAltMatch = cleanUrl.match(/^ssh:\/\/[^@]+@([^:\/]+)(:[0-9]+)?\/([^\/]+)\/(.+?)(\.git)?$/);
+    if (sshAltMatch) {
+        const [, domain, , owner, repo] = sshAltMatch;
+        return {
+            domain,
+            slug: `${owner}/${repo}`,
+        };
+    }
+    return null;
+}
+function getVcsRemoteInfo(directory) {
+    try {
+        const gitRemote = (0, child_process_1.execSync)('git remote -v', {
+            stdio: 'pipe',
+            windowsHide: true,
+            cwd: directory,
+        })
+            .toString()
+            .trim();
+        if (!gitRemote || gitRemote.length === 0) {
+            return null;
+        }
+        const lines = gitRemote.split('\n').filter((line) => line.trim());
+        const remotesPriority = ['origin', 'upstream', 'base'];
+        const foundRemotes = {};
+        let firstRemote = null;
+        for (const line of lines) {
+            const match = line.trim().match(/^(\w+)\s+(\S+)\s+\((fetch|push)\)$/);
+            if (match) {
+                const [, remoteName, url] = match;
+                const remoteInfo = parseVcsRemoteUrl(url);
+                if (remoteInfo && !foundRemotes[remoteName]) {
+                    foundRemotes[remoteName] = remoteInfo;
+                    if (!firstRemote) {
+                        firstRemote = remoteInfo;
+                    }
+                }
+            }
+        }
+        // Return high-priority remote if found
+        for (const remote of remotesPriority) {
+            if (foundRemotes[remote]) {
+                return foundRemotes[remote];
+            }
+        }
+        // Return first found remote
+        return firstRemote;
+    }
+    catch (e) {
+        return null;
+    }
+}
+function commitChanges(commitMessage, directory) {
+    try {
+        (0, child_process_1.execSync)('git add -A', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            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) {
+        if (directory) {
+            // We don't want to throw during create-nx-workspace
+            // because maybe there was an error when setting up git
+            // initially.
+            logger_1.logger.verbose(`Git may not be set up correctly for this new workspace.
+        ${err}`);
+        }
+        else {
+            throw new Error(`Error committing changes:\n${err.stderr}`);
+        }
+    }
+    return getLatestCommitSha(directory);
+}
+function getLatestCommitSha(directory) {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse HEAD', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            windowsHide: true,
+            cwd: directory,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+const { execSync } = require('child_process');
+const { existsSync, mkdirSync, renameSync, rmSync } = require('fs');
+// NOTE: The path passed to `git filter-branch` is POSIX, so we need to use the `posix` module.
+const { posix } = require('path');
+try {
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    const dest = process.env.NX_IMPORT_DESTINATION;
+    const files = execSync(`git ls-files -z ${src}`, {
+        windowsHide: true,
+    })
+        .toString()
+        .trim()
+        .split('\x00')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const file of files) {
+        if (src === '' || file.startsWith(src)) {
+            // If source and destination are the same, then keep the file as is.
+            if (src === dest)
+                continue;
+            const destFile = posix.join(dest, file.replace(src, ''));
+            const dir = posix.dirname(destFile);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            renameSync(file, destFile);
+        }
+        else {
+            // If not matching the source we are filtering, remove it.
+            rmSync(file);
+        }
+    }
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}