piral-cli 0.15.0-alpha.4122 → 0.15.0-alpha.4284

package/src/apps/publish-piral.ts

@@ -1,7 +1,7 @@
 import { resolve } from 'path';
 import { publishArtifacts } from '../release';
 import { LogLevels, PiralBuildType } from '../types';
-import { setLogLevel, progress, checkExists, fail, logDone, logReset, publishPackage, matchFiles } from '../common';
+import { setLogLevel, progress, checkExists, fail, logDone, logReset, publishNpmPackage, matchFiles } from '../common';
 
 export interface PublishPiralOptions {
   /**
@@ -19,6 +19,11 @@ export interface PublishPiralOptions {
    */
   fields?: Record<string, string>;
 
+  /**
+   * Defines if authorization tokens can be retrieved interactively.
+   */
+  interactive?: boolean;
+
   /**
    * The provider to use for publishing the release artifacts.
    */
@@ -36,9 +41,15 @@ export const publishPiralDefaults: PublishPiralOptions = {
   type: 'all',
   provider: 'none',
   fields: {},
+  interactive: false,
 };
 
-async function publishEmulator(baseDir: string, source: string, args: Record<string, string> = {}) {
+async function publishEmulator(
+  baseDir: string,
+  source: string,
+  args: Record<string, string> = {},
+  interactive = false,
+) {
   const type = 'emulator';
   const directory = resolve(baseDir, source, type);
   const exists = await checkExists(directory);
@@ -58,7 +69,9 @@ async function publishEmulator(baseDir: string, source: string, args: Record<str
     p.push(`--${c}`, args[c]);
     return p;
   }, [] as Array<string>);
-  await publishPackage(directory, file, flags);
+
+  //TODO support interactive here, too?
+  await publishNpmPackage(directory, file, flags);
 }
 
 async function publishRelease(
@@ -66,6 +79,7 @@ async function publishRelease(
   source: string,
   providerName: string,
   args: Record<string, string> = {},
+  interactive = false,
 ) {
   const type = 'release';
   const directory = resolve(baseDir, source, type);
@@ -76,7 +90,7 @@ async function publishRelease(
   }
 
   const files = await matchFiles(directory, '**/*');
-  await publishArtifacts(providerName, files, args);
+  await publishArtifacts(providerName, directory, files, args, interactive);
 }
 
 export async function publishPiral(baseDir = process.cwd(), options: PublishPiralOptions = {}) {
@@ -86,6 +100,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     logLevel = publishPiralDefaults.logLevel,
     fields = publishPiralDefaults.fields,
     provider = publishPiralDefaults.provider,
+    interactive = publishPiralDefaults.interactive,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
@@ -98,14 +113,14 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
 
   if (type !== 'release') {
     progress('Publishing emulator package ...');
-    await publishEmulator(fullBase, source, fields);
+    await publishEmulator(fullBase, source, fields, interactive);
     logDone(`Successfully published emulator.`);
     logReset();
   }
 
   if (type !== 'emulator') {
     progress('Publishing release files ...');
-    await publishRelease(fullBase, source, provider, fields);
+    await publishRelease(fullBase, source, provider, fields, interactive);
     logDone(`Successfully published release.`);
     logReset();
   }

package/src/apps/upgrade-pilet.ts

@@ -2,7 +2,7 @@ import { resolve } from 'path';
 import { LogLevels, NpmClientType } from '../types';
 import {
   readJson,
-  installPackage,
+  installNpmPackage,
   checkExistingDirectory,
   patchPiletPackage,
   copyPiralFiles,
@@ -10,7 +10,7 @@ import {
   readPiralPackage,
   getPiletsInfo,
   runScript,
-  installDependencies,
+  installNpmDependencies,
   getCurrentPackageDetails,
   checkAppShellPackage,
   setLogLevel,
@@ -22,8 +22,6 @@ import {
   ForceOverwrite,
   copyScaffoldingFiles,
   getPiralPath,
-  detectMonorepo,
-  bootstrapMonorepo,
   isMonorepoPackageRef,
   getPiletScaffoldData,
   SourceLanguage,
@@ -131,7 +129,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     if (!monorepoRef) {
       // only install the latest if the shell does come from remote
       progress(`Updating npm package to %s ...`, packageRef);
-      await installPackage(npmClient, packageRef, root, '--no-save');
+      await installNpmPackage(npmClient, packageRef, root, '--no-save');
     }
 
     const piralInfo = await readPiralPackage(root, sourceName);
@@ -164,13 +162,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
 
     if (install) {
       progress(`Updating dependencies ...`);
-      const monorepoKind = await detectMonorepo(root);
-
-      if (monorepoKind === 'lerna') {
-        await bootstrapMonorepo(root);
-      } else {
-        await installDependencies(npmClient, root);
-      }
+      await installNpmDependencies(npmClient, root);
     }
 
     if (postUpgrade) {

package/src/apps/upgrade-piral.ts

@@ -3,7 +3,7 @@ import { LogLevels, NpmClientType } from '../types';
 import {
   readJson,
   checkExistingDirectory,
-  installDependencies,
+  installNpmDependencies,
   setLogLevel,
   progress,
   fail,
@@ -113,7 +113,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
 
   if (install) {
     progress(`Updating the npm packages to %s ...`, version);
-    await installDependencies(npmClient, root);
+    await installNpmDependencies(npmClient, root);
   }
 
   logDone('Piral instance upgraded successfully!');

package/src/bundler.test.ts

@@ -48,7 +48,7 @@ jest.mock('./common', () => ({
     bundler: 'parcel',
   },
   cliVersion: '1.0.0',
-  installPackage: jest.fn(),
+  installNpmPackage: jest.fn(),
   fail(msg) {
     throw new Error(msg);
   },

package/src/bundler.ts

@@ -1,7 +1,7 @@
 import { callDynamic, callStatic } from './build/bundler-calls';
 import { availableBundlers } from './helpers';
 import {
-  installPackage,
+  installNpmPackage,
   cliVersion,
   fail,
   progress,
@@ -39,7 +39,7 @@ async function installDefaultBundler(root: string) {
   const client = await determineNpmClient(root);
   log('generalDebug_0003', `Prepare to install ${selectedPackage}@${cliVersion} using "${client}" into "${root}".`);
   progress(`Installing ${selectedPackage} ...`);
-  await installPackage(client, `${selectedPackage}@${cliVersion}`, root, '--save-dev', '--save-exact');
+  await installNpmPackage(client, `${selectedPackage}@${cliVersion}`, root, '--save-dev', '--save-exact');
   log('generalDebug_0003', `Installed bundler from "${selectedPackage}".`);
 
   require('./inject').inject(selectedPackage);

package/src/commands.ts

@@ -6,9 +6,9 @@ import {
   forceOverwriteKeys,
   keyOfForceOverwrite,
   valueOfForceOverwrite,
-  keyOfPiletLanguage,
-  piletLanguageKeys,
-  valueOfPiletLanguage,
+  keyOfSourceLanguage,
+  sourceLanguageKeys,
+  valueOfSourceLanguage,
   frameworkKeys,
   clientTypeKeys,
   schemaKeys,
@@ -208,6 +208,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .option('fields', undefined)
         .describe('fields', 'Sets additional fields to be included in the feed service request.')
         .default('fields', apps.publishPiralDefaults.fields)
+        .boolean('interactive')
+        .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
+        .default('interactive', apps.publishPiralDefaults.interactive)
         .string('base')
         .default('base', process.cwd())
         .describe('base', 'Sets the base directory. By default the current directory is used.');
@@ -219,6 +222,7 @@ const allCommands: Array<ToolCommand<any>> = [
         type: args.type as PiralBuildType,
         provider: args.provider as string,
         fields: args.fields as Record<string, string>,
+        interactive: args.interactive as boolean,
       });
     },
   },
@@ -293,9 +297,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('force-overwrite', forceOverwriteKeys)
         .describe('force-overwrite', 'Determines if files should be overwritten by the installation.')
         .default('force-overwrite', keyOfForceOverwrite(apps.newPiralDefaults.forceOverwrite))
-        .choices('language', piletLanguageKeys)
+        .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new Piral instance.')
-        .default('language', keyOfPiletLanguage(apps.newPiralDefaults.language))
+        .default('language', keyOfSourceLanguage(apps.newPiralDefaults.language))
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiralDefaults.template)
@@ -320,7 +324,7 @@ const allCommands: Array<ToolCommand<any>> = [
         version: args.tag as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfPiletLanguage(args.language as string),
+        language: valueOfSourceLanguage(args.language as string),
         install: args.install as boolean,
         template: args.template as string,
         logLevel: args['log-level'] as LogLevels,
@@ -623,6 +627,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .option('headers', undefined)
         .describe('headers', 'Sets additional headers to be included in the feed service request.')
         .default('headers', apps.publishPiletDefaults.headers)
+        .boolean('interactive')
+        .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
+        .default('interactive', apps.publishPiletDefaults.interactive)
         .string('base')
         .default('base', process.cwd())
         .describe('base', 'Sets the base directory. By default the current directory is used.');
@@ -641,6 +648,7 @@ const allCommands: Array<ToolCommand<any>> = [
         fields: args.fields as Record<string, string>,
         headers: args.headers as Record<string, string>,
         mode: args.mode as PiletPublishScheme,
+        interactive: args.interactive as boolean,
         _: args,
       });
     },
@@ -674,9 +682,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .number('log-level')
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.newPiletDefaults.logLevel)
-        .choices('language', piletLanguageKeys)
+        .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new pilet.')
-        .default('language', keyOfPiletLanguage(apps.newPiletDefaults.language))
+        .default('language', keyOfSourceLanguage(apps.newPiletDefaults.language))
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiletDefaults.template)
@@ -699,7 +707,7 @@ const allCommands: Array<ToolCommand<any>> = [
         source: args.source as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfPiletLanguage(args.language as string),
+        language: valueOfSourceLanguage(args.language as string),
         logLevel: args['log-level'] as LogLevels,
         install: args.install as boolean,
         template: args.template as string,

package/src/common/browser.ts

@@ -1,15 +1,19 @@
 import { log } from './log';
-import { open } from '../external';
 import { config } from './config';
+import { open } from '../external';
+
+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 {
-      const scheme = https ? 'https' : 'http';
-      const address = `${scheme}://${config.host}:${port}${path}`;
-      await open(address, 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,33 @@
+import * as lerna from './lerna';
+import * as npm from './npm';
+import * as pnpm from './pnpm';
+import * as rush from './rush';
+import * as yarn from './yarn';
+
+export const clients = {
+  lerna,
+  npm,
+  pnpm,
+  rush,
+  yarn,
+};
+
+type ClientName = keyof typeof clients;
+
+const directClients = ['npm', 'yarn', 'pnpm'];
+
+export function isWrapperClient(client: ClientName) {
+  return !directClients.includes(client);
+}
+
+export function detectClients(root: string) {
+  return Promise.all(
+    Object.keys(clients).map(async (client: ClientName) => {
+      const result = await clients[client].detectClient(root);
+      return {
+        client,
+        result,
+      };
+    }),
+  );
+}

package/src/common/clients/lerna.ts

@@ -1,17 +1,77 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile } 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 installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runLernaProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Lerna install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'lerna.json'));
+}
+
+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,14 +1,19 @@
 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 ...');
   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);
@@ -16,26 +21,37 @@ export async function installDependencies(target = '.', ...flags: Array<string>)
   return ms.value;
 }
 
-export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+export async function installPackage(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(['install', packageRef, '--legacy-peer-deps', ...flags], target, ms);
+  log('generalDebug_0003', `npm install package result: ${ms.value}`);
   return ms.value;
 }
 
-export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
-  try {
-    const ms = new MemoryStream();
-    await runNpmProcess(['install', packageRef, '--legacy-peer-deps', ...flags], target, ms);
-    log('generalDebug_0003', `npm install package result: ${ms.value}`);
-    return ms.value;
-  } catch (ex) {
-    log(
-      'generalError_0002',
-      `Could not install the package "${packageRef}" using npm. Make sure npm is correctly installed and accessible: ${ex}`,
-    );
-    throw ex;
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'package-lock.json'));
+}
+
+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 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>) {
@@ -73,6 +89,7 @@ export async function listPackage(packageRef: string, target = '.', ...flags: Ar
     await runNpmProcess(['ls', packageRef, '--json', '--depth', '0', ...flags], target, ms);
   } catch (e) {
     log('generalDebug_0003', `npm ls packageRef error: ${e}`);
+    return {};
   }
 
   log('generalDebug_0003', `npm ls packageRef result: ${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);
@@ -29,16 +34,40 @@ export async function installDependencies(target = '.', ...flags: Array<string>)
 }
 
 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}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'pnpm-lock.yaml'));
+}
+
+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 {
-    const ms = new MemoryStream();
-    await runPnpmProcess(['add', packageRef, ...convert(flags)], target, ms);
-    log('generalDebug_0003', `Pnpm install package result: ${ms.value}`);
-    return ms.value;
-  } catch (ex) {
-    log(
-      'generalError_0002',
-      `Could not install the package "${packageRef}" using Pnpm. Make sure Pnpm is correctly installed and accessible: ${ex}`,
-    );
-    throw ex;
+    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);
 }

package/src/common/clients/rush.ts

@@ -0,0 +1,111 @@
+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,
+    }),
+  );
+}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listProjects(root);
+
+  if (typeof details === 'object' && Array.isArray(details?.projects)) {
+    return details?.projects?.some((p) => p.name === packageRef) ?? false;
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from rush client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runRushProcess(['list', '--json'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `rush list error: ${e}`);
+    return {};
+  }
+
+  log('generalDebug_0003', `rush list project result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}