piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/apps/debug-piral.ts

@@ -1,17 +1,21 @@
 import { dirname, join, resolve } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli, defaultConfig } from 'kras';
 import { callPiralDebug } from '../bundler';
 import { LogLevels } from '../types';
 import {
   retrievePiletsInfo,
   retrievePiralRoot,
-  openBrowser,
   checkCliCompatibility,
-  reorderInjectors,
-  notifyServerOnline,
   setLogLevel,
   progress,
-  log,
+  config,
+  normalizePublicUrl,
+  configurePlatform,
+  logDone,
+  getDestination,
+  watcherTask,
+  validateSharedDependencies,
+  piralJson,
+  packageJson,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -20,6 +24,11 @@ export interface DebugPiralOptions {
    */
   entry?: string;
 
+  /**
+   * Sets the target directory where the output of the bundling should be placed.
+   */
+  target?: string;
+
   /**
    * Sets the port to use for the debug server.
    */
@@ -51,101 +60,145 @@ export interface DebugPiralOptions {
    */
   bundlerName?: string;
 
+  /**
+   * Sets the relative path to the krasrc, if any.
+   */
+  krasrc?: string;
+
   /**
    * States if the node modules should be included for target transpilation
    */
   optimizeModules?: boolean;
 
+  /**
+   * The URL of a pilet feed(s) used to include locally missing pilets.
+   */
+  feed?: string | Array<string>;
+
   /**
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    onBegin?(e: any): Promise<void>;
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeOnline?(e: any): Promise<void>;
+    afterOnline?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const debugPiralDefaults: DebugPiralOptions = {
   entry: './',
-  port: 1234,
+  target: './dist',
+  port: config.port,
   publicUrl: '/',
   logLevel: LogLevels.info,
-  open: false,
+  open: config.openBrowser,
   hmr: true,
+  krasrc: undefined,
   optimizeModules: false,
 };
 
-const injectorName = resolve(__dirname, '../injectors/piral.js');
-
 export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOptions = {}) {
   const {
     entry = debugPiralDefaults.entry,
-    port = debugPiralDefaults.port,
+    target = debugPiralDefaults.target,
     open = debugPiralDefaults.open,
     hmr = debugPiralDefaults.hmr,
-    publicUrl = debugPiralDefaults.publicUrl,
+    port: originalPort = debugPiralDefaults.port,
+    publicUrl: originalPublicUrl = debugPiralDefaults.publicUrl,
     logLevel = debugPiralDefaults.logLevel,
+    krasrc: customkrasrc = debugPiralDefaults.krasrc,
     optimizeModules = debugPiralDefaults.optimizeModules,
+    feed,
     _ = {},
+    hooks = {},
     bundlerName,
   } = options;
+  const publicUrl = normalizePublicUrl(originalPublicUrl);
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
-  progress('Reading configuration ...');
-  const entryFiles = await retrievePiralRoot(baseDir, entry);
-  const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
-  const krasConfig = readKrasConfig({ port }, krasrc);
 
-  await checkCliCompatibility(root);
+  await hooks.onBegin?.({ options, fullBase });
 
-  if (krasConfig.directory === undefined) {
-    krasConfig.directory = join(dirname(entryFiles), 'mocks');
-  }
-
-  if (krasConfig.ssl === undefined) {
-    krasConfig.ssl = undefined;
-  }
-
-  if (krasConfig.map === undefined) {
-    krasConfig.map = {};
-  }
-
-  if (krasConfig.api === undefined) {
-    krasConfig.api = '/manage-mock-server';
-  }
-
-  if (krasConfig.injectors === undefined) {
-    krasConfig.injectors = defaultConfig.injectors;
-  }
+  progress('Reading configuration ...');
 
-  const bundler = await callPiralDebug(
-    {
-      root,
-      piral: name,
-      optimizeModules,
-      hmr,
-      externals,
+  const buildRef = await watcherTask(async (watcherContext) => {
+    const entryFiles = await retrievePiralRoot(fullBase, entry);
+    const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
+    const piralInstances = [name];
+    const dest = getDestination(entryFiles, resolve(fullBase, target));
+
+    await checkCliCompatibility(root);
+
+    validateSharedDependencies(externals);
+
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, piralInstances });
+
+    watcherContext.watch(join(root, packageJson));
+    watcherContext.watch(join(root, piralJson));
+
+    const bundler = await callPiralDebug(
+      {
+        root,
+        piralInstances,
+        optimizeModules,
+        hmr,
+        externals: externals.map((m) => m.name),
+        publicUrl,
+        entryFiles,
+        logLevel,
+        ignored,
+        ...dest,
+        _,
+      },
+      bundlerName,
+    );
+
+    bundler.ready().then(() => logDone(`Ready!`));
+
+    bundler.on((args) => {
+      hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, piralInstances, bundler, ...dest });
+    });
+
+    bundler.start();
+    return { bundler, entryFiles, root };
+  });
+
+  const platform = configurePlatform();
+
+  const serverRef = await watcherTask(async (watcherContext) => {
+    watcherContext.dependOn(buildRef);
+    const { bundler, entryFiles, root } = buildRef.data;
+    const targetDir = dirname(entryFiles);
+
+    await platform.startShell({
+      bundler,
+      customkrasrc,
+      feed,
+      fullBase,
+      hooks,
+      open,
+      originalPort,
       publicUrl,
-      entryFiles,
-      logLevel,
-      ignored,
-      _,
-    },
-    bundlerName,
-  );
-
-  const injectorConfig = {
-    active: true,
-    handle: ['/'],
-    bundler,
-  };
-
-  krasConfig.map['/'] = '';
-  krasConfig.injectors = reorderInjectors(injectorName, injectorConfig, krasConfig.injectors);
-
-  log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
-
-  const krasServer = buildKrasWithCli(krasConfig);
-  krasServer.removeAllListeners('open');
-  krasServer.on('open', notifyServerOnline([bundler], krasConfig.api));
-
-  await krasServer.start();
-  openBrowser(open, port);
-  await new Promise((resolve) => krasServer.on('close', resolve));
+      root,
+      targetDir,
+      registerEnd(cb) {
+        return watcherContext.onClean(cb);
+      },
+      registerWatcher(file) {
+        return watcherContext.watch(file);
+      }
+    });
+  });
+
+  await Promise.all([buildRef.end, serverRef.end]);
+
+  await hooks.onEnd?.({});
 }

package/src/apps/declaration-piral.ts

@@ -1,4 +1,5 @@
-import { setLogLevel, logDone, createDeclaration, ForceOverwrite } from '../common';
+import { resolve } from 'path';
+import { setLogLevel, logDone, createPiralDeclaration, ForceOverwrite } from '../common';
 import { LogLevels } from '../types';
 
 export interface DeclarationPiralOptions {
@@ -37,7 +38,8 @@ export async function declarationPiral(baseDir = process.cwd(), options: Declara
     forceOverwrite = declarationPiralDefaults.forceOverwrite,
     logLevel = declarationPiralDefaults.logLevel,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
-  await createDeclaration(baseDir, entry, target, forceOverwrite, logLevel);
+  await createPiralDeclaration(fullBase, entry, target, forceOverwrite, logLevel);
   logDone(`Declaration created successfully in "${target}"!`);
 }

package/src/apps/index.ts

@@ -7,6 +7,9 @@ export * from './publish-piral';
 export * from './validate-piral';
 export * from './new-pilet';
 export * from './upgrade-pilet';
+export * from './add-piral-instance-pilet';
+export * from './remove-piral-instance-pilet';
+export * from './run-emulator-piral';
 export * from './debug-pilet';
 export * from './build-pilet';
 export * from './pack-pilet';

package/src/apps/new-pilet.test.ts

@@ -1,8 +1,7 @@
-import { mkdtempSync, existsSync } from 'fs';
+import { mkdtempSync, existsSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, resolve } from 'path';
 import { newPilet } from './new-pilet';
-import { SourceLanguage } from '../common';
 
 function createTempDir() {
   return mkdtempSync(join(tmpdir(), 'piral-tests-new-pilet-'));
@@ -14,18 +13,21 @@ jest.mock('../common/clients/npm', () => {
   return {
     ...original,
     installPackage: (...args) => {
-      if (args[0].startsWith('@smapiot/')) {
-        return Promise.resolve();
-      } else {
-        return original.installPackage(...args);
-      }
+      return original.installPackage(
+        ...args,
+        '--legacy-peer-deps',
+        '--no-package-lock',
+        '--no-save',
+        '--registry=https://registry.npmjs.org/',
+      );
     },
   };
 });
 
+jest.setTimeout(90000);
+
 describe('New Pilet Command', () => {
   it('scaffolding in an empty directory works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPilet(dir, {
       install: false,
@@ -56,7 +58,6 @@ describe('New Pilet Command', () => {
   });
 
   it('should scaffold without creating npmrc file', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPilet(dir, {
       install: false,
@@ -70,10 +71,9 @@ describe('New Pilet Command', () => {
   });
 
   it('scaffolding with language JS works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPilet(dir, {
-      language: SourceLanguage.js,
+      language: 'js',
       install: false,
       source: 'piral@latest',
     });
@@ -83,4 +83,21 @@ describe('New Pilet Command', () => {
     expect(existsSync(resolve(dir, 'src/index.jsx'))).toBeTruthy();
     expect(existsSync(resolve(dir, '.npmrc'))).toBeFalsy();
   });
+
+  it('should set pilet name if passed as argument', async () => {
+    const dir = createTempDir();
+    await newPilet(dir, {
+      install: false,
+      source: 'piral@latest',
+      name: 'testpiralname',
+    });
+    expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'package.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'tsconfig.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'src/index.tsx'))).toBeTruthy();
+    expect(existsSync(resolve(dir, '.npmrc'))).toBeFalsy();
+
+    const packageContent = await JSON.parse(readFileSync(`${dir}/package.json`, 'utf8'));
+    expect(packageContent.name).toBe('testpiralname');
+  });
 });

package/src/apps/new-pilet.ts

@@ -1,20 +1,13 @@
 import { resolve, basename } from 'path';
-import { LogLevels, NpmClientType } from '../types';
+import { SourceLanguage, LogLevels, NpmClientType } from '../types';
 import {
   ForceOverwrite,
-  SourceLanguage,
   createDirectory,
   createFileIfNotExists,
-  defaultRegistry,
-  installPackage,
-  dissectPackageName,
   copyPiralFiles,
   patchPiletPackage,
   scaffoldPiletSourceFiles,
-  installDependencies,
-  combinePackageRef,
-  getPackageName,
-  getPackageVersion,
+  installNpmDependencies,
   readPiralPackage,
   getPiletsInfo,
   runScript,
@@ -25,11 +18,15 @@ import {
   log,
   logDone,
   determineNpmClient,
-  isLinkedPackage,
   copyScaffoldingFiles,
   getPiralPath,
-  detectMonorepo,
-  bootstrapMonorepo,
+  getPiletScaffoldData,
+  config,
+  initNpmProject,
+  cliVersion,
+  installPiralInstance,
+  piletJson,
+  defaultSchemaVersion,
 } from '../common';
 
 export interface NewPiletOptions {
@@ -76,7 +73,7 @@ export interface NewPiletOptions {
   logLevel?: LogLevels;
 
   /**
-   * The NPM client to be used when scaffolding.
+   * The npm client to be used when scaffolding.
    * @example 'yarn'
    */
   npmClient?: NpmClientType;
@@ -91,20 +88,26 @@ export interface NewPiletOptions {
    * Places additional variables that should used when scaffolding.
    */
   variables?: Record<string, string>;
+
+  /**
+   * Sets Pilet's name
+   */
+  name?: string;
 }
 
 export const newPiletDefaults: NewPiletOptions = {
   target: '.',
-  registry: defaultRegistry,
-  source: 'piral',
+  registry: config.registry,
+  source: undefined,
   forceOverwrite: ForceOverwrite.no,
-  language: SourceLanguage.ts,
+  language: config.language,
   install: true,
-  template: 'default',
+  template: undefined,
   logLevel: LogLevels.info,
   npmClient: undefined,
   bundlerName: 'none',
   variables: {},
+  name: undefined,
 };
 
 export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions = {}) {
@@ -119,15 +122,18 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
     logLevel = newPiletDefaults.logLevel,
     bundlerName = newPiletDefaults.bundlerName,
     variables = newPiletDefaults.variables,
+    npmClient: defaultNpmClient = newPiletDefaults.npmClient,
+    name = newPiletDefaults.name,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
-  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, source);
   const success = await createDirectory(root);
 
   if (success) {
-    const npmClient = await determineNpmClient(root, options.npmClient);
+    const npmClient = await determineNpmClient(root, defaultNpmClient);
+    const projectName = name || basename(root);
 
     progress(`Scaffolding new pilet in %s ...`, root);
 
@@ -136,7 +142,7 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
       'package.json',
       JSON.stringify(
         {
-          name: basename(root),
+          name: projectName,
           version: '1.0.0',
           description: '',
           keywords: ['pilet'],
@@ -152,8 +158,10 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
       ),
     );
 
+    await initNpmProject(npmClient, projectName, root);
+
     if (registry !== newPiletDefaults.registry) {
-      progress(`Setting up NPM registry (%s) ...`, registry);
+      progress(`Setting up npm registry (%s) ...`, registry);
 
       await createFileIfNotExists(
         root,
@@ -164,25 +172,29 @@ always-auth=true`,
       );
     }
 
-    const isLocal = isLinkedPackage(sourceName, type, hadVersion);
-
-    if (!isLocal) {
-      const packageRef = combinePackageRef(sourceName, sourceVersion, type);
-
-      progress(`Installing NPM package %s ...`, packageRef);
-
-      await installPackage(npmClient, packageRef, root, '--save-dev');
-    } else {
-      progress(`Using locally available NPM package %s ...`, sourceName);
-    }
+    await createFileIfNotExists(
+      root,
+      piletJson,
+      JSON.stringify(
+        {
+          schemaVersion: defaultSchemaVersion,
+        },
+        undefined,
+        2,
+      ),
+    );
 
-    const packageName = await getPackageName(root, sourceName, type);
-    const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, root);
+    const [packageName, packageVersion] = await installPiralInstance(
+      source || `empty-piral@${cliVersion}`,
+      fullBase,
+      root,
+      npmClient,
+    );
     const piralInfo = await readPiralPackage(root, packageName);
 
     const isEmulator = checkAppShellPackage(piralInfo);
 
-    const { preScaffold, postScaffold, files } = getPiletsInfo(piralInfo);
+    const { preScaffold, postScaffold, files, template: preSelectedTemplate } = getPiletsInfo(piralInfo);
 
     if (preScaffold) {
       progress(`Running preScaffold script ...`);
@@ -192,29 +204,29 @@ always-auth=true`,
 
     progress(`Taking care of templating ...`);
 
-    await scaffoldPiletSourceFiles(template, registry, language, root, packageName, forceOverwrite, variables);
+    const data = getPiletScaffoldData(language, root, packageName, variables);
+
+    await patchPiletPackage(root, packageName, packageVersion, piralInfo, isEmulator, {
+      language,
+      bundler: bundlerName,
+    });
+
+    const chosenTemplate = template || preSelectedTemplate || 'default';
+    await scaffoldPiletSourceFiles(chosenTemplate, registry, data, forceOverwrite);
 
     if (isEmulator) {
       // in the emulator case we get the files (and files_once) from the contained tarballs
-      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes);
+      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes, data);
     } else {
       // otherwise, we perform the same action as in the emulator creation
       // just with a different target; not a created directory, but the root
       const packageRoot = getPiralPath(root, packageName);
-      await copyScaffoldingFiles(packageRoot, root, files, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, files, piralInfo, data);
     }
 
-    await patchPiletPackage(root, packageName, packageVersion, piralInfo, { language, bundler: bundlerName });
-
     if (install) {
       progress(`Installing dependencies ...`);
-      const monorepoKind = await detectMonorepo(root);
-
-      if (monorepoKind === 'lerna') {
-        await bootstrapMonorepo(root);
-      } else {
-        await installDependencies(npmClient, root);
-      }
+      await installNpmDependencies(npmClient, root);
     }
 
     if (postScaffold) {

package/src/apps/new-piral.test.ts

@@ -1,8 +1,7 @@
-import { mkdtempSync, existsSync } from 'fs';
+import { mkdtempSync, existsSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, resolve } from 'path';
 import { newPiral } from './new-piral';
-import { SourceLanguage } from '../common';
 
 function createTempDir() {
   return mkdtempSync(join(tmpdir(), 'piral-tests-new-piral-'));
@@ -14,18 +13,15 @@ jest.mock('../common/clients/npm', () => {
   return {
     ...original,
     installPackage: (...args) => {
-      if (args[0].startsWith('@smapiot/')) {
-        return Promise.resolve();
-      } else {
-        return original.installPackage(...args);
-      }
+      return original.installPackage(...args, '--legacy-peer-deps', '--no-package-lock', '--no-save');
     },
   };
 });
 
+jest.setTimeout(90000);
+
 describe('New Piral Command', () => {
   it('scaffolding in an empty directory works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, { install: false });
     expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
@@ -38,10 +34,9 @@ describe('New Piral Command', () => {
   });
 
   it('scaffolding with language JS works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
-      language: SourceLanguage.js,
+      language: 'js',
       install: false,
     });
     expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
@@ -53,8 +48,26 @@ describe('New Piral Command', () => {
     expect(existsSync(resolve(dir, '.npmrc'))).toBeFalsy();
   });
 
+  it('scaffolding with custom app name works', async () => {
+    const dir = createTempDir();
+    await newPiral(dir, {
+      name: 'test-name',
+      install: false,
+    });
+
+    expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'package.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'tsconfig.json'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'src/index.tsx'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'src/index.html'))).toBeTruthy();
+    expect(existsSync(resolve(dir, 'src/mocks/backend.js'))).toBeTruthy();
+    expect(existsSync(resolve(dir, '.npmrc'))).toBeFalsy();
+
+    const packageContent = await JSON.parse(readFileSync(`${dir}/package.json`, 'utf8'));
+    expect(packageContent.name).toBe('test-name');
+  });
+
   it('scaffolding for piral-core works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
       framework: 'piral-core',
@@ -72,7 +85,6 @@ describe('New Piral Command', () => {
   });
 
   it('scaffolding for piral-base works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
       framework: 'piral-base',
@@ -85,7 +97,7 @@ describe('New Piral Command', () => {
     expect(existsSync(resolve(dir, 'tsconfig.json'))).toBeTruthy();
     expect(existsSync(resolve(dir, 'src/index.jsx'))).toBeFalsy();
     expect(existsSync(resolve(dir, 'src/index.ts'))).toBeTruthy();
-    expect(existsSync(resolve(dir, 'src/index.html'))).toBeFalsy();
+    expect(existsSync(resolve(dir, 'src/index.html'))).toBeTruthy();
     expect(existsSync(resolve(dir, 'src/mocks/backend.js'))).toBeTruthy();
     expect(existsSync(resolve(dir, '.npmrc'))).toBeFalsy();
   });