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

package/src/bundler.test.ts

@@ -6,50 +6,63 @@ import {
   callPiralDebug,
   callDebugPiralFromMonoRepo,
 } from './bundler';
+import { callDynamic, callStatic } from './build/bundler-calls';
+import * as common from './common';
 
-let common: any;
-let defaults = {
+const defaults = {
   bundler: false,
 };
 
+jest.mock('./build/bundler-calls.ts', () => ({
+  callDynamic: jest.fn(() =>
+    Promise.resolve({
+      bundle: {},
+    }),
+  ),
+  callStatic: jest.fn(() =>
+    Promise.resolve({
+      bundle: {},
+    }),
+  ),
+}));
+
 jest.mock('./inject', () => ({
   inject() {
     if (defaults.bundler) {
       setBundler({
         name: 'default',
         actions: {
-          buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-          debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-          buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-          debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-          watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+          buildPilet: { path: '' },
+          debugPilet: { path: '' },
+          buildPiral: { path: '' },
+          debugPiral: { path: '' },
+          watchPiral: { path: '' },
         } as any,
       });
     }
   },
 }));
 
-jest.mock(
-  './common',
-  () =>
-    (common = {
-      config: {
-        bundler: 'parcel',
-      },
-      cliVersion: '1.0.0',
-      installPackage: jest.fn(),
-      fail(msg) {
-        throw new Error(msg);
-      },
-      progress() {},
-      log() {},
-      determineNpmClient() {
-        return 'npm';
-      },
-      patchModules: jest.fn(),
-      logReset() {},
-    }),
-);
+jest.mock('./common', () => ({
+  config: {
+    bundler: 'parcel',
+  },
+  promptSelect(msg, choices, defval) {
+    return Promise.resolve(defval);
+  },
+  compatVersion: '1',
+  installNpmPackage: jest.fn(),
+  fail(msg) {
+    throw new Error(msg);
+  },
+  progress() {},
+  log() {},
+  determineNpmClient() {
+    return 'npm';
+  },
+  patchModules: jest.fn(),
+  logReset() {},
+}));
 
 describe('Piral CLI Bundler Module', () => {
   it('fails if no default bundler can be installed, but required', async () => {
@@ -64,11 +77,11 @@ describe('Piral CLI Bundler Module', () => {
 
   it('setting the bundler can resolve it properly for call pilet build', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '1' },
+      debugPilet: { path: '2' },
+      buildPiral: { path: '3' },
+      debugPiral: { path: '4' },
+      watchPiral: { path: '5' },
     };
 
     setBundler({
@@ -76,17 +89,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiletBuild({ root: undefined } as any, 'foo1');
-    expect(actions.buildPilet.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiletBuild(args as any, 'foo1');
+    expect(callStatic).toHaveBeenCalledWith('build-pilet', '1', args);
   });
 
   it('setting the bundler with optimize modules calls optimize modules', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '' },
+      debugPilet: { path: '' },
+      buildPiral: { path: '' },
+      debugPiral: { path: '' },
+      watchPiral: { path: '' },
     };
 
     setBundler({
@@ -105,11 +119,11 @@ describe('Piral CLI Bundler Module', () => {
 
   it('setting the bundler can resolve it properly for call piral build', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '1' },
+      debugPilet: { path: '2' },
+      buildPiral: { path: '3' },
+      debugPiral: { path: '4' },
+      watchPiral: { path: '5' },
     };
 
     setBundler({
@@ -117,17 +131,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiralBuild({ root: undefined } as any, 'foo2');
-    expect(actions.buildPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiralBuild(args as any, 'foo2');
+    expect(callStatic).toHaveBeenCalledWith('build-piral', '3', args);
   });
 
   it('setting the bundler can resolve it properly for call pilet debug', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '0' },
+      debugPilet: { path: '1' },
+      buildPiral: { path: '2' },
+      debugPiral: { path: '3' },
+      watchPiral: { path: '4' },
     };
 
     setBundler({
@@ -135,17 +150,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiletDebug({ root: undefined } as any, 'foo3');
-    expect(actions.debugPilet.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiletDebug(args as any, 'foo3');
+    expect(callDynamic).toHaveBeenCalledWith('debug-pilet', '1', args);
   });
 
   it('setting the bundler can resolve it properly for call piral debug', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '7' },
+      debugPilet: { path: '8' },
+      buildPiral: { path: '9' },
+      debugPiral: { path: '10' },
+      watchPiral: { path: '11' },
     };
 
     setBundler({
@@ -153,17 +169,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiralDebug({ root: undefined } as any, 'foo4');
-    expect(actions.debugPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiralDebug(args as any, 'foo4');
+    expect(callDynamic).toHaveBeenCalledWith('debug-piral', '10', args);
   });
 
   it('setting the bundler can resolve it properly for call piral watch', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '3' },
+      debugPilet: { path: '4' },
+      buildPiral: { path: '5' },
+      debugPiral: { path: '6' },
+      watchPiral: { path: '7' },
     };
 
     setBundler({
@@ -171,8 +188,9 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callDebugPiralFromMonoRepo({ root: undefined } as any, 'foo5');
-    expect(actions.watchPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callDebugPiralFromMonoRepo(args as any, 'foo5');
+    expect(callStatic).toHaveBeenCalledWith('debug-mono-piral', '7', args);
   });
 
   it('using a non-available bundler should fail', () => {

package/src/bundler.ts

@@ -1,14 +1,18 @@
+import { callDynamic, callStatic } from './build/bundler-calls';
 import { availableBundlers } from './helpers';
+import { isInteractive } from './external';
 import {
-  installPackage,
-  cliVersion,
+  installNpmPackage,
+  compatVersion,
   fail,
   progress,
   log,
   determineNpmClient,
   patchModules,
+  bundlerNames,
   logReset,
   config,
+  promptSelect,
 } from './common';
 import {
   Bundler,
@@ -20,6 +24,7 @@ import {
   DebugPiletParameters,
   BundlerDefinition,
   BaseBundleParameters,
+  BaseBundlerDefinition,
 } from './types';
 
 export interface QualifiedBundler {
@@ -29,15 +34,27 @@ export interface QualifiedBundler {
 
 const bundlers: Array<QualifiedBundler> = [];
 
+async function getBundlerToInstall() {
+  const selectedBundler = config.bundler || 'webpack5';
+
+  if (isInteractive()) {
+    return await promptSelect('No bundler found. Which one do you want to install?', bundlerNames, selectedBundler);
+  }
+
+  log('bundlerNotInstalled_0176');
+  return selectedBundler;
+}
+
 async function installDefaultBundler(root: string) {
-  const selectedBundler = config.bundler || 'webpack';
-  log('generalDebug_0003', `Installation of default bundler for "${selectedBundler}".`);
+  const selectedBundler = await getBundlerToInstall();
+  log('generalDebug_0003', `Installation of bundler "${selectedBundler}".`);
   const selectedPackage = `piral-cli-${selectedBundler}`;
-  log('generalDebug_0003', `Determining NPM client at "${root}" ...`);
+  log('generalDebug_0003', `Determining npm client at "${root}" ...`);
   const client = await determineNpmClient(root);
-  log('generalDebug_0003', `Prepare to install ${selectedPackage}@${cliVersion} using "${client}" into "${root}".`);
+  const packageId = `${selectedPackage}@^${compatVersion}`;
+  log('generalDebug_0003', `Prepare to install ${packageId} using "${client}" into "${root}".`);
   progress(`Installing ${selectedPackage} ...`);
-  await installPackage(client, `${selectedPackage}@${cliVersion}`, root, '--save-dev');
+  await installNpmPackage(client, packageId, root, '--save-dev', '--save-exact');
   log('generalDebug_0003', `Installed bundler from "${selectedPackage}".`);
 
   require('./inject').inject(selectedPackage);
@@ -76,12 +93,18 @@ async function findBundler(root: string, bundlerName?: string) {
   return defaultBundler;
 }
 
-async function prepareModules(args: BaseBundleParameters) {
+async function prepareArgs<T extends BaseBundleParameters>(bundler: BaseBundlerDefinition<T>, args: T): Promise<T> {
   if (args.optimizeModules) {
     progress('Preparing modules ...');
     await patchModules(args.root, args.ignored);
     logReset();
   }
+
+  if (bundler.prepare) {
+    return await bundler.prepare(args);
+  }
+
+  return args;
 }
 
 export function setBundler(bundler: QualifiedBundler) {
@@ -94,26 +117,52 @@ export function setBundler(bundler: QualifiedBundler) {
 
 export async function callPiralDebug(args: DebugPiralParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPiral;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-piral', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletDebug(args: DebugPiletParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPilet;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-pilet', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiralBuild(args: BuildPiralParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletBuild(args: BuildPiletParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPilet;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-pilet', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callDebugPiralFromMonoRepo(
@@ -121,7 +170,13 @@ export async function callDebugPiralFromMonoRepo(
   bundlerName?: string,
 ): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  const { bundle } = await bundler.actions.watchPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
-  return bundle;
+
+  try {
+    const action = bundler.actions.watchPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('debug-mono-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }

package/src/cli.ts

@@ -1,5 +1,6 @@
 import * as yargs from 'yargs';
 import { detailed } from 'yargs-parser';
+import { caterpillerIcon, zapIcon, butterflyIcon, cliName, cliVersion } from './common';
 import { runQuestionnaireFor } from './questionnaire';
 import { ToolCommand } from './types';
 
@@ -42,11 +43,13 @@ export function setupCli(commands: Array<ToolCommand<any>>) {
           }
         };
 
+        console.log(`${butterflyIcon} ${cliName} v${cliVersion}`);
+
         return runCommand().then(
           () => process.exit(0),
           (err) => {
             err && !err.logged && console.error(err.message);
-            console.log('Codes Reference: https://docs.piral.io/code/search');
+            console.log(`${caterpillerIcon} Find detailed descriptions at https://docs.piral.io/code/search`);
             process.exit(1);
           },
         );
@@ -54,5 +57,6 @@ export function setupCli(commands: Array<ToolCommand<any>>) {
     );
   }
 
-  argv.epilog('For more information, check out the documentation at https://docs.piral.io.').help().strict().argv;
+  argv.epilog(`${zapIcon} For more information, check out the documentation at https://docs.piral.io`).help().strict()
+    .argv;
 }