make medusa-dev-cli compatible with yarn 2/3 (#1765)

packages/medusa-dev-cli/src/local-npm-registry/index.js

@@ -1,23 +1,23 @@
-const startVerdaccio = require(`verdaccio`).default;
+const startVerdaccio = require(`verdaccio`).default
 
-const fs = require(`fs-extra`);
-const _ = require(`lodash`);
+const fs = require(`fs-extra`)
+const _ = require(`lodash`)
 
-let VerdaccioInitPromise = null;
+let VerdaccioInitPromise = null
 
-const { verdaccioConfig } = require(`./verdaccio-config`);
-const { publishPackage } = require(`./publish-package`);
-const { installPackages } = require(`./install-packages`);
+const { verdaccioConfig } = require(`./verdaccio-config`)
+const { publishPackage } = require(`./publish-package`)
+const { installPackages } = require(`./install-packages`)
 
 const startServer = () => {
   if (VerdaccioInitPromise) {
-    return VerdaccioInitPromise;
+    return VerdaccioInitPromise
   }
 
-  console.log(`Starting local verdaccio server`);
+  console.log(`Starting local verdaccio server`)
 
   // clear storage
-  fs.removeSync(verdaccioConfig.storage);
+  fs.removeSync(verdaccioConfig.storage)
 
   VerdaccioInitPromise = new Promise((resolve) => {
     startVerdaccio(
@@ -29,47 +29,49 @@ const startServer = () => {
       (webServer, addr, pkgName, pkgVersion) => {
         // console.log(webServer)
         webServer.listen(addr.port || addr.path, addr.host, () => {
-          console.log(`Started local verdaccio server`);
+          console.log(`Started local verdaccio server`)
 
-          resolve();
-        });
+          resolve()
+        })
       }
-    );
-  });
+    )
+  })
 
-  return VerdaccioInitPromise;
-};
+  return VerdaccioInitPromise
+}
 
-exports.startVerdaccio = startServer;
+exports.startVerdaccio = startServer
 
 exports.publishPackagesLocallyAndInstall = async ({
   packagesToPublish,
   localPackages,
-  root,
+  packageNameToPath,
   ignorePackageJSONChanges,
   yarnWorkspaceRoot,
+  externalRegistry,
 }) => {
-  await startServer();
+  await startServer()
 
-  const versionPostFix = Date.now();
+  const versionPostFix = Date.now()
 
-  const newlyPublishedPackageVersions = {};
+  const newlyPublishedPackageVersions = {}
 
   for (const packageName of packagesToPublish) {
     newlyPublishedPackageVersions[packageName] = await publishPackage({
       packageName,
       packagesToPublish,
-      root,
+      packageNameToPath,
       versionPostFix,
       ignorePackageJSONChanges,
-    });
+    })
   }
 
-  const packagesToInstall = _.intersection(packagesToPublish, localPackages);
+  const packagesToInstall = _.intersection(packagesToPublish, localPackages)
 
   await installPackages({
     packagesToInstall,
     yarnWorkspaceRoot,
     newlyPublishedPackageVersions,
-  });
-};
+    externalRegistry,
+  })
+}

packages/medusa-dev-cli/src/local-npm-registry/install-packages.js

@@ -8,10 +8,11 @@ const installPackages = async ({
   packagesToInstall,
   yarnWorkspaceRoot,
   newlyPublishedPackageVersions,
+  externalRegistry,
 }) => {
   console.log(
     `Installing packages from local registry:\n${packagesToInstall
-      .map(packageAndVersion => ` - ${packageAndVersion}`)
+      .map((packageAndVersion) => ` - ${packageAndVersion}`)
       .join(`\n`)}`
   )
   let installCmd
@@ -80,22 +81,22 @@ const installPackages = async ({
       process.exit(1)
     }
 
-    const handleDeps = deps => {
+    const handleDeps = (deps) => {
       if (!deps) {
         return false
       }
 
       let changed = false
-      Object.keys(deps).forEach(depName => {
+      Object.keys(deps).forEach((depName) => {
         if (packagesToInstall.includes(depName)) {
-          deps[depName] = `gatsby-dev`
+          deps[depName] = `medusa-dev`
           changed = true
         }
       })
       return changed
     }
 
-    Object.keys(workspacesLayout).forEach(workspaceName => {
+    Object.keys(workspacesLayout).forEach((workspaceName) => {
       const { location } = workspacesLayout[workspaceName]
       const pkgJsonPath = path.join(yarnWorkspaceRoot, location, `package.json`)
       if (!fs.existsSync(pkgJsonPath)) {
@@ -109,7 +110,7 @@ const installPackages = async ({
       changed |= handleDeps(pkg.peerDependencies)
 
       if (changed) {
-        console.log(`Changing deps in ${pkgJsonPath} to use @gatsby-dev`)
+        console.log(`Changing deps in ${pkgJsonPath} to use @medusa-dev`)
         fs.outputJSONSync(pkgJsonPath, pkg, {
           spaces: 2,
         })
@@ -118,24 +119,28 @@ const installPackages = async ({
 
     // package.json files are changed - so we just want to install
     // using verdaccio registry
-    installCmd = [
-      `yarn`,
-      [`install`, `--registry=${registryUrl}`, `--ignore-engines`],
-    ]
+    const yarnCommands = [`install`]
+
+    if (!externalRegistry) {
+      yarnCommands.push(`--registry=${registryUrl}`)
+    }
+
+    installCmd = [`yarn`, yarnCommands]
   } else {
-    installCmd = [
-      `yarn`,
-      [
-        `add`,
-        ...packagesToInstall.map(packageName => {
-          const packageVersion = newlyPublishedPackageVersions[packageName]
-          return `${packageName}@${packageVersion}`
-        }),
-        `--registry=${registryUrl}`,
-        `--exact`,
-        `--ignore-engines`,
-      ],
+    const yarnCommands = [
+      `add`,
+      ...packagesToInstall.map((packageName) => {
+        const packageVersion = newlyPublishedPackageVersions[packageName]
+        return `${packageName}@${packageVersion}`
+      }),
+      `--exact`,
     ]
+
+    if (!externalRegistry) {
+      yarnCommands.push(`--registry=${registryUrl}`)
+    }
+
+    installCmd = [`yarn`, yarnCommands]
   }
 
   try {

packages/medusa-dev-cli/src/local-npm-registry/publish-package.js

@@ -1,18 +1,18 @@
-const fs = require(`fs-extra`);
-const path = require(`path`);
+const fs = require(`fs-extra`)
+const path = require(`path`)
 
-const { promisifiedSpawn } = require(`../utils/promisified-spawn`);
-const { registryUrl } = require(`./verdaccio-config`);
+const { promisifiedSpawn } = require(`../utils/promisified-spawn`)
+const { registryUrl } = require(`./verdaccio-config`)
 
 const NPMRCContent = `${registryUrl.replace(
   /https?:/g,
   ``
-)}/:_authToken="medusa-dev"`;
+)}/:_authToken="medusa-dev"`
 
 const {
   getMonorepoPackageJsonPath,
-} = require(`../utils/get-monorepo-package-json-path`);
-const { registerCleanupTask } = require(`./cleanup-tasks`);
+} = require(`../utils/get-monorepo-package-json-path`)
+const { registerCleanupTask } = require(`./cleanup-tasks`)
 
 /**
  * Edit package.json to:
@@ -27,7 +27,7 @@ const adjustPackageJson = ({
   versionPostFix,
   packagesToPublish,
   ignorePackageJSONChanges,
-  root,
+  packageNameToPath,
 }) => {
   // 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
@@ -36,10 +36,10 @@ const adjustPackageJson = ({
   const monorepoPKGjsonString = fs.readFileSync(
     monoRepoPackageJsonPath,
     `utf-8`
-  );
-  const monorepoPKGjson = JSON.parse(monorepoPKGjsonString);
+  )
+  const monorepoPKGjson = JSON.parse(monorepoPKGjsonString)
 
-  monorepoPKGjson.version = `${monorepoPKGjson.version}-dev-${versionPostFix}`;
+  monorepoPKGjson.version = `${monorepoPKGjson.version}-dev-${versionPostFix}`
   packagesToPublish.forEach((packageThatWillBePublished) => {
     if (
       monorepoPKGjson.dependencies &&
@@ -49,37 +49,37 @@ const adjustPackageJson = ({
         fs.readFileSync(
           getMonorepoPackageJsonPath({
             packageName: packageThatWillBePublished,
-            root,
+            packageNameToPath,
           }),
           `utf-8`
         )
-      ).version;
+      ).version
 
       monorepoPKGjson.dependencies[
         packageThatWillBePublished
-      ] = `${currentVersion}-dev-${versionPostFix}`;
+      ] = `${currentVersion}-dev-${versionPostFix}`
     }
-  });
+  })
 
-  const temporaryMonorepoPKGjsonString = JSON.stringify(monorepoPKGjson);
+  const temporaryMonorepoPKGjsonString = JSON.stringify(monorepoPKGjson)
 
   const unignorePackageJSONChanges = ignorePackageJSONChanges(packageName, [
     monorepoPKGjsonString,
     temporaryMonorepoPKGjsonString,
-  ]);
+  ])
 
   // change version and dependency versions
-  fs.outputFileSync(monoRepoPackageJsonPath, temporaryMonorepoPKGjsonString);
+  fs.outputFileSync(monoRepoPackageJsonPath, temporaryMonorepoPKGjsonString)
 
   return {
     newPackageVersion: monorepoPKGjson.version,
     unadjustPackageJson: registerCleanupTask(() => {
       // restore original package.json
-      fs.outputFileSync(monoRepoPackageJsonPath, monorepoPKGjsonString);
-      unignorePackageJSONChanges();
+      fs.outputFileSync(monoRepoPackageJsonPath, monorepoPKGjsonString)
+      unignorePackageJSONChanges()
     }),
-  };
-};
+  }
+}
 
 /**
  * Anonymous publishing require dummy .npmrc
@@ -88,38 +88,38 @@ const adjustPackageJson = ({
  * This is not verdaccio restriction.
  */
 const createTemporaryNPMRC = ({ pathToPackage }) => {
-  const NPMRCPath = path.join(pathToPackage, `.npmrc`);
-  fs.outputFileSync(NPMRCPath, NPMRCContent);
+  const NPMRCPath = path.join(pathToPackage, `.npmrc`)
+  fs.outputFileSync(NPMRCPath, NPMRCContent)
 
   return registerCleanupTask(() => {
-    fs.removeSync(NPMRCPath);
-  });
-};
+    fs.removeSync(NPMRCPath)
+  })
+}
 
 const publishPackage = async ({
   packageName,
   packagesToPublish,
-  root,
   versionPostFix,
   ignorePackageJSONChanges,
+  packageNameToPath,
 }) => {
   const monoRepoPackageJsonPath = getMonorepoPackageJsonPath({
     packageName,
-    root,
-  });
+    packageNameToPath,
+  })
 
   const { unadjustPackageJson, newPackageVersion } = adjustPackageJson({
     monoRepoPackageJsonPath,
     packageName,
-    root,
+    packageNameToPath,
     versionPostFix,
     packagesToPublish,
     ignorePackageJSONChanges,
-  });
+  })
 
-  const pathToPackage = path.dirname(monoRepoPackageJsonPath);
+  const pathToPackage = path.dirname(monoRepoPackageJsonPath)
 
-  const uncreateTemporaryNPMRC = createTemporaryNPMRC({ pathToPackage });
+  const uncreateTemporaryNPMRC = createTemporaryNPMRC({ pathToPackage })
 
   // npm publish
   const publishCmd = [
@@ -128,26 +128,26 @@ const publishPackage = async ({
     {
       cwd: pathToPackage,
     },
-  ];
+  ]
 
   console.log(
     `Publishing ${packageName}@${newPackageVersion} to local registry`
-  );
+  )
   try {
-    await promisifiedSpawn(publishCmd);
+    await promisifiedSpawn(publishCmd)
 
     console.log(
       `Published ${packageName}@${newPackageVersion} to local registry`
-    );
+    )
   } catch (e) {
-    console.error(`Failed to publish ${packageName}@${newPackageVersion}`, e);
-    process.exit(1);
+    console.error(`Failed to publish ${packageName}@${newPackageVersion}`, e)
+    process.exit(1)
   }
 
-  uncreateTemporaryNPMRC();
-  unadjustPackageJson();
+  uncreateTemporaryNPMRC()
+  unadjustPackageJson()
 
-  return newPackageVersion;
-};
+  return newPackageVersion
+}
 
-exports.publishPackage = publishPackage;
+exports.publishPackage = publishPackage