piral-cli 0.14.24-beta.4157 → 0.14.24-beta.4168

package/src/common/clients/rush.ts

@@ -0,0 +1,85 @@
+import { dirname, relative, resolve } from 'path';
+import { log } from '../log';
+import { findFile, readText, writeText } from '../io';
+import { jju } from '../../external';
+import { runCommand } from '../scripts';
+import { MemoryStream } from '../MemoryStream';
+
+// Helpers:
+const rushJson = 'rush.json';
+
+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':
+        // discard as this may lead to problems
+        return '';
+      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, rushJson));
+}
+
+export async function initProject(packageName: string, target: string) {
+  const rushPath = await findFile(target, rushJson);
+
+  if (!rushPath) {
+    throw new Error(
+      `Could not find the "${rushJson}" from "${target}". Sure you want to create the project in the right directory?`,
+    );
+  }
+
+  const rushDir = dirname(rushPath);
+  const rushContent = await readText(rushDir, rushJson);
+  const rushData = jju.parse(rushContent);
+  const projectFolder = relative(rushDir, target);
+
+  if (!Array.isArray(rushData.projects)) {
+    rushData.projects = [];
+  }
+
+  rushData.projects.push({
+    packageName,
+    projectFolder,
+  });
+
+  await writeText(
+    rushDir,
+    rushJson,
+    jju.update(rushContent, rushData, {
+      mode: 'cjson',
+      indent: 2,
+    }),
+  );
+}

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,24 @@ 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'));
+}
+
+export async function initProject(projectName: string, target: string) {}

package/src/common/emulator.ts

@@ -3,7 +3,7 @@ import { findDependencyVersion, copyScaffoldingFiles, isValidDependency } from '
 import { createFileFromTemplateIfNotExists } from './template';
 import { filesTar, filesOnceTar } from './constants';
 import { cliVersion } from './info';
-import { createPackage, makeExternals } from './npm';
+import { createNpmPackage, makeExternals } from './npm';
 import { createPiralDeclaration } from './declaration';
 import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
@@ -138,7 +138,7 @@ export async function createEmulatorSources(
 
 export async function packageEmulator(rootDir: string) {
   // finally package everything up
-  await createPackage(rootDir);
+  await createNpmPackage(rootDir);
 
   // get all files
   const names = await getFileNames(rootDir);

package/src/common/info.ts

@@ -15,6 +15,7 @@ export function findCompatVersion(version: string) {
 }
 
 export const nodeVersion = process.version.substring(1);
+export const cliName = info.name;
 export const cliVersion = info.version;
 export const compatVersion = findCompatVersion(cliVersion);
 export const repositoryUrl = info.repository.url;

package/src/common/inspect.ts

@@ -1,5 +1,6 @@
 import { dirname, basename } from 'path';
 import { unpackGzTar } from './archive';
+import { jju } from '../external';
 import { PackageData, PackageFiles } from '../types';
 
 const packageRoot = 'package/';
@@ -8,7 +9,7 @@ function getPackageJson(files: PackageFiles): PackageData {
   const fileName = `${packageRoot}package.json`;
   const fileContent = files[fileName];
   const content = fileContent.toString('utf8');
-  return JSON.parse(content);
+  return jju.parse(content);
 }
 
 function getPiletMainPath(data: PackageData, files: PackageFiles) {

package/src/common/npm.test.ts

@@ -1,16 +1,12 @@
 import { resolve } from 'path';
+import { clients } from './clients';
 import {
   dissectPackageName,
-  installPackage,
-  detectNpm,
-  detectPnpm,
-  detectYarn,
+  installNpmPackage,
   isMonorepoPackageRef,
-  detectMonorepo,
-  bootstrapMonorepo,
-  installDependencies,
-  createPackage,
-  findTarball,
+  installNpmDependencies,
+  createNpmPackage,
+  findNpmTarball,
   findSpecificVersion,
   findLatestVersion,
   isLocalPackage,
@@ -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', () => {
@@ -174,55 +165,66 @@ describe('npm Module', () => {
 
   it('installs a package using the npm command line tool without a target', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Yarn command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Pnpm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool with some flag', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+      expect(result).toEqual(jsonValueString),
+    );
     wrongCase = true;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).not.toEqual(jsonValueString),
     );
   });
 
   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,59 +235,46 @@ 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 () => {
     wrongCase = false;
-    await installDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with pnpm client', async () => {
     wrongCase = false;
-    await installDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with yarn client', async () => {
     wrongCase = false;
-    await installDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('create npm package', async () => {
     wrongCase = false;
-    await createPackage().then((result) => expect(result).toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await createPackage().then((result) => expect(result).not.toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find npm tarball', async () => {
     wrongCase = false;
-    await findTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await findTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find latest version', async () => {