piral-cli 1.0.0-pre.2296 → 1.0.1-beta.5640

package/src/common/archive.test.ts

@@ -45,52 +45,58 @@ jest.mock('path', () =>
 );
 
 const fileNotFoundError = 'File not found!';
-jest.mock('tar', () => ({
-  create: (options: CreateOptions & FileOptions, fileList: ReadonlyArray<string>) => {
-    return new Promise((resolve, reject) => {
-      if (options.file && options.file == 'foo.txt') {
-        resolve(true);
-      } else {
-        reject(fileNotFoundError);
-      }
-    });
-  },
-  extract: (options: ExtractOptions & FileOptions, fileList?: ReadonlyArray<string>) => {
-    return new Promise((resolve, reject) => {
-      if (options.file && options.file.includes('foo.tgz')) {
-        resolve(true);
-      } else {
-        reject(fileNotFoundError);
-      }
-    });
-  },
-  Parse: () => {
-    return {
-      position: 0,
-      _stream: new Stream(),
-      _ended: false,
-      _streamEnd: () => {
-        this._ended = true;
-        console.log('_streamEnd');
-      },
-      process: (c: Buffer) => {
-        console.log('process');
-      },
-      _startEntry: (c: Buffer) => {
-        console.log('_startEntry');
-      },
-      on: (event: string, listener: (...args: any[]) => {}) => {
-        console.log(`on event: ${event}`);
-      },
-      once: (event: string, listener: (...args: any[]) => {}) => {
-        console.log(`once event: ${event}`);
-      },
-      emit: (event: string | symbol, ...args: any[]) => {
-        console.log(`emit event: ${event.toString()}`);
-        return true;
-      },
-    } as any;
+
+jest.mock('../external', () => ({
+  ora() {
+    return {};
   },
+  tar: {
+    create: (options: CreateOptions & FileOptions, fileList: ReadonlyArray<string>) => {
+      return new Promise((resolve, reject) => {
+        if (options.file && options.file == 'foo.txt') {
+          resolve(true);
+        } else {
+          reject(fileNotFoundError);
+        }
+      });
+    },
+    extract: (options: ExtractOptions & FileOptions, fileList?: ReadonlyArray<string>) => {
+      return new Promise((resolve, reject) => {
+        if (options.file && options.file.includes('foo.tgz')) {
+          resolve(true);
+        } else {
+          reject(fileNotFoundError);
+        }
+      });
+    },
+    Parse: () => {
+      return {
+        position: 0,
+        _stream: new Stream(),
+        _ended: false,
+        _streamEnd: () => {
+          this._ended = true;
+          console.log('_streamEnd');
+        },
+        process: (c: Buffer) => {
+          console.log('process');
+        },
+        _startEntry: (c: Buffer) => {
+          console.log('_startEntry');
+        },
+        on: (event: string, listener: (...args: any[]) => {}) => {
+          console.log(`on event: ${event}`);
+        },
+        once: (event: string, listener: (...args: any[]) => {}) => {
+          console.log(`once event: ${event}`);
+        },
+        emit: (event: string | symbol, ...args: any[]) => {
+          console.log(`emit event: ${event.toString()}`);
+          return true;
+        },
+      } as any;
+    },
+  }
 }));
 
 describe('Archive Module', () => {

package/src/common/archive.ts

@@ -1,6 +1,7 @@
-import { resolve, relative } from 'path';
 import { createGunzip } from 'zlib';
 import { EventEmitter } from 'events';
+import { createWriteStream } from 'fs';
+import { resolve, relative } from 'path';
 import { log } from './log';
 import { tar } from '../external';
 import { PackageFiles } from '../types';
@@ -11,6 +12,32 @@ interface ReadEntry extends EventEmitter {
   ignore: boolean;
 }
 
+/**
+ * Creates an npm-style tgz.
+ */
+export function createTgz(file: string, cwd: string, files: Array<string>) {
+  const stream = createWriteStream(file);
+
+  const tgz = tar.create(
+    {
+      cwd,
+      prefix: 'package/',
+      portable: true,
+      follow: true,
+      gzip: {
+        level: 9,
+      },
+      // @ts-ignore
+      mtime: new Date('1985-10-26T08:15:00.000Z'),
+    },
+    files,
+  );
+
+  tgz.pipe(stream, { end: true });
+
+  return new Promise((finish) => stream.on('close', finish));
+}
+
 export function createTarball(sourceDir: string, targetDir: string, targetFile: string) {
   const folder = relative(targetDir, sourceDir);
   log('generalDebug_0003', `Create archive "${targetFile}" in "${targetDir}" containing "${folder}".`);

package/src/common/browser.test.ts

@@ -2,23 +2,33 @@ import { openBrowser } from './browser';
 
 let error = false;
 
-jest.mock('open', () => (...args) => {
-  if (error) {
-    throw new Error('Error occured');
-  } else {
-    return null;
-  }
-});
+jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
+  ora() {
+    return {
+      fail() {},
+    };
+  },
+  open() {
+    if (error) {
+      throw new Error('Error occured');
+    } else {
+      return null;
+    }
+  },
+}));
 
 describe('Browser Module', () => {
   it('opens browser successfully', async () => {
     error = false;
-    await openBrowser(false, 1234).then((result) => expect(result).toBeUndefined());
-    await openBrowser(true, 1234).then((result) => expect(result).toBeUndefined());
+    await openBrowser(false, 1234, '/').then((result) => expect(result).toBeUndefined());
+    await openBrowser(true, 1234, '/').then((result) => expect(result).toBeUndefined());
   });
 
   it('handles errored opening', async () => {
     error = true;
-    await openBrowser(true, 1234).then((result) => expect(result).toBeUndefined());
+    await openBrowser(true, 1234, '/').then((result) => expect(result).toBeUndefined());
   });
 });

package/src/common/browser.ts

@@ -1,12 +1,19 @@
 import { log } from './log';
+import { config } from './config';
 import { open } from '../external';
 
-export async function openBrowser(shouldOpen: boolean, port: number) {
+export async function openBrowserAt(address: string) {
+  try {
+    await open(address, undefined);
+  } catch (err) {
+    log('failedToOpenBrowser_0170', err);
+  }
+}
+
+export async function openBrowser(shouldOpen: boolean, port: number, path: string, https?: boolean) {
   if (shouldOpen) {
-    try {
-      await open(`http://localhost:${port}`, undefined);
-    } catch (err) {
-      log('failedToOpenBrowser_0170', err);
-    }
+    const scheme = https ? 'https' : 'http';
+    const address = `${scheme}://${config.host}:${port}${path}`;
+    await openBrowserAt(address);
   }
 }

package/src/common/clients/index.ts

@@ -0,0 +1,41 @@
+import { dirname, resolve } from 'path';
+import { findFile } from '../io';
+
+import * as lerna from './lerna';
+import * as npm from './npm';
+import * as pnp from './pnp';
+import * as pnpm from './pnpm';
+import * as rush from './rush';
+import * as yarn from './yarn';
+
+export const clients = {
+  lerna,
+  npm,
+  pnp,
+  pnpm,
+  rush,
+  yarn,
+};
+
+type ClientName = keyof typeof clients;
+
+const directClients = ['npm', 'pnp', 'yarn', 'pnpm'];
+
+export function isWrapperClient(client: ClientName) {
+  return !directClients.includes(client);
+}
+
+export async function detectClients(root: string) {
+  const packageJson = await findFile(resolve(root, '..'), 'package.json');
+  const stopDir = packageJson ? dirname(packageJson) : undefined;
+
+  return await Promise.all(
+    Object.keys(clients).map(async (client: ClientName) => {
+      const result = await clients[client].detectClient(root, stopDir);
+      return {
+        client,
+        result,
+      };
+    }),
+  );
+}

package/src/common/clients/lerna.ts

@@ -1,17 +1,101 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile, readJson, writeJson } from '../io';
 import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
+// Helpers:
+
 function runLernaProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
   log('generalDebug_0003', 'Starting the Lerna process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('lerna', args, cwd, output);
 }
 
-export async function bootstrap(target = '.', ...flags: Array<string>) {
+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 runLernaProcess(['bootstrap', ...flags], target, ms);
   log('generalDebug_0003', `Lerna bootstrap result: ${ms.value}`);
   return ms.value;
 }
+
+export async function uninstallPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  // at the moment not supported by Lerna directly
+  // workaround is to manipulate the package.json directly and bootstrap again...
+  const packageData = await readJson(target, 'package.json');
+
+  if (packageData.dependencies && packageRef in packageData.dependencies) {
+    packageData.dependencies[packageRef] = undefined;
+  }
+
+  if (packageData.devDependencies && packageRef in packageData.devDependencies) {
+    packageData.devDependencies[packageRef] = undefined;
+  }
+
+  if (packageData.peerDependencies && packageRef in packageData.peerDependencies) {
+    packageData.peerDependencies[packageRef] = undefined;
+  }
+
+  await writeJson(target, 'package.json', packageData, true);
+  await runLernaProcess(['bootstrap'], target, ms);
+  log('generalDebug_0003', `Lerna bootstrap (after remove) package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runLernaProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Lerna add package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string, stopDir = resolve(root, '/')) {
+  return !!(await findFile(root, 'lerna.json', stopDir));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const projects = await listProjects(root);
+
+  if (Array.isArray(projects)) {
+    return projects?.some((p) => p.name === packageRef) ?? false;
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from lerna client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runLernaProcess(['list', '--json', '-p'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `lerna list error: ${e}`);
+    return [];
+  }
+
+  log('generalDebug_0003', `lerna list project result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}

package/src/common/clients/npm.ts

@@ -1,60 +1,101 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile } from '../io';
 import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
+// Helpers:
+
 function runNpmProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the NPM process ...');
+  log('generalDebug_0003', 'Starting the npm process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('npm', args, cwd, output);
 }
 
+// Client interface functions:
+
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['install', '--legacy-peer-deps', ...flags], target, ms);
-  log('generalDebug_0003', `NPM install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `npm install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
-export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+export async function uninstallPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
-  await runNpmProcess(['pack', packageRef, ...flags], target, ms);
-  log('generalDebug_0003', `NPM (un)pack result: ${ms.value}`);
+  await runNpmProcess(['uninstall', packageRef, ...flags], target, ms);
+  log('generalDebug_0003', `npm uninstall package result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['install', packageRef, '--legacy-peer-deps', ...flags], target, ms);
-  log('generalDebug_0003', `NPM install package result: ${ms.value}`);
+  log('generalDebug_0003', `npm install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string, stopDir = resolve(root, '/')) {
+  return !!(await findFile(root, 'package-lock.json', stopDir));
+}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listPackage(packageRef, root);
+  const packageDetails =  details?.dependencies?.[packageRef];
+
+  if (packageDetails && typeof packageDetails.resolved === 'string') {
+    return packageDetails.resolved.startsWith('file:');
+  }
+
+  return false;
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+// Functions to exclusively use from npm client:
+
+export async function loginUser() {
+  await runNpmProcess(['login'], '.');
+}
+
+export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runNpmProcess(['pack', packageRef, ...flags], target, ms);
+  log('generalDebug_0003', `npm (un)pack result: ${ms.value}`);
   return ms.value;
 }
 
 export async function createPackage(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['pack', ...flags], target, ms);
-  log('generalDebug_0003', `NPM pack result: ${ms.value}`);
+  log('generalDebug_0003', `npm pack result: ${ms.value}`);
   return ms.value;
 }
 
 export async function publishPackage(target = '.', file = '*.tgz', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['publish', file, ...flags], target, ms);
-  log('generalDebug_0003', `NPM publish result: ${ms.value}`);
+  log('generalDebug_0003', `npm publish result: ${ms.value}`);
   return ms.value;
 }
 
 export async function findSpecificVersion(packageName: string, version: string) {
   const ms = new MemoryStream();
-  await runNpmProcess(['show', packageName, 'version', '--tag', version], '.', ms);
-  log('generalDebug_0003', `NPM show result: ${ms.value}`);
-  return ms.value;
+
+  try {
+    await runNpmProcess(['show', packageName, 'version', '--tag', version], '.', ms);
+    log('generalDebug_0003', `npm show result: ${ms.value}`);
+    return ms.value;
+  } catch (ex) {
+    log('generalDebug_0003', `npm show result: ${ex}`);
+    return '';
+  }
 }
 
 export async function findTarball(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['view', packageRef, 'dist.tarball', ...flags], target, ms);
-  log('generalDebug_0003', `NPM view packageRef result: ${ms.value}`);
+  log('generalDebug_0003', `npm view packageRef result: ${ms.value}`);
   return ms.value;
 }
 
@@ -64,9 +105,10 @@ export async function listPackage(packageRef: string, target = '.', ...flags: Ar
   try {
     await runNpmProcess(['ls', packageRef, '--json', '--depth', '0', ...flags], target, ms);
   } catch (e) {
-    log('generalDebug_0003', `NPM ls packageRef error: ${e}`);
+    log('generalDebug_0003', `npm ls packageRef error: ${e}`);
+    return {};
   }
 
-  log('generalDebug_0003', `NPM ls packageRef result: ${ms.value}`);
+  log('generalDebug_0003', `npm ls packageRef result: ${ms.value}`);
   return JSON.parse(ms.value);
 }

package/src/common/clients/pnp.ts

@@ -0,0 +1,84 @@
+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 PnP process ...');
+  const cwd = resolve(process.cwd(), target);
+  return runCommand('yarn', 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 (https://github.com/yarnpkg/yarn/issues/1743)
+        return '';
+      default:
+        return flag;
+    }
+  });
+}
+
+// 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 PnP install dependencies result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function uninstallPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['remove', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP remove package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP add package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string, stopDir = resolve(root, '/')) {
+  return !!(await findFile(root, '.pnp.cjs', stopDir));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listProjects(root);
+
+  if (typeof details === 'object') {
+    return typeof details?.[packageRef]?.location === 'string';
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from yarn client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runYarnProcess(['workspaces', 'info'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `yarn workspaces error: ${e}`);
+    return {};
+  }
+
+  log('generalDebug_0003', `yarn workspaces result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}

package/src/common/clients/pnpm.ts

@@ -1,8 +1,11 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile } from '../io';
 import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
+// Helpers:
+
 function runPnpmProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
   log('generalDebug_0003', 'Starting the Pnpm process ...');
   const cwd = resolve(process.cwd(), target);
@@ -21,6 +24,8 @@ function convert(flags: Array<string>) {
   });
 }
 
+// Client interface functions:
+
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runPnpmProcess(['install', ...convert(flags)], target, ms);
@@ -28,9 +33,48 @@ export async function installDependencies(target = '.', ...flags: Array<string>)
   return ms.value;
 }
 
+export async function uninstallPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runPnpmProcess(['remove', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Pnpm remove package result: ${ms.value}`);
+  return ms.value;
+}
+
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runPnpmProcess(['add', packageRef, ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Pnpm install package result: ${ms.value}`);
+  log('generalDebug_0003', `Pnpm add package result: ${ms.value}`);
   return ms.value;
 }
+
+export async function detectClient(root: string, stopDir = resolve(root, '/')) {
+  return !!(await findFile(root, ['pnpm-lock.yaml', 'pnpm-workspace.yaml'], stopDir));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const projects = await listProjects(root);
+
+  if (Array.isArray(projects)) {
+    return projects?.some((p) => p.name === packageRef) ?? false;
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from pnpm client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runPnpmProcess(['list', '--json', '--recursive', '--depth', '0'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `pnpm list error: ${e}`);
+    return [];
+  }
+
+  log('generalDebug_0003', `pnpm list project result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}