piral-cli 0.15.0-alpha.4098 → 0.15.0-alpha.4257

package/src/common/npm.ts

@@ -1,65 +1,60 @@
-import { resolve, relative, dirname } from 'path';
-import { createReadStream, existsSync, access, constants } from 'fs';
+import { resolve, relative, dirname, isAbsolute, sep } from 'path';
+import { createReadStream, existsSync } from 'fs';
 import { log, fail } from './log';
+import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
 import { legacyCoreExternals, frameworkLibs } from './constants';
 import { inspectPackage } from './inspect';
-import { readJson, checkExists, findFile } from './io';
+import { readJson, checkExists } from './io';
 import { clientTypeKeys } from '../helpers';
 import { PackageType, NpmClientType } from '../types';
 
 const gitPrefix = 'git+';
 const filePrefix = 'file:';
+const pathPrefixes = ['/', './', '../', '.\\', '..\\', '~/', '~\\', filePrefix];
 
 function isProjectReference(name: string) {
   const target = resolve(name, 'package.json');
   return checkExists(target);
 }
 
-export function detectPnpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'pnpm-lock.yaml'), constants.F_OK, (noPnpmLock) => {
-      res(!noPnpmLock);
-    });
-  });
+function resolveAbsPath(basePath: string, fullName: string) {
+  const prefixed = fullName.startsWith(filePrefix);
+  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
+  return resolve(basePath, relPath);
 }
 
-export function detectNpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'package-lock.json'), constants.F_OK, (noPackageLock) => {
-      res(!noPackageLock);
-    });
-  });
-}
+async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClientType]> {
+  let previous = root;
 
-export async function detectYarn(root: string) {
-  return !!(await findFile(root, 'yarn.lock'));
-}
+  do {
+    if (await checkExists(resolve(root, 'lerna.json'))) {
+      return [root, 'lerna'];
+    }
 
-export async function getLernaConfigPath(root: string) {
-  log('generalDebug_0003', 'Trying to get the configuration file for Lerna ...');
-  const file = await findFile(root, 'lerna.json');
+    if (await checkExists(resolve(root, 'rush.json'))) {
+      return [root, 'rush'];
+    }
 
-  if (file) {
-    log('generalDebug_0003', `Found Lerna config in "${file}".`);
-    return file;
-  }
+    if (await checkExists(resolve(root, 'pnpm-workspace.yaml'))) {
+      return [root, 'pnpm'];
+    }
 
-  return undefined;
-}
+    const packageJson = await readJson(root, 'package.json');
 
-export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
-  const file = await getLernaConfigPath(root);
+    if (Array.isArray(packageJson?.workspaces)) {
+      if (await checkExists(resolve(root, 'yarn.lock'))) {
+        return [root, 'yarn'];
+      }
 
-  if (file) {
-    try {
-      return require(file).npmClient;
-    } catch (err) {
-      log('generalError_0002', `Could not read lerna.json: ${err}.`);
+      return [root, 'npm'];
     }
-  }
 
-  return undefined;
+    previous = root;
+    root = dirname(root);
+  } while (root !== previous);
+
+  return [];
 }
 
 /**
@@ -69,36 +64,45 @@ export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
  */
 export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClientType> {
   if (!selected || !clientTypeKeys.includes(selected)) {
-    log('generalDebug_0003', 'No npm client selected. Checking for lock files ...');
-    const [hasNpm, hasYarn, hasPnpm] = await Promise.all([detectNpm(root), detectYarn(root), detectPnpm(root)]);
-    const found = +hasNpm + +hasYarn + +hasPnpm;
-    log('generalDebug_0003', `Results of the lock file check: npm = ${hasNpm}, Yarn = ${hasYarn}, Pnpm = ${hasPnpm}`);
+    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+
+    const searchedClients = await detectClients(root);
+    const foundClients = searchedClients.filter((m) => m.result);
+
+    log(
+      'generalDebug_0003',
+      `Results of the lock file check: ${searchedClients.map((m) => `${m.client}=${m.result}`).join(', ')}`,
+    );
+
     const defaultClient = config.npmClient;
 
-    if (found !== 1) {
-      const lernaClient = await getLernaNpmClient(root);
+    if (foundClients.length > 1) {
+      const wrapperClient = foundClients.find((m) => isWrapperClient(m.client));
 
-      if (clientTypeKeys.includes(lernaClient)) {
-        log('generalDebug_0003', `Found valid npm client via Lerna: ${lernaClient}.`);
-        return lernaClient;
+      if (wrapperClient) {
+        const { client } = wrapperClient;
+        log('generalDebug_0003', `Found valid wrapper client via lock or config file: "${client}".`);
       }
-    } else if (hasNpm) {
-      log('generalDebug_0003', `Found valid npm client via lockfile.`);
-      return 'npm';
-    } else if (hasYarn) {
-      log('generalDebug_0003', `Found valid Yarn client via lockfile.`);
-      return 'yarn';
-    } else if (hasPnpm) {
-      log('generalDebug_0003', `Found valid pnpm client via lockfile.`);
-      return 'pnpm';
+    }
+
+    if (foundClients.length > 0) {
+      const { client } = foundClients[0];
+
+      if (foundClients.length > 1) {
+        const clientStr = `"${foundClients.map((m) => m.client).join('", "')}"`;
+        log('generalWarning_0001', `Found multiple clients via their lock or config files: ${clientStr}.`);
+      }
+
+      log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+      return client;
     }
 
     if (clientTypeKeys.includes(defaultClient)) {
-      log('generalDebug_0003', `Found valid Pnpm client the default client: "${defaultClient}".`);
+      log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
       return defaultClient;
     }
 
-    log('generalDebug_0003', 'Using the default npm client.');
+    log('generalDebug_0003', 'Using the default "npm" client.');
     return 'npm';
   }
 
@@ -106,103 +110,66 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
-  const c = require(`./clients/npm`);
-  const newRoot = await detectMonorepoRoot(root);
+  const [monorepoRoot, client] = await detectMonorepoRoot(root);
 
-  if (newRoot) {
-    const details = await c.listPackage(refName, newRoot);
-    return details?.dependencies?.[refName]?.extraneous ?? false;
+  if (monorepoRoot) {
+    const c = clients[client];
+    return await c.isProject(monorepoRoot, refName);
   }
 
   return false;
 }
 
-export async function detectMonorepoRoot(root: string): Promise<string> {
-  const file = await getLernaConfigPath(root);
-
-  if (file !== undefined) {
-    return dirname(file);
-  }
-
-  let previous = root;
-
-  do {
-    const packageJson = await readJson(root, 'package.json');
-
-    if (Array.isArray(packageJson?.workspaces)) {
-      return root;
-    }
-
-    previous = root;
-    root = dirname(root);
-  } while (root !== previous);
-
-  return undefined;
+export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
+  const { installDependencies } = clients[client];
+  return installDependencies(target);
 }
 
-export type MonorepoKind = 'none' | 'lerna' | 'yarn';
-
-export async function detectMonorepo(root: string): Promise<MonorepoKind> {
-  const newRoot = await detectMonorepoRoot(root);
-
-  if (newRoot) {
-    const file = await getLernaConfigPath(newRoot);
-
-    if (file !== undefined) {
-      return 'lerna';
-    }
-
-    const packageJson = await readJson(newRoot, 'package.json');
-
-    if (Array.isArray(packageJson?.workspaces)) {
-      return 'yarn';
-    }
-  }
-
-  return 'none';
-}
-
-export function bootstrapMonorepo(target = '.') {
-  const c = require(`./clients/lerna`);
-  return c.bootstrap(target);
-}
-
-export function installDependencies(client: NpmClientType, target = '.'): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installDependencies(target);
-}
-
-export function installPackage(
+export async function installNpmPackage(
   client: NpmClientType,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installPackage(packageRef, target, ...flags);
+  try {
+    const { installPackage } = clients[client];
+    return await installPackage(packageRef, target, ...flags);
+  } catch (ex) {
+    log(
+      'generalError_0002',
+      `Could not install the package "${packageRef}" using ${client}. Make sure ${client} is correctly installed and accessible: ${ex}`,
+    );
+    throw ex;
+  }
+}
+
+export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
+  const { initProject } = clients[client];
+  return initProject(projectName, target);
 }
 
-export function publishPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.publishPackage(target, file, ...flags);
+export function publishNpmPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
+  const { publishPackage } = clients.npm;
+  return publishPackage(target, file, ...flags);
 }
 
-export function createPackage(target = '.'): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.createPackage(target);
+export function createNpmPackage(target = '.'): Promise<string> {
+  const { createPackage } = clients.npm;
+  return createPackage(target);
 }
 
-export function findTarball(packageRef: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findTarball(packageRef);
+export function findNpmTarball(packageRef: string): Promise<string> {
+  const { findTarball } = clients.npm;
+  return findTarball(packageRef);
 }
 
 export function findSpecificVersion(packageName: string, version: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findSpecificVersion(packageName, version);
+  const { findSpecificVersion } = clients.npm;
+  return findSpecificVersion(packageName, version);
 }
 
 export function findLatestVersion(packageName: string) {
+  const { findSpecificVersion } = clients.npm;
   return findSpecificVersion(packageName, 'latest');
 }
 
@@ -210,7 +177,7 @@ export function isLocalPackage(baseDir: string, fullName: string) {
   log('generalDebug_0003', 'Checking if its a local package ...');
 
   if (fullName) {
-    if (/^[\.\/\~]/.test(fullName)) {
+    if (pathPrefixes.some((prefix) => fullName.startsWith(prefix))) {
       log('generalDebug_0003', 'Found a local package by name.');
       return true;
     } else if (fullName.endsWith('.tgz')) {
@@ -249,9 +216,7 @@ export function makeGitUrl(fullName: string) {
 }
 
 export function makeFilePath(basePath: string, fullName: string) {
-  const prefixed = fullName.startsWith(filePrefix);
-  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
-  const absPath = resolve(basePath, relPath);
+  const absPath = resolveAbsPath(basePath, fullName);
   return `${filePrefix}${absPath}`;
 }
 
@@ -275,7 +240,7 @@ export async function dissectPackageName(
     const gitUrl = makeGitUrl(fullName);
     return [gitUrl, 'latest', false, 'git'];
   } else if (isLocalPackage(baseDir, fullName)) {
-    const fullPath = resolve(baseDir, fullName);
+    const fullPath = resolveAbsPath(baseDir, fullName);
     const exists = await checkExists(fullPath);
 
     if (!exists) {
@@ -354,12 +319,63 @@ export async function getCurrentPackageDetails(
   return [combinePackageRef(sourceName, desired, 'registry'), desired];
 }
 
+function tryResolve(...args: Parameters<typeof require.resolve>) {
+  try {
+    return require.resolve(...args);
+  } catch {
+    return undefined;
+  }
+}
+
+export function tryResolvePackage(name: string, baseDir: string = undefined) {
+  let path = baseDir ? tryResolve(name, { paths: [baseDir] }) : tryResolve(name);
+  const root = baseDir || process.cwd();
+
+  if (!path) {
+    if (name.startsWith('.')) {
+      path = resolve(root, name);
+    } else if (isAbsolute(name)) {
+      path = name;
+    } else if (name.includes('/', name.startsWith('@') ? name.indexOf('/') + 1 : 0)) {
+      const parts = name.split('/');
+      const mainPart = name.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+      const mainPath = baseDir ? tryResolve(mainPart, { paths: [baseDir] }) : tryResolve(mainPart);
+      const searchStr = `${sep}${mainPart.replace('/', sep)}${sep}`;
+
+      if (mainPath?.includes(searchStr)) {
+        const rest = name.startsWith('@') ? parts.slice(2) : parts.slice(1);
+        path = mainPath.substring(0, mainPath.indexOf(searchStr) + searchStr.length) + rest.join(sep);
+      }
+    } else {
+      path = resolve(root, 'node_modules', name);
+    }
+
+    if (!existsSync(path)) {
+      path = `${path}.js`;
+
+      if (!existsSync(path)) {
+        path = undefined;
+      }
+    }
+  }
+
+  if (!path) {
+    log('generalDebug_0003', `Could not resolve the package "${name}" in "${root}".`);
+  } else {
+    log('generalVerbose_0004', `Resolved the package "${name}" (from "${root}") to be "${path}".`);
+  }
+
+  return path;
+}
+
+export function findPackageRoot(pck: string, baseDir: string = undefined) {
+  return tryResolvePackage(`${pck}/package.json`, baseDir);
+}
+
 export function isLinkedPackage(name: string, type: PackageType, hadVersion: boolean) {
   if (type === 'registry' && !hadVersion) {
-    try {
-      require.resolve(`${name}/package.json`);
-      return true;
-    } catch {}
+    const root = findPackageRoot(name);
+    return typeof root === 'string';
   }
 
   return false;
@@ -367,7 +383,8 @@ export function isLinkedPackage(name: string, type: PackageType, hadVersion: boo
 
 export function combinePackageRef(name: string, version: string, type: PackageType) {
   if (type === 'registry') {
-    return `${name}@${version || 'latest'}`;
+    const tag = version || 'latest';
+    return `${name}@${tag}`;
   }
 
   return name;
@@ -421,18 +438,22 @@ export function getPackageVersion(
   }
 }
 
-function getExternalsFrom(packageName: string): Array<string> | undefined {
+function getExternalsFrom(root: string, packageName: string): Array<string> | undefined {
   try {
-    return require(`${packageName}/package.json`).sharedDependencies;
-  } catch {
+    const target = require.resolve(`${packageName}/package.json`, {
+      paths: [root],
+    });
+    return require(target).sharedDependencies;
+  } catch (err) {
+    log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
     return undefined;
   }
 }
 
-function getCoreExternals(dependencies: Record<string, string>): Array<string> {
+function getCoreExternals(root: string, dependencies: Record<string, string>): Array<string> {
   for (const frameworkLib of frameworkLibs) {
     if (dependencies[frameworkLib]) {
-      const deps = getExternalsFrom(frameworkLib);
+      const deps = getExternalsFrom(root, frameworkLib);
 
       if (deps) {
         return deps;
@@ -445,24 +466,23 @@ function getCoreExternals(dependencies: Record<string, string>): Array<string> {
 }
 
 export function makePiletExternals(
+  root: string,
   dependencies: Record<string, string>,
   externals: Array<string>,
   fromEmulator: boolean,
   piralInfo: any,
-) {
+): Array<string> {
   if (fromEmulator) {
-    const { sharedDependencies = makeExternals(dependencies, externals, true) } = piralInfo;
+    const { sharedDependencies = mergeExternals(externals, legacyCoreExternals) } = piralInfo;
     return sharedDependencies;
   } else {
-    return makeExternals(dependencies, externals);
+    return makeExternals(root, dependencies, externals);
   }
 }
 
-export function makeExternals(dependencies: Record<string, string>, externals?: Array<string>, legacy = false) {
-  const coreExternals = legacy ? legacyCoreExternals : getCoreExternals(dependencies);
-
-  if (externals && Array.isArray(externals)) {
-    const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
+export function mergeExternals(customExternals?: Array<string>, coreExternals: Array<string> = []) {
+  if (customExternals && Array.isArray(customExternals)) {
+    const [include, exclude] = customExternals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {
         if (typeof curr === 'string') {
           if (curr.startsWith('!')) {
@@ -482,3 +502,8 @@ export function makeExternals(dependencies: Record<string, string>, externals?:
 
   return coreExternals;
 }
+
+export function makeExternals(root: string, dependencies: Record<string, string>, externals?: Array<string>) {
+  const coreExternals = getCoreExternals(root, dependencies);
+  return mergeExternals(externals, coreExternals);
+}

package/src/common/pack.test.ts

@@ -13,7 +13,7 @@ jest.mock('./io', () => ({
 }));
 
 jest.mock('./npm', () => ({
-  createPackage: (target?: string) => {
+  createNpmPackage: (target?: string) => {
     return Promise.resolve(target);
   },
 }));

package/src/common/pack.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from 'path';
 import { log, progress, fail } from './log';
 import { readJson, move } from './io';
-import { createPackage } from './npm';
+import { createNpmPackage } from './npm';
 import { ForceOverwrite } from './enums';
 
 async function getFile(root: string, name: string, dest: string) {
@@ -38,7 +38,7 @@ export async function createPiletPackage(baseDir: string, source: string, target
 
   progress(`Packing pilet in ${dest} ...`);
   log('generalDebug_0003', 'Creating package ...');
-  await createPackage(root);
+  await createNpmPackage(root);
   log('generalDebug_0003', 'Successfully created package.');
   const name = `${pckg.name}-${pckg.version}.tgz`.replace(/@/g, '').replace(/\//g, '-');
   log('generalDebug_0003', `Assumed package name "${name}".`);

package/src/common/package.test.ts

@@ -1,5 +1,4 @@
-import { resolve } from 'path';
-import { findPackageVersion, findPackageRoot, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
+import { findPackageVersion, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
 import { cliVersion } from './info';
 import { SourceLanguage } from './enums';
 
@@ -14,18 +13,6 @@ describe('CLI package module', () => {
     expect(version).toBe('latest');
   });
 
-  it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
-    const dir = process.cwd();
-    const version = findPackageRoot('webpack', dir);
-    expect(version).toBe(resolve(dir, 'node_modules', 'webpack', 'package.json'));
-  });
-
-  it('findPackageRoot returns undefined for invalid package', () => {
-    const dir = process.cwd();
-    const version = findPackageRoot('foo-bar-not-exist', dir);
-    expect(version).toBeUndefined();
-  });
-
   it('getPiletsInfo returns pilets information about provided piralInfo', () => {
     const emptyPiletsInfo = {
       files: [],