piral-cli 0.14.24-beta.4161 → 0.14.24-beta.4163

package/src/common/clients/rush.ts

@@ -0,0 +1,49 @@
+import { resolve } from 'path';
+import { log } from '../log';
+import { findFile } from '../io';
+import { runCommand } from '../scripts';
+import { MemoryStream } from '../MemoryStream';
+
+// Helpers:
+
+function runRushProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
+  log('generalDebug_0003', 'Starting the Rush process ...');
+  const cwd = resolve(process.cwd(), target);
+  return runCommand('rush', args, cwd, output);
+}
+
+function convert(flags: Array<string>) {
+  return flags.map((flag) => {
+    switch (flag) {
+      case '--save-exact':
+        return '--exact';
+      case '--save-dev':
+        return '--dev';
+      case '--no-save':
+        // unfortunately no
+        return '';
+      default:
+        return flag;
+    }
+  });
+}
+
+// Client interface functions:
+
+export async function installDependencies(target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runRushProcess(['update', ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Rush install dependencies result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runRushProcess(['add', '--package', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Rush install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'rush.json'));
+}

package/src/common/clients/yarn.ts

@@ -1,10 +1,13 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile } from '../io';
 import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
+// Helpers:
+
 function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the Yarn process ...');
+  log('generalDebug_0003', 'Starting the Yarn@1 process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('yarn', args, cwd, output);
 }
@@ -25,24 +28,22 @@ function convert(flags: Array<string>) {
   });
 }
 
+// Client interface functions:
+
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['install', ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn@1 install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
-  try {
-    const ms = new MemoryStream();
-    await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
-    log('generalDebug_0003', `Yarn install package result: ${ms.value}`);
-    return ms.value;
-  } catch (ex) {
-    log(
-      'generalError_0002',
-      `Could not install the package "${packageRef}" using Yarn. Make sure Yarn@1 is correctly installed and accessible: ${ex}`,
-    );
-    throw ex;
-  }
+  const ms = new MemoryStream();
+  await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn@1 install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'yarn.lock'));
 }

package/src/common/npm.test.ts

@@ -1,13 +1,9 @@
 import { resolve } from 'path';
+import { clients } from './clients';
 import {
   dissectPackageName,
   installPackage,
-  detectNpm,
-  detectPnpm,
-  detectYarn,
   isMonorepoPackageRef,
-  detectMonorepo,
-  bootstrapMonorepo,
   installDependencies,
   createPackage,
   findTarball,
@@ -42,6 +38,7 @@ jest.mock('../external', () => ({
 }));
 
 let specialCase = false;
+let shouldFind = true;
 let wrongCase = false;
 const jsonValueString = JSON.stringify({ dependencies: { npm: { extraneous: true } } });
 const jsonValueStringWrong = JSON.stringify({ dependencies: {} });
@@ -56,14 +53,15 @@ jest.mock('./scripts', () => ({
 }));
 
 jest.mock('fs', () => ({
-  constants: {
-    F_OK: 1,
-  },
   createReadStream() {
     return undefined;
   },
   exists: (file: string, cb: (status: boolean) => void) =>
-    cb(!file.endsWith('package.json') && !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock')))),
+    cb(
+      shouldFind &&
+        !file.endsWith('package.json') &&
+        !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
+    ),
   existsSync: (file: string) => {
     return true;
   },
@@ -72,13 +70,6 @@ jest.mock('fs', () => ({
   },
   realpathSync: () => ({}),
   readFileSync: () => '',
-  access: (path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void) => {
-    if (path.includes('test')) {
-      return callback(undefined);
-    } else {
-      return callback(new Error('bla'));
-    }
-  },
 }));
 
 describe('npm Module', () => {
@@ -210,19 +201,28 @@ describe('npm Module', () => {
   });
 
   it('detectNpm finds package-lock.json', async () => {
-    await detectNpm('test').then((result) => expect(result).toBeTruthy());
-    await detectNpm('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
+    await clients.npm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.npm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
-  it('detectPnpm finds nppm-lock.yaml', async () => {
-    await detectPnpm('test').then((result) => expect(result).toBeTruthy());
-    await detectPnpm('toast').then((result) => expect(result).toBeFalsy());
+  it('detectPnpm finds pnpm-lock.yaml', async () => {
+    shouldFind = true;
+    await clients.pnpm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.pnpm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
   it('detectYarn finds yarn.lock', async () => {
-    await detectYarn('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = true;
+    await clients.yarn.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
     specialCase = true;
-    await detectYarn('toast').then((result) => expect(result).toBeFalsy());
+    await clients.yarn.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
     specialCase = false;
   });
 
@@ -233,24 +233,11 @@ describe('npm Module', () => {
     await isMonorepoPackageRef('npm', './').then((result) => expect(result).toBeFalsy());
   });
 
-  it('verifies whether lerna config path is valid', async () => {
-    wrongCase = false;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('lerna');
-    });
-    wrongCase = true;
-    specialCase = true;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('none');
-    });
-    specialCase = false;
-  });
-
   it('verifies whether lerna bootstrap ran', async () => {
     wrongCase = false;
-    await bootstrapMonorepo().then((result) => expect(result).toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await bootstrapMonorepo().then((result) => expect(result).not.toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with npm client', async () => {

package/src/common/npm.ts

@@ -1,6 +1,7 @@
 import { resolve, relative, dirname } from 'path';
-import { createReadStream, existsSync, access, constants } from 'fs';
+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';
@@ -23,48 +24,28 @@ function resolveAbsPath(basePath: string, fullName: string) {
   return resolve(basePath, relPath);
 }
 
-export function detectPnpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'pnpm-lock.yaml'), constants.F_OK, (noPnpmLock) => {
-      res(!noPnpmLock);
-    });
-  });
-}
-
-export function detectNpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'package-lock.json'), constants.F_OK, (noPackageLock) => {
-      res(!noPackageLock);
-    });
-  });
-}
-
-export async function detectYarn(root: string) {
-  return !!(await findFile(root, 'yarn.lock'));
-}
-
-export async function getLernaConfigPath(root: string) {
-  log('generalDebug_0003', 'Trying to get the configuration file for Lerna ...');
-  const file = await findFile(root, 'lerna.json');
+async function detectMonorepoRoot(root: string): Promise<string> {
+  let previous = root;
 
-  if (file) {
-    log('generalDebug_0003', `Found Lerna config in "${file}".`);
-    return file;
-  }
+  do {
+    const isMonorepo =
+      (await checkExists(resolve(root, 'lerna.json'))) ||
+      (await checkExists(resolve(root, 'rush.json'))) ||
+      (await checkExists(resolve(root, 'pnpm-workspace.yaml')));
 
-  return undefined;
-}
+    if (isMonorepo) {
+      return root;
+    }
 
-export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
-  const file = await getLernaConfigPath(root);
+    const packageJson = await readJson(root, 'package.json');
 
-  if (file) {
-    try {
-      return require(file).npmClient;
-    } catch (err) {
-      log('generalError_0002', `Could not read lerna.json: ${err}.`);
+    if (Array.isArray(packageJson?.workspaces)) {
+      return root;
     }
-  }
+
+    previous = root;
+    root = dirname(root);
+  } while (root !== previous);
 
   return undefined;
 }
@@ -76,36 +57,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';
   }
 
@@ -113,103 +103,62 @@ 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);
 
   if (newRoot) {
-    const details = await c.listPackage(refName, newRoot);
+    const { listPackage } = clients.npm;
+    const details = await listPackage(refName, newRoot);
     return details?.dependencies?.[refName]?.extraneous ?? false;
   }
 
   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 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);
+  const { installDependencies } = clients[client];
+  return installDependencies(target);
 }
 
-export function installPackage(
+export async function installPackage(
   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 publishPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.publishPackage(target, file, ...flags);
+  const { publishPackage } = clients.npm;
+  return publishPackage(target, file, ...flags);
 }
 
 export function createPackage(target = '.'): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.createPackage(target);
+  const { createPackage } = clients.npm;
+  return createPackage(target);
 }
 
 export function findTarball(packageRef: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findTarball(packageRef);
+  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');
 }
 

package/src/common/scaffold.ts

@@ -1,5 +1,5 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
-import { installPackage } from './clients/npm';
+import { installPackage } from './npm';
 import { ForceOverwrite, SourceLanguage } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { log, fail } from './log';
@@ -36,7 +36,7 @@ async function getTemplateFiles(
   if (templatePackageName.startsWith('.')) {
     templatePackageName = resolve(process.cwd(), templatePackageName);
   } else {
-    await installPackage(templatePackageName, __dirname, '--registry', registry);
+    await installPackage('npm', templatePackageName, __dirname, '--registry', registry);
   }
 
   const templateRunner = getTemplatePackage(templatePackageName);

package/src/helpers.ts

@@ -15,7 +15,7 @@ export const publishModeKeys: Array<PiletPublishScheme> = ['none', 'basic', 'bea
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone', 'manifest'];
-export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
+export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn', 'lerna', 'rush'];
 export const bundlerKeys: Array<string> = ['none', ...bundlerNames];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];

package/src/types/public.ts

@@ -226,7 +226,7 @@ export type PiletBuildType = 'default' | 'standalone' | 'manifest';
 
 export type PackageType = 'registry' | 'file' | 'git';
 
-export type NpmClientType = 'npm' | 'yarn' | 'pnpm';
+export type NpmClientType = 'npm' | 'yarn' | 'pnpm' | 'lerna' | 'rush';
 
 export type Framework = 'piral' | 'piral-core' | 'piral-base';