How to use pathToPackage method in Cypress

1#!/usr/bin/env node
2const shell = require('shelljs');
3let pathToPackage = require('global-modules-path').getPath('git-safe');
4switch (process.argv[2]) {
5  case 'encrypt':
6    {
7      shell.exec(`bash ${pathToPackage}/git-safe.sh encrypt ${pathToPackage}`);
8    }
9    break;
10  case 'decrypt':
11    {
12      shell.exec(`bash ${pathToPackage}/git-safe.sh decrypt ${pathToPackage}`);
13    }
14    break;
15  case 'commit':
16    {
17      shell.exec(`bash ${pathToPackage}/git-safe.sh commit ${pathToPackage}`);
18    }
19    break;
20  default: {
21    console.log(
22      '[git-safe]: Only `git-safe encrypt | git-safe decrypt | git-safe commit` are supported !'
23    );
24  }
25}
26

Source: index.js

#!/usr/bin/env node
const shell = require('shelljs');
let pathToPackage = require('global-modules-path').getPath('git-safe');
switch (process.argv[2]) {
  case 'encrypt':
    {
      shell.exec(`bash ${pathToPackage}/git-safe.sh encrypt ${pathToPackage}`);
    }
    break;
  case 'decrypt':
    {
      shell.exec(`bash ${pathToPackage}/git-safe.sh decrypt ${pathToPackage}`);
    }
    break;
  case 'commit':
    {
      shell.exec(`bash ${pathToPackage}/git-safe.sh commit ${pathToPackage}`);
    }
    break;
  default: {
    console.log(
      '[git-safe]: Only `git-safe encrypt | git-safe decrypt | git-safe commit` are supported !'
    );
  }
}

1#! /usr/bin/env node
2/**
3 *  Script to run wiremock based on specific stub jar downloaded from local machine or if not found from nexus.
4 *
5 *  Download sources:
6 *    1) local machine .m2 repository
7 *    2) nexus artifactory
8 *
9 *  Required params:
10 *    stubs - path to direct stubs jar link
11 *      uk/co/hl/bf/working-day-calendar/0.2.9-SNAPSHOT/working-day-calendar-0.2.9-20180112.122824-2-stubs.jar
12 *    port - port of wiremock to serve mocks
13 *      9000
14 *
15 *  Example of use in project package.json:
16 *    node ./mock/mock-backend.js stubs=uk/co/hl/bf/working-day-calendar/0.2.9-SNAPSHOT/working-day-calendar-0.2.9-20180112.122824-2-stubs.jar port=9000"
17 */
18
19const NPMRC_CA_PARAM_NAME = "ca";
20const MAVEN_REPO = "https://nexus.hltech.dev/repository/maven-public/";
21
22const fs = require('fs');
23const request = require('request');
24const unzip = require('unzip');
25const execSync = require('child_process').execSync;
26
27const dir = './stubs';
28const jarDir = dir + '/stubs.jar';
29const mappingsDir = dir + '/mappings';
30
31cleanStubs(dir);
32createBaseStubFolder();
33downloadStubsJarAndRunWireMock(getParam('stubs'));
34
35function downloadStubsJarAndRunWireMock(stubsPath) {
36  createJarFromLocalM2Source(
37    stubsPath,
38    createJarFromNexusSource
39  )
40}
41
42function createJarFromLocalM2Source(stubsPath, alternative) {
43  const pathToPackage = getUserHome() + '/.m2/repository/' + stubsPath;
44  console.log("Looking for jar in local", pathToPackage);
45  fs.readFile(pathToPackage, (err, data) => {
46    if (err) {
47      alternative(stubsPath);
48      return
49    }
50    fs.writeFile(jarDir, data, (err) => {
51    if (err) {
52      alternative(stubsPath);
53      return
54    }
55
56    runWireMockOnJustCreatedJar();
57});
58})
59}
60
61function createJarFromNexusSource(stubsPath) {
62  const projectCa = getNpmrcParam(NPMRC_CA_PARAM_NAME);
63  const ca = projectCa !== undefined ? {ca: projectCa} : {};
64  const pathToPackage = MAVEN_REPO + stubsPath;
65
66  console.log("Looking for jar in nexus", pathToPackage);
67  request({
68    method: "GET",
69    uri: pathToPackage,
70    agentOptions: ca
71  }, function(body, err) {
72    if (err) {
73      console.log('Jar downloading status: ' + err.statusCode + ' - ' + err.statusMessage);
74    } else {
75      console.log(body);
76    }
77
78    runWireMockOnJustCreatedJar();
79  }).pipe(fs.createWriteStream(jarDir));
80}
81
82function runWireMockOnJustCreatedJar() {
83  console.log("Running wiremock jar..");
84  extractStubsJar();
85  runWireMock(getParam('port'));
86}
87
88function createBaseStubFolder() {
89  if (!fs.existsSync(dir)){
90    fs.mkdirSync(dir);
91  }
92
93  if (!fs.existsSync(mappingsDir)){
94    fs.mkdirSync(mappingsDir);
95  }
96}
97
98function extractStubsJar() {
99  fs.createReadStream(jarDir)
100    .pipe(unzip.Parse())
101    .on('entry', function (entry) {
102      const fileName = entry.path;
103      if (fileName.endsWith(".json")) {
104        const filenameWithoutFolders = fileName.replace(/^.*[\\\/]/, '');
105        console.log("found", filenameWithoutFolders);
106        entry.pipe(fs.createWriteStream(mappingsDir + '/' + filenameWithoutFolders));
107      } else {
108        entry.autodrain();
109      }
110    });
111}
112
113function cleanStubs(path) {
114  const deleteFolderRecursive = function(path) {
115    if( fs.existsSync(path) ) {
116      fs.readdirSync(path).forEach(function(file,index){
117        const curPath = path + "/" + file;
118        if(fs.lstatSync(curPath).isDirectory()) { // recurse
119          deleteFolderRecursive(curPath);
120        } else {
121          fs.unlinkSync(curPath);
122        }
123      });
124      fs.rmdirSync(path);
125    }
126  };
127
128  deleteFolderRecursive(path);
129}
130
131function runWireMock(port) {
132  const spawn = require('child_process').spawn;
133  spawn('java', ['-jar', './mock/wiremock-standalone-2.14.0.jar', '--root-dir=' + dir, '--port=' + port], { stdio: 'inherit' });
134}
135
136function getUserHome() {
137  return process.env.HOME || process.env.USERPROFILE;
138}
139
140function getParam(key) {
141  for (i = 0; i < process.argv.length; i++) {
142    const val = process.argv[i];
143    const name = val.split('=')[0];
144    if (name === key) {
145      return val.split('=')[1];
146    }
147  }
148
149  console.log("Missing param: " + key);
150  process.exit(-1);
151}
152
153function getNpmrcParam(param) {
154  const paramValue = execSync('npm config get ' + param);
155  return paramValue.toString();
156}
157

Source: mock-backend.js

#! /usr/bin/env node
/**
 *  Script to run wiremock based on specific stub jar downloaded from local machine or if not found from nexus.
 *
 *  Download sources:
 *    1) local machine .m2 repository
 *    2) nexus artifactory
 *
 *  Required params:
 *    stubs - path to direct stubs jar link
 *      uk/co/hl/bf/working-day-calendar/0.2.9-SNAPSHOT/working-day-calendar-0.2.9-20180112.122824-2-stubs.jar
 *    port - port of wiremock to serve mocks
 *      9000
 *
 *  Example of use in project package.json:
 *    node ./mock/mock-backend.js stubs=uk/co/hl/bf/working-day-calendar/0.2.9-SNAPSHOT/working-day-calendar-0.2.9-20180112.122824-2-stubs.jar port=9000"
 */

const NPMRC_CA_PARAM_NAME = "ca";
const MAVEN_REPO = "https://nexus.hltech.dev/repository/maven-public/";

const fs = require('fs');
const request = require('request');
const unzip = require('unzip');
const execSync = require('child_process').execSync;

const dir = './stubs';
const jarDir = dir + '/stubs.jar';
const mappingsDir = dir + '/mappings';

cleanStubs(dir);
createBaseStubFolder();
downloadStubsJarAndRunWireMock(getParam('stubs'));

function downloadStubsJarAndRunWireMock(stubsPath) {
  createJarFromLocalM2Source(
    stubsPath,
    createJarFromNexusSource
  )
}

function createJarFromLocalM2Source(stubsPath, alternative) {
  const pathToPackage = getUserHome() + '/.m2/repository/' + stubsPath;
  console.log("Looking for jar in local", pathToPackage);
  fs.readFile(pathToPackage, (err, data) => {
    if (err) {
      alternative(stubsPath);
      return
    }
    fs.writeFile(jarDir, data, (err) => {
    if (err) {
      alternative(stubsPath);
      return
    }

    runWireMockOnJustCreatedJar();
});
})
}

function createJarFromNexusSource(stubsPath) {
  const projectCa = getNpmrcParam(NPMRC_CA_PARAM_NAME);
  const ca = projectCa !== undefined ? {ca: projectCa} : {};
  const pathToPackage = MAVEN_REPO + stubsPath;

  console.log("Looking for jar in nexus", pathToPackage);
  request({
    method: "GET",
    uri: pathToPackage,
    agentOptions: ca
  }, function(body, err) {
    if (err) {
      console.log('Jar downloading status: ' + err.statusCode + ' - ' + err.statusMessage);
    } else {
      console.log(body);
    }

    runWireMockOnJustCreatedJar();
  }).pipe(fs.createWriteStream(jarDir));
}

function runWireMockOnJustCreatedJar() {
  console.log("Running wiremock jar..");
  extractStubsJar();
  runWireMock(getParam('port'));
}

function createBaseStubFolder() {
  if (!fs.existsSync(dir)){
    fs.mkdirSync(dir);
  }

  if (!fs.existsSync(mappingsDir)){
    fs.mkdirSync(mappingsDir);
  }
}

function extractStubsJar() {
  fs.createReadStream(jarDir)
    .pipe(unzip.Parse())
    .on('entry', function (entry) {
      const fileName = entry.path;
      if (fileName.endsWith(".json")) {
        const filenameWithoutFolders = fileName.replace(/^.*[\\\/]/, '');
        console.log("found", filenameWithoutFolders);
        entry.pipe(fs.createWriteStream(mappingsDir + '/' + filenameWithoutFolders));
      } else {
        entry.autodrain();
      }
    });
}

function cleanStubs(path) {
  const deleteFolderRecursive = function(path) {
    if( fs.existsSync(path) ) {
      fs.readdirSync(path).forEach(function(file,index){
        const curPath = path + "/" + file;
        if(fs.lstatSync(curPath).isDirectory()) { // recurse
          deleteFolderRecursive(curPath);
        } else {
          fs.unlinkSync(curPath);
        }
      });
      fs.rmdirSync(path);
    }
  };

  deleteFolderRecursive(path);
}

function runWireMock(port) {
  const spawn = require('child_process').spawn;
  spawn('java', ['-jar', './mock/wiremock-standalone-2.14.0.jar', '--root-dir=' + dir, '--port=' + port], { stdio: 'inherit' });
}

function getUserHome() {
  return process.env.HOME || process.env.USERPROFILE;
}

function getParam(key) {
  for (i = 0; i < process.argv.length; i++) {
    const val = process.argv[i];
    const name = val.split('=')[0];
    if (name === key) {
      return val.split('=')[1];
    }
  }

  console.log("Missing param: " + key);
  process.exit(-1);
}

function getNpmrcParam(param) {
  const paramValue = execSync('npm config get ' + param);
  return paramValue.toString();
}

1const fs = require(`fs-extra`)
2const path = require(`path`)
3
4const { promisifiedSpawn } = require(`../utils/promisified-spawn`)
5const { registryUrl } = require(`./verdaccio-config`)
6
7const NPMRCContent = `${registryUrl.replace(
8  /https?:/g,
9  ``
10)}/:_authToken="gatsby-dev"`
11
12const {
13  getMonorepoPackageJsonPath,
14} = require(`../utils/get-monorepo-package-json-path`)
15const { registerCleanupTask } = require(`./cleanup-tasks`)
16
17/**
18 * Edit package.json to:
19 *  - adjust version to temporary one
20 *  - change version selectors for dependencies that
21 *    will be published, to make sure that yarn
22 *    install them in local site
23 */
24const adjustPackageJson = ({
25  monoRepoPackageJsonPath,
26  packageName,
27  versionPostFix,
28  packagesToPublish,
29  ignorePackageJSONChanges,
30  root,
31}) => {
32  // we need to check if package depend on any other package to will be published and
33  // adjust version selector to point to dev version of package so local registry is used
34  // for dependencies.
35
36  const monorepoPKGjsonString = fs.readFileSync(
37    monoRepoPackageJsonPath,
38    `utf-8`
39  )
40  const monorepoPKGjson = JSON.parse(monorepoPKGjsonString)
41
42  monorepoPKGjson.version = `${monorepoPKGjson.version}-dev-${versionPostFix}`
43  packagesToPublish.forEach(packageThatWillBePublished => {
44    if (
45      monorepoPKGjson.dependencies &&
46      monorepoPKGjson.dependencies[packageThatWillBePublished]
47    ) {
48      const currentVersion = JSON.parse(
49        fs.readFileSync(
50          getMonorepoPackageJsonPath({
51            packageName: packageThatWillBePublished,
52            root,
53          }),
54          `utf-8`
55        )
56      ).version
57
58      monorepoPKGjson.dependencies[
59        packageThatWillBePublished
60      ] = `${currentVersion}-dev-${versionPostFix}`
61    }
62  })
63
64  const temporaryMonorepoPKGjsonString = JSON.stringify(monorepoPKGjson)
65
66  const unignorePackageJSONChanges = ignorePackageJSONChanges(packageName, [
67    monorepoPKGjsonString,
68    temporaryMonorepoPKGjsonString,
69  ])
70
71  // change version and dependency versions
72  fs.outputFileSync(monoRepoPackageJsonPath, temporaryMonorepoPKGjsonString)
73
74  return {
75    newPackageVersion: monorepoPKGjson.version,
76    unadjustPackageJson: registerCleanupTask(() => {
77      // restore original package.json
78      fs.outputFileSync(monoRepoPackageJsonPath, monorepoPKGjsonString)
79      unignorePackageJSONChanges()
80    }),
81  }
82}
83
84/**
85 * Anonymous publishing require dummy .npmrc
86 * See https://github.com/verdaccio/verdaccio/issues/212#issuecomment-308578500
87 * This is `npm publish` (as in linked comment) and `yarn publish` requirement.
88 * This is not verdaccio restriction.
89 */
90const createTemporaryNPMRC = ({ pathToPackage }) => {
91  const NPMRCPath = path.join(pathToPackage, `.npmrc`)
92  fs.outputFileSync(NPMRCPath, NPMRCContent)
93
94  return registerCleanupTask(() => {
95    fs.removeSync(NPMRCPath)
96  })
97}
98
99const publishPackage = async ({
100  packageName,
101  packagesToPublish,
102  root,
103  versionPostFix,
104  ignorePackageJSONChanges,
105}) => {
106  const monoRepoPackageJsonPath = getMonorepoPackageJsonPath({
107    packageName,
108    root,
109  })
110
111  const { unadjustPackageJson, newPackageVersion } = adjustPackageJson({
112    monoRepoPackageJsonPath,
113    packageName,
114    root,
115    versionPostFix,
116    packagesToPublish,
117    ignorePackageJSONChanges,
118  })
119
120  const pathToPackage = path.dirname(monoRepoPackageJsonPath)
121
122  const uncreateTemporaryNPMRC = createTemporaryNPMRC({ pathToPackage })
123
124  // npm publish
125  const publishCmd = [
126    `npm`,
127    [`publish`, `--tag`, `gatsby-dev`, `--registry=${registryUrl}`],
128    {
129      cwd: pathToPackage,
130    },
131  ]
132
133  console.log(
134    `Publishing ${packageName}@${newPackageVersion} to local registry`
135  )
136  try {
137    await promisifiedSpawn(publishCmd)
138
139    console.log(
140      `Published ${packageName}@${newPackageVersion} to local registry`
141    )
142  } catch (e) {
143    console.error(`Failed to publish ${packageName}@${newPackageVersion}`, e)
144    process.exit(1)
145  }
146
147  uncreateTemporaryNPMRC()
148  unadjustPackageJson()
149
150  return newPackageVersion
151}
152
153exports.publishPackage = publishPackage
154

Source: publish-package.js

const fs = require(`fs-extra`)
const path = require(`path`)

const { promisifiedSpawn } = require(`../utils/promisified-spawn`)
const { registryUrl } = require(`./verdaccio-config`)

const NPMRCContent = `${registryUrl.replace(
  /https?:/g,
  ``
)}/:_authToken="gatsby-dev"`

const {
  getMonorepoPackageJsonPath,
} = require(`../utils/get-monorepo-package-json-path`)
const { registerCleanupTask } = require(`./cleanup-tasks`)

/**
 * Edit package.json to:
 *  - adjust version to temporary one
 *  - change version selectors for dependencies that
 *    will be published, to make sure that yarn
 *    install them in local site
 */
const adjustPackageJson = ({
  monoRepoPackageJsonPath,
  packageName,
  versionPostFix,
  packagesToPublish,
  ignorePackageJSONChanges,
  root,
}) => {
  // we need to check if package depend on any other package to will be published and
  // adjust version selector to point to dev version of package so local registry is used
  // for dependencies.

  const monorepoPKGjsonString = fs.readFileSync(
    monoRepoPackageJsonPath,
    `utf-8`
  )
  const monorepoPKGjson = JSON.parse(monorepoPKGjsonString)

  monorepoPKGjson.version = `${monorepoPKGjson.version}-dev-${versionPostFix}`
  packagesToPublish.forEach(packageThatWillBePublished => {
    if (
      monorepoPKGjson.dependencies &&
      monorepoPKGjson.dependencies[packageThatWillBePublished]
    ) {
      const currentVersion = JSON.parse(
        fs.readFileSync(
          getMonorepoPackageJsonPath({
            packageName: packageThatWillBePublished,
            root,
          }),
          `utf-8`
        )
      ).version

      monorepoPKGjson.dependencies[
        packageThatWillBePublished
      ] = `${currentVersion}-dev-${versionPostFix}`
    }
  })

  const temporaryMonorepoPKGjsonString = JSON.stringify(monorepoPKGjson)

  const unignorePackageJSONChanges = ignorePackageJSONChanges(packageName, [
    monorepoPKGjsonString,
    temporaryMonorepoPKGjsonString,
  ])

  // change version and dependency versions
  fs.outputFileSync(monoRepoPackageJsonPath, temporaryMonorepoPKGjsonString)

  return {
    newPackageVersion: monorepoPKGjson.version,
    unadjustPackageJson: registerCleanupTask(() => {
      // restore original package.json
      fs.outputFileSync(monoRepoPackageJsonPath, monorepoPKGjsonString)
      unignorePackageJSONChanges()
    }),
  }
}

/**
 * Anonymous publishing require dummy .npmrc
 * See https://github.com/verdaccio/verdaccio/issues/212#issuecomment-308578500
 * This is `npm publish` (as in linked comment) and `yarn publish` requirement.
 * This is not verdaccio restriction.
 */
const createTemporaryNPMRC = ({ pathToPackage }) => {
  const NPMRCPath = path.join(pathToPackage, `.npmrc`)
  fs.outputFileSync(NPMRCPath, NPMRCContent)

  return registerCleanupTask(() => {
    fs.removeSync(NPMRCPath)
  })
}

const publishPackage = async ({
  packageName,
  packagesToPublish,
  root,
  versionPostFix,
  ignorePackageJSONChanges,
}) => {
  const monoRepoPackageJsonPath = getMonorepoPackageJsonPath({
    packageName,
    root,
  })

  const { unadjustPackageJson, newPackageVersion } = adjustPackageJson({
    monoRepoPackageJsonPath,
    packageName,
    root,
    versionPostFix,
    packagesToPublish,
    ignorePackageJSONChanges,
  })

  const pathToPackage = path.dirname(monoRepoPackageJsonPath)

  const uncreateTemporaryNPMRC = createTemporaryNPMRC({ pathToPackage })

  // npm publish
  const publishCmd = [
    `npm`,
    [`publish`, `--tag`, `gatsby-dev`, `--registry=${registryUrl}`],
    {
      cwd: pathToPackage,
    },
  ]

  console.log(
    `Publishing ${packageName}@${newPackageVersion} to local registry`
  )
  try {
    await promisifiedSpawn(publishCmd)

    console.log(
      `Published ${packageName}@${newPackageVersion} to local registry`
    )
  } catch (e) {
    console.error(`Failed to publish ${packageName}@${newPackageVersion}`, e)
    process.exit(1)
  }

  uncreateTemporaryNPMRC()
  unadjustPackageJson()

  return newPackageVersion
}

exports.publishPackage = publishPackage