How to use findNodeInFullPath method in Cypress

1// https://folktale.origamitower.com/api/v2.3.0/en/folktale.concurrency.task.html
2const Task = require('folktale/concurrency/task')
3
4const debug = require('debug')('verbose')
5const which = require('which')
6
7// wrap Node callback style function in a Task
8const asyncWhich = Task.fromNodeback(which)
9
10function findNodeInFullPath () {
11  debug('finding Node with $PATH %s', process.env.PATH)
12
13  // "tap" and debug log implemented using "comma operator"
14  const tapDebug = path => (debug('found Node %o', { path }), path)
15
16  return (
17    asyncWhich('node')  // async Task
18      .map(tapDebug)    // success flow
19      .orElse(err => {  // error flow
20        debug('could not find Node %o', { err })
21        // keep the rejection (still error flow)
22        return Task.rejected(err)
23      })
24  )
25}
26
27const findNodePathAndVersion = () =>
28  findNodeInFullPath()
29    // if we cannot find Node right away
30    // fix the "PATH" and try again
31    .orElse(() => {
32      debug('fixing path before searching again')
33      fixPath()
34      return findNodeInFullPath()
35    })
36
37if (!module.parent) {
38  findNodePathAndVersion()
39    .run()
40    .promise()
41    .then(console.log, console.error)
42}
43

Source: 02-with-fix-path.js

// https://folktale.origamitower.com/api/v2.3.0/en/folktale.concurrency.task.html
const Task = require('folktale/concurrency/task')

const debug = require('debug')('verbose')
const which = require('which')

// wrap Node callback style function in a Task
const asyncWhich = Task.fromNodeback(which)

function findNodeInFullPath () {
  debug('finding Node with $PATH %s', process.env.PATH)

  // "tap" and debug log implemented using "comma operator"
  const tapDebug = path => (debug('found Node %o', { path }), path)

  return (
    asyncWhich('node')  // async Task
      .map(tapDebug)    // success flow
      .orElse(err => {  // error flow
        debug('could not find Node %o', { err })
        // keep the rejection (still error flow)
        return Task.rejected(err)
      })
  )
}

const findNodePathAndVersion = () =>
  findNodeInFullPath()
    // if we cannot find Node right away
    // fix the "PATH" and try again
    .orElse(() => {
      debug('fixing path before searching again')
      fixPath()
      return findNodeInFullPath()
    })

if (!module.parent) {
  findNodePathAndVersion()
    .run()
    .promise()
    .then(console.log, console.error)
}

1const debug = require('debug')('cypress:server:find_system_node')
2const execa = require('execa')
3const fixPath = require('fix-path')
4const Promise = require('bluebird')
5const which = require('which')
6
7const NODE_VERSION_RE = /^v(\d+\.\d+\.\d+)/m
8
9/*
10 * Find the full path to a `node` binary on the current PATH.
11 * Note about fix-path:
12 *   while fix-path is good, it can cause unexpected behavior when running Cypress locally
13 *   for example, using NVM we set local Node to 8
14 *   then fix-path adds all user paths, and the found Node is whatever we have
15 *   installed globally, like 6 or 10 (NVM path comes later)
16 *   So this function only fixes the path, if the Node cannot be found on first attempt
17 */
18function findNodeInFullPath () {
19  debug('finding Node with $PATH %s', process.env.PATH)
20
21  return Promise.fromCallback((cb) => {
22    return which('node', cb)
23  })
24  .catch(() => {
25    debug('could not find Node, trying to fix path')
26    // Fix the $PATH on macOS when run from a GUI app
27    fixPath()
28    debug('searching again with fixed $PATH %s', process.env.PATH)
29
30    return Promise.fromCallback((cb) => {
31      return which('node', cb)
32    })
33  })
34  .tap((path) => {
35    debug('found Node %o', { path })
36  })
37  .catch((err) => {
38    debug('could not find Node %o', { err })
39
40    throw err
41  })
42}
43
44function findNodeVersionFromPath (path) {
45  if (!path) {
46    return Promise.resolve(null)
47  }
48
49  return execa.stdout(path, ['-v'])
50  .then((stdout) => {
51    debug('node -v returned %o', { stdout })
52    const matches = NODE_VERSION_RE.exec(stdout)
53
54    if (matches && matches.length === 2) {
55      const version = matches[1]
56
57      debug('found Node version', { version })
58
59      return version
60    }
61  })
62  .catch((err) => {
63    debug('could not resolve Node version %o', { err })
64
65    throw err
66  })
67}
68
69function findNodePathAndVersion () {
70  return findNodeInFullPath()
71  .then((path) => {
72    return findNodeVersionFromPath(path)
73    .then((version) => {
74      return {
75        path, version,
76      }
77    })
78  })
79}
80
81module.exports = {
82  findNodePathAndVersion,
83}
84

Source: find_system_node.js

const debug = require('debug')('cypress:server:find_system_node')
const execa = require('execa')
const fixPath = require('fix-path')
const Promise = require('bluebird')
const which = require('which')

const NODE_VERSION_RE = /^v(\d+\.\d+\.\d+)/m

/*
 * Find the full path to a `node` binary on the current PATH.
 * Note about fix-path:
 *   while fix-path is good, it can cause unexpected behavior when running Cypress locally
 *   for example, using NVM we set local Node to 8
 *   then fix-path adds all user paths, and the found Node is whatever we have
 *   installed globally, like 6 or 10 (NVM path comes later)
 *   So this function only fixes the path, if the Node cannot be found on first attempt
 */
function findNodeInFullPath () {
  debug('finding Node with $PATH %s', process.env.PATH)

  return Promise.fromCallback((cb) => {
    return which('node', cb)
  })
  .catch(() => {
    debug('could not find Node, trying to fix path')
    // Fix the $PATH on macOS when run from a GUI app
    fixPath()
    debug('searching again with fixed $PATH %s', process.env.PATH)

    return Promise.fromCallback((cb) => {
      return which('node', cb)
    })
  })
  .tap((path) => {
    debug('found Node %o', { path })
  })
  .catch((err) => {
    debug('could not find Node %o', { err })

    throw err
  })
}

function findNodeVersionFromPath (path) {
  if (!path) {
    return Promise.resolve(null)
  }

  return execa.stdout(path, ['-v'])
  .then((stdout) => {
    debug('node -v returned %o', { stdout })
    const matches = NODE_VERSION_RE.exec(stdout)

    if (matches && matches.length === 2) {
      const version = matches[1]

      debug('found Node version', { version })

      return version
    }
  })
  .catch((err) => {
    debug('could not resolve Node version %o', { err })

    throw err
  })
}

function findNodePathAndVersion () {
  return findNodeInFullPath()
  .then((path) => {
    return findNodeVersionFromPath(path)
    .then((version) => {
      return {
        path, version,
      }
    })
  })
}

module.exports = {
  findNodePathAndVersion,
}