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

package/src/apps/debug-pilet.ts

@@ -1,20 +1,28 @@
-import { join, dirname, resolve } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli, defaultConfig } from 'kras';
+import { join, dirname, resolve, relative, basename } from 'path';
 import { callDebugPiralFromMonoRepo, callPiletDebug } from '../bundler';
-import { LogLevels, PiletSchemaVersion } from '../types';
+import { AppDefinition, LogLevels, PiletSchemaVersion } from '../types';
 import {
   checkExistingDirectory,
   retrievePiletData,
+  retrievePiletsInfo,
   config,
-  openBrowser,
-  reorderInjectors,
-  notifyServerOnline,
-  findEntryModule,
   setLogLevel,
   progress,
-  matchAny,
+  matchAnyPilet,
   fail,
   log,
+  logDone,
+  cpuCount,
+  concurrentWorkers,
+  normalizePublicUrl,
+  combinePiletExternals,
+  watcherTask,
+  flattenExternals,
+  validateSharedDependencies,
+  configurePlatform,
+  packageJson,
+  piletJson,
+  defaultSchemaVersion,
 } from '../common';
 
 export interface DebugPiletOptions {
@@ -28,12 +36,24 @@ export interface DebugPiletOptions {
    */
   entry?: string | Array<string>;
 
+  /**
+   * The target file of bundling.
+   * @example './dist/index.js'
+   */
+  target?: string;
+
   /**
    * Overrides the name of the app shell to use.
    * By default the app is inferred from the package.json.
    */
   app?: string;
 
+  /**
+   * Overrides the directory of the app to serve when
+   * debugging.
+   */
+  appInstanceDir?: string;
+
   /**
    * Sets if the (system default) browser should be auto-opened.
    */
@@ -44,6 +64,17 @@ export interface DebugPiletOptions {
    */
   port?: number;
 
+  /**
+   * Sets the publicUrl to use.
+   * By default, the server is assumed to be at root "/".
+   */
+  publicUrl?: string;
+
+  /**
+   * Sets the maximum number of parallel build processes.
+   */
+  concurrency?: number;
+
   /**
    * Defines if hot module reloading (HMR) should be integrated for faster debugging.
    */
@@ -54,6 +85,11 @@ export interface DebugPiletOptions {
    */
   bundlerName?: string;
 
+  /**
+   * Sets the relative path to the krasrc, if any.
+   */
+  krasrc?: string;
+
   /**
    * States if the node modules should be included for target transpilation
    */
@@ -66,65 +102,104 @@ export interface DebugPiletOptions {
   schemaVersion?: PiletSchemaVersion;
 
   /**
-   * The URL of a pilet feed used to include locally missing pilets.
+   * The URL of a pilet feed(s) used to include locally missing pilets.
    */
-  feed?: string;
+  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>;
+    beforeApp?(e: any): Promise<void>;
+    afterApp?(e: any): Promise<void>;
+    beforeOnline?(e: any): Promise<void>;
+    afterOnline?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const debugPiletDefaults: DebugPiletOptions = {
   logLevel: LogLevels.info,
+  target: './dist/index.js',
   entry: './src/index',
-  open: false,
-  port: 1234,
+  open: config.openBrowser,
+  port: config.port,
+  publicUrl: '/',
   hmr: true,
+  krasrc: undefined,
   optimizeModules: false,
-  schemaVersion: 'v1',
+  schemaVersion: undefined,
+  concurrency: cpuCount,
 };
 
-const injectorName = resolve(__dirname, '../injectors/pilet.js');
-
 interface AppInfo {
-  emulator: boolean;
-  appFile: string;
-  appVersion: string;
+  apps: Array<AppDefinition>;
+  root: string;
+  mocks: string;
+  publicUrl: string;
   externals: Array<string>;
-  piral: string;
 }
 
-async function getOrMakeAppDir({ emulator, piral, externals, appFile }: AppInfo, logLevel: LogLevels) {
-  if (!emulator) {
-    const packageJson = require.resolve(`${piral}/package.json`);
-    const cwd = resolve(packageJson, '..');
-    const { dir } = await callDebugPiralFromMonoRepo({
-      root: cwd,
-      optimizeModules: false,
-      ignored: [],
-      externals,
-      piral,
-      entryFiles: appFile,
-      logLevel,
-      _: {},
-    });
-    return dir;
-  }
+type PiralInstanceInfo = [appDir: string, appPort: number];
 
-  return dirname(appFile);
+function byPort(a: PiralInstanceInfo, b: PiralInstanceInfo) {
+  return a[1] - b[1];
+}
+
+function getOrMakeApps({ apps, publicUrl }: AppInfo, logLevel: LogLevels) {
+  return Promise.all(
+    apps.map(async ({ emulator, appFile, appPackage, appPort }): Promise<PiralInstanceInfo> => {
+      if (!emulator) {
+        const piralInstances = [appPackage.name];
+        const { externals, root, ignored } = await retrievePiletsInfo(appFile);
+        const { dir } = await callDebugPiralFromMonoRepo({
+          root,
+          optimizeModules: false,
+          publicUrl,
+          ignored,
+          externals: flattenExternals(externals),
+          piralInstances,
+          entryFiles: appFile,
+          logLevel,
+          _: {},
+        });
+        return [dir, appPort];
+      }
+
+      return [dirname(appFile), appPort];
+    }),
+  );
 }
 
 function checkSanity(pilets: Array<AppInfo>) {
   for (let i = 1; i < pilets.length; i++) {
     const previous = pilets[i - 1];
     const current = pilets[i];
-
-    if (previous.piral !== current.piral) {
-      return log('piletMultiDebugAppShellDifferent_0301', previous.piral, current.piral);
-    } else if (previous.appVersion !== current.appVersion) {
-      return log('piletMultiDebugAppShellVersions_0302', previous.appVersion, current.appVersion);
+    const previousInstances = previous.apps;
+    const currentInstances = current.apps;
+    const previousInstancesNames = previousInstances
+      .map((m) => m.appPackage.name)
+      .sort()
+      .join(', ');
+    const currentInstancesNames = currentInstances
+      .map((m) => m.appPackage.name)
+      .sort()
+      .join(', ');
+    const previousInstancesVersions = previousInstances.map((m) => m.appPackage.version).join(', ');
+    const currentInstancesVersions = currentInstances.map((m) => m.appPackage.version).join(', ');
+
+    if (previousInstancesNames !== currentInstancesNames) {
+      return log('piletMultiDebugAppShellDifferent_0301', previousInstancesNames, currentInstancesNames);
+    } else if (previousInstancesVersions !== currentInstancesVersions) {
+      return log('piletMultiDebugAppShellVersions_0302', previousInstancesVersions, currentInstancesVersions);
     } else if (previous.externals.length !== current.externals.length) {
       return log('piletMultiDebugExternalsDifferent_0303', previous.externals, current.externals);
     } else if (previous.externals.some((m) => !current.externals.includes(m))) {
@@ -136,65 +211,84 @@ function checkSanity(pilets: Array<AppInfo>) {
 export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOptions = {}) {
   const {
     entry = debugPiletDefaults.entry,
-    port = debugPiletDefaults.port,
+    target = debugPiletDefaults.target,
     open = debugPiletDefaults.open,
     hmr = debugPiletDefaults.hmr,
+    port: originalPort = debugPiletDefaults.port,
+    publicUrl: originalPublicUrl = debugPiletDefaults.publicUrl,
     logLevel = debugPiletDefaults.logLevel,
+    concurrency = debugPiletDefaults.concurrency,
+    krasrc: customkrasrc = debugPiletDefaults.krasrc,
     optimizeModules = debugPiletDefaults.optimizeModules,
-    schemaVersion = debugPiletDefaults.schemaVersion,
+    schemaVersion: originalSchemaVersion = debugPiletDefaults.schemaVersion,
     _ = {},
+    hooks = {},
     bundlerName,
     app,
+    appInstanceDir,
     feed,
   } = options;
+  const publicUrl = normalizePublicUrl(originalPublicUrl);
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
-  progress('Reading configuration ...');
-  const krasConfig = readKrasConfig({ port }, krasrc);
-  const api = config.piletApi;
-  const entryList = Array.isArray(entry) ? entry : [entry];
-  const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
-  log('generalDebug_0003', `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${baseDir}".`);
-  const allEntries = multi ? await matchAny(baseDir, entryList) : entryList;
-  log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
-
-  if (krasConfig.sources === undefined) {
-    krasConfig.sources = [];
-  }
 
-  if (allEntries.length === 0) {
-    fail('entryFileMissing_0077');
-  }
+  await hooks.onBegin?.({ options, fullBase });
+
+  const watcherRef = await watcherTask(async (watcherContext) => {
+    progress('Reading configuration ...');
+    const entryList = Array.isArray(entry) ? entry : [entry];
+    const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
+    log(
+      'generalDebug_0003',
+      `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${fullBase}".`,
+    );
+
+    const allEntries = await matchAnyPilet(fullBase, entryList);
+    const maxListeners = Math.max(2 + allEntries.length * 2, 16);
+    log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
+
+    if (allEntries.length === 0) {
+      fail('entryFileMissing_0077');
+    }
 
-  const pilets = await Promise.all(
-    allEntries.map(async (entry) => {
-      const entryFile = join(baseDir, entry);
-      const targetDir = dirname(entryFile);
-      const entryModule = await findEntryModule(entryFile, targetDir);
-      const { peerDependencies, peerModules, root, appPackage, appFile, ignored, emulator } = await retrievePiletData(
+    process.stderr?.setMaxListeners(maxListeners);
+    process.stdout?.setMaxListeners(maxListeners);
+    process.stdin?.setMaxListeners(maxListeners);
+
+    const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
+      const targetDir = dirname(entryModule);
+      const { peerDependencies, peerModules, root, apps, ignored, importmap, schema } = await retrievePiletData(
         targetDir,
         app,
       );
-      const externals = [...Object.keys(peerDependencies), ...peerModules];
+      const schemaVersion = originalSchemaVersion || schema || config.schemaVersion || defaultSchemaVersion;
+      const piralInstances = apps.map((m) => m.appPackage.name);
+      const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
       const mocks = join(targetDir, 'mocks');
-      const exists = await checkExistingDirectory(mocks);
+      const dest = resolve(root, target);
+      const outDir = dirname(dest);
+      const outFile = basename(dest);
+      const mocksExists = await checkExistingDirectory(mocks);
 
-      if (exists) {
-        if (krasConfig.directory === undefined) {
-          krasConfig.directory = mocks;
-        }
+      validateSharedDependencies(importmap);
 
-        krasConfig.sources.push(mocks);
-      }
+      await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
+
+      watcherContext.watch(join(root, packageJson));
+      watcherContext.watch(join(root, piletJson));
 
       const bundler = await callPiletDebug(
         {
           root,
-          piral: appPackage.name,
+          piralInstances,
           optimizeModules,
           hmr,
           externals,
           targetDir,
-          entryModule,
+          importmap,
+          outFile,
+          outDir,
+          entryModule: `./${relative(root, entryModule)}`,
           logLevel,
           version: schemaVersion,
           ignored,
@@ -203,65 +297,77 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
         bundlerName,
       );
 
+      bundler.on((args) => {
+        hooks.afterBuild?.({
+          ...args,
+          root,
+          publicUrl,
+          importmap,
+          entryModule,
+          schemaVersion,
+          bundler,
+          outFile,
+          outDir,
+        });
+      });
+
       return {
-        emulator,
-        appFile,
-        appVersion: appPackage.version,
+        apps,
+        publicUrl,
         externals,
-        piral: appPackage.name,
         bundler,
+        mocks: mocksExists ? mocks : undefined,
         root,
       };
-    }),
-  );
-
-  // sanity check see #250
-  checkSanity(pilets);
-
-  const appDir = await getOrMakeAppDir(pilets[0], logLevel);
-
-  if (krasConfig.ssl === undefined) {
-    krasConfig.ssl = undefined;
-  }
-
-  if (krasConfig.map === undefined) {
-    krasConfig.map = {};
-  }
+    });
 
-  if (krasConfig.api === undefined) {
-    krasConfig.api = '/manage-mock-server';
-  }
+    // sanity check see #250
+    checkSanity(pilets);
 
-  if (krasConfig.injectors === undefined) {
-    krasConfig.injectors = defaultConfig.injectors;
-  }
+    await hooks.beforeApp?.({ appInstanceDir, pilets });
 
-  const injectorConfig = {
-    active: true,
-    pilets,
-    app: appDir,
-    handle: ['/', api],
-    api,
-    feed,
-  };
+    const appInstances: Array<PiralInstanceInfo> = appInstanceDir
+      ? [[appInstanceDir, 0]]
+      : await getOrMakeApps(pilets[0], logLevel);
 
-  krasConfig.map['/'] = '';
-  krasConfig.map[api] = '';
-  krasConfig.injectors = reorderInjectors(injectorName, injectorConfig, krasConfig.injectors);
+    Promise.all(pilets.map((p) => p.bundler.ready())).then(() => logDone(`Ready!`));
 
-  log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
+    pilets.forEach((p) => p.bundler.start());
 
-  const krasServer = buildKrasWithCli(krasConfig);
-  krasServer.removeAllListeners('open');
-  krasServer.on(
-    'open',
-    notifyServerOnline(
-      pilets.map((p) => p.bundler),
-      krasConfig.api,
-    ),
-  );
+    if (appInstances.length === 0) {
+      appInstances.push([undefined, originalPort]);
+    }
 
-  await krasServer.start();
-  openBrowser(open, port);
-  await new Promise((resolve) => krasServer.on('close', resolve));
+    await Promise.all(
+      appInstances.sort(byPort).map(async ([appDir, appPort], i) => {
+        const platform = configurePlatform();
+        const suggestedPort = appPort || originalPort + i;
+
+        await platform.startModule({
+          appDir,
+          pilets,
+          customkrasrc,
+          feed,
+          fullBase,
+          hooks,
+          open,
+          originalPort: suggestedPort,
+          publicUrl,
+          maxListeners,
+          registerEnd(cb) {
+            return watcherContext.onClean(cb);
+          },
+          registerWatcher(file) {
+            return watcherContext.watch(file);
+          },
+        });
+      }),
+    );
+
+    await hooks.afterApp?.({ appInstanceDir, pilets });
+  });
+
+  await Promise.all([watcherRef.end]);
+
+  await hooks.onEnd?.({});
 }