piral-cli 0.15.9-beta.5384 → 0.15.9-beta.5403

package/lib/types/common.d.ts

@@ -82,6 +82,35 @@ export interface Bundler {
     off(cb: (args: any) => void): void;
     ready(): Promise<void>;
 }
+export interface PlatformStartModuleOptions {
+    appRoot: string;
+    appDir: string;
+    open: boolean;
+    fullBase: string;
+    feed: string | Array<string>;
+    publicUrl: string;
+    customkrasrc: string;
+    originalPort: number;
+    hooks: Record<string, Function>;
+    registerWatcher(file: string): void;
+    registerEnd(cb: () => void): void;
+    maxListeners: number;
+    pilets: Array<any>;
+}
+export interface PlatformStartShellOptions {
+    open: boolean;
+    fullBase: string;
+    root: string;
+    feed: string | Array<string>;
+    targetDir: string;
+    publicUrl: string;
+    bundler: Bundler;
+    customkrasrc: string;
+    originalPort: number;
+    hooks: Record<string, Function>;
+    registerWatcher(file: string): void;
+    registerEnd(cb: () => void): void;
+}
 export interface ReleaseProvider {
     (directory: string, files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "piral-cli",
-  "version": "0.15.9-beta.5384",
+  "version": "0.15.9-beta.5403",
   "description": "The standard CLI for creating and building a Piral instance or a Pilet.",
   "keywords": [
     "portal",
@@ -80,5 +80,5 @@
     "typescript": "^4.0.0",
     "yargs": "^15.0.0"
   },
-  "gitHead": "e1fc7342dedc2c0b0f099823e15d9e5ac4c641d5"
+  "gitHead": "d1f1d5eabcf01612d13b5b09c2156d0dc906316b"
 }

package/src/apps/build-pilet.ts

@@ -24,6 +24,7 @@ import {
   normalizePublicUrl,
   combinePiletExternals,
   retrievePiletsInfo,
+  validateSharedDependencies,
 } from '../common';
 
 interface PiletData {
@@ -226,6 +227,8 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
     const outDir = dirname(dest);
     const outFile = basename(dest);
 
+    validateSharedDependencies(importmap);
+
     if (fresh) {
       progress('Removing output directory ...');
       await removeDirectory(outDir);

package/src/apps/build-piral.ts

@@ -17,6 +17,7 @@ import {
   packageEmulator,
   normalizePublicUrl,
   getDestination,
+  validateSharedDependencies,
 } from '../common';
 
 const releaseName = 'release';
@@ -168,6 +169,8 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
 
   await checkCliCompatibility(root);
 
+  validateSharedDependencies(externals);
+
   if (fresh) {
     progress('Removing output directory ...');
     await removeDirectory(dest.outDir);

package/src/apps/debug-pilet.ts

@@ -1,5 +1,4 @@
 import { join, dirname, resolve, relative, basename } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
 import { callDebugPiralFromMonoRepo, callPiletDebug } from '../bundler';
 import { AppDefinition, LogLevels, PiletSchemaVersion } from '../types';
 import {
@@ -7,8 +6,6 @@ import {
   retrievePiletData,
   retrievePiletsInfo,
   config,
-  openBrowser,
-  notifyServerOnline,
   setLogLevel,
   progress,
   matchAnyPilet,
@@ -19,11 +16,11 @@ import {
   concurrentWorkers,
   normalizePublicUrl,
   findFile,
-  createInitialKrasConfig,
-  getAvailablePort,
   combinePiletExternals,
   watcherTask,
   flattenExternals,
+  validateSharedDependencies,
+  configurePlatform,
 } from '../common';
 
 export interface DebugPiletOptions {
@@ -237,7 +234,6 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
 
   await watcherTask(async (watcherContext) => {
     progress('Reading configuration ...');
-    const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
     const entryList = Array.isArray(entry) ? entry : [entry];
     const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
     log(
@@ -269,6 +265,8 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
       const outFile = basename(dest);
       const mocksExists = await checkExistingDirectory(mocks);
 
+      validateSharedDependencies(importmap);
+
       await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
 
       const bundler = await callPiletDebug(
@@ -330,52 +328,29 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
     await Promise.all(
       appInstances.sort(byPort).map(async ([appDir, appPort], i) => {
         const appRoot = dirname(await findFile(appDir, 'package.json'));
+        const platform = configurePlatform();
         await hooks.afterApp?.({ appInstanceDir, pilets });
         const suggestedPort = appPort || originalPort + i;
-        const port = await getAvailablePort(suggestedPort);
-
-        const sources = pilets.map((m) => m.mocks).filter(Boolean);
-        const baseMocks = resolve(fullBase, 'mocks');
-        const krasBaseConfig = resolve(fullBase, krasrc);
-        const krasRootConfig = resolve(appRoot, krasrc);
-        const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
-        const configs = [krasBaseConfig, ...pilets.map((p) => resolve(p.root, krasrc)), krasRootConfig];
-        const required = {
-          injectors: {
-            piral: {
-              active: false,
-            },
-            pilet: {
-              active: true,
-              pilets,
-              app: appDir,
-              publicUrl,
-              handle: ['/', api],
-              api,
-            },
-          },
-        };
-
-        if (customkrasrc) {
-          configs.push(resolve(fullBase, customkrasrc));
-        }
-
-        configs.forEach(cfg => watcherContext.watch(cfg));
-
-        const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
 
-        log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
-
-        const krasServer = buildKrasWithCli(krasConfig);
-        krasServer.setMaxListeners(maxListeners);
-        krasServer.removeAllListeners('open');
-        krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
-
-        await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-        await krasServer.start();
-        openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-        await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-        await new Promise((resolve) => krasServer.on('close', resolve));
+        await platform.startModule({
+          appRoot,
+          appDir,
+          pilets,
+          customkrasrc,
+          feed,
+          fullBase,
+          hooks,
+          open,
+          originalPort: suggestedPort,
+          publicUrl,
+          maxListeners,
+          registerEnd(cb) {
+            return watcherContext.onClean(cb);
+          },
+          registerWatcher(file) {
+            return watcherContext.watch(file);
+          }
+        });
       }),
     );
   });

package/src/apps/debug-piral.ts

@@ -1,24 +1,19 @@
 import { dirname, join, resolve } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
 import { callPiralDebug } from '../bundler';
 import { LogLevels } from '../types';
 import {
   retrievePiletsInfo,
   retrievePiralRoot,
-  openBrowser,
   checkCliCompatibility,
-  notifyServerOnline,
   setLogLevel,
   progress,
-  log,
   config,
   normalizePublicUrl,
+  configurePlatform,
   logDone,
   getDestination,
-  createInitialKrasConfig,
-  getAvailablePort,
-  checkExistingDirectory,
   watcherTask,
+  validateSharedDependencies,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -126,7 +121,6 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
-  const port = await getAvailablePort(originalPort);
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
@@ -140,9 +134,12 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     const dest = getDestination(entryFiles, resolve(fullBase, target));
 
     watcherContext.watch(join(root, 'package.json'));
+    watcherContext.watch(join(root, 'piral.json'));
 
     await checkCliCompatibility(root);
 
+    validateSharedDependencies(externals);
+
     await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, piralInstances });
 
     const bundler = await callPiralDebug(
@@ -151,7 +148,7 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
         piralInstances,
         optimizeModules,
         hmr,
-        externals: externals.map(m => m.name),
+        externals: externals.map((m) => m.name),
         publicUrl,
         entryFiles,
         logLevel,
@@ -172,55 +169,31 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     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);
-    const krasBaseConfig = resolve(fullBase, krasrc);
-    const krasRootConfig = resolve(root, krasrc);
-    const mocks = join(targetDir, 'mocks');
-    const baseMocks = resolve(fullBase, 'mocks');
-    const mocksExist = await checkExistingDirectory(mocks);
-    const sources = [mocksExist ? mocks : undefined].filter(Boolean);
-    const initial = createInitialKrasConfig(baseMocks, sources);
-    const configs = [krasBaseConfig, krasRootConfig];
-    const required = {
-      injectors: {
-        piral: {
-          active: true,
-          handle: ['/'],
-          feed,
-          publicUrl,
-          bundler,
-        },
-        pilet: {
-          active: false,
-        },
-      },
-    };
-
-    if (customkrasrc) {
-      configs.push(resolve(fullBase, customkrasrc));
-    }
-
-    configs.forEach(cfg => watcherContext.watch(cfg));
 
-    const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
-
-    log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
-
-    const krasServer = buildKrasWithCli(krasConfig);
-    krasServer.setMaxListeners(16);
-    krasServer.removeAllListeners('open');
-    krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
-
-    await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-    await krasServer.start();
-    openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-    await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-
-    watcherContext.onClean(() => krasServer.stop());
+    await platform.startShell({
+      bundler,
+      customkrasrc,
+      feed,
+      fullBase,
+      hooks,
+      open,
+      originalPort,
+      publicUrl,
+      root,
+      targetDir,
+      registerEnd(cb) {
+        return watcherContext.onClean(cb);
+      },
+      registerWatcher(file) {
+        return watcherContext.watch(file);
+      }
+    });
   });
 
   await Promise.all([buildRef.end, serverRef.end]);

package/src/common/constants.ts

@@ -11,6 +11,7 @@ export const bundlerNames = [
   'parcel' as const,
   'parcel2' as const,
   'rollup' as const,
+  'rspack' as const,
   'webpack' as const,
   'webpack5' as const,
   'vite' as const,

package/src/common/declaration.ts

@@ -2,7 +2,7 @@ import { DeclOptions, generateDeclaration, createExcludePlugin, Logger } from 'd
 import { dirname, basename, resolve, extname } from 'path';
 import { progress, log, logWarn, logVerbose, logInfo } from './log';
 import { ForceOverwrite } from './enums';
-import { retrievePiralRoot, retrievePiletsInfo, flattenExternals } from './package';
+import { retrievePiralRoot, retrievePiletsInfo, flattenExternals, validateSharedDependencies } from './package';
 import { entryModuleExtensions, piralBaseRoot } from './constants';
 import { readText, getEntryFiles, matchFiles, createFileIfNotExists } from './io';
 import { getModulePath } from '../external';
@@ -172,6 +172,8 @@ export async function createPiralDeclaration(
     logger: createLogger(),
   };
 
+  validateSharedDependencies(externals);
+
   if (options.apis.length) {
     return await createDeclarationFile(options, baseDir, target, forceOverwrite);
   }

package/src/common/index.ts

@@ -25,6 +25,7 @@ export * from './package';
 export * from './parallel';
 export * from './patcher';
 export * from './patches';
+export * from './platform';
 export * from './port';
 export * from './rules';
 export * from './scaffold';

package/src/common/pack.ts

@@ -1,6 +1,7 @@
 import { tmpdir } from 'os';
 import { resolve, relative, join, dirname, basename } from 'path';
 import { createTgz } from './archive';
+import { onlyUnique } from './utils';
 import { log, progress, fail } from './log';
 import { readJson, copy, removeDirectory, checkExists, makeTempDir, createDirectory } from './io';
 import { getPossiblePiletMainPaths } from './inspect';
@@ -52,7 +53,7 @@ export async function createPiletPackage(baseDir: string, source: string, target
   const readme = resolve(root, 'README.md');
 
   if (Array.isArray(pckg.files)) {
-    files.push(...pckg.files.map(f => resolve(root, f)));
+    files.push(...pckg.files.map((f) => resolve(root, f)));
   }
 
   if (await checkExists(readme)) {
@@ -63,7 +64,7 @@ export async function createPiletPackage(baseDir: string, source: string, target
   const cwd = await makeTempDir(prefix);
   log('generalDebug_0003', `Creating package with content from "${content}" ...`);
 
-  await Promise.all(files.map((file) => copy(file, resolve(cwd, relative(root, file)))));
+  await Promise.all(files.filter(onlyUnique).map((file) => copy(file, resolve(cwd, relative(root, file)))));
 
   log('generalDebug_0003', `Creating directory if not exist for "${file}" ...`);
 

package/src/common/package.ts

@@ -5,6 +5,7 @@ import { unpackTarball } from './archive';
 import { ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
+import { onlyUnique } from './utils';
 import { readImportmap } from './importmap';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
@@ -546,10 +547,6 @@ export async function findPackageVersion(rootPath: string, packageName: string |
   return 'latest';
 }
 
-function onlyUnique<T>(value: T, index: number, self: Array<T>) {
-  return self.indexOf(value) === index;
-}
-
 export function flattenExternals(dependencies: Array<SharedDependency>) {
   return dependencies.map((m) => m.name).filter(onlyUnique);
 }
@@ -601,13 +598,6 @@ export async function retrievePiletsInfo(entryFile: string) {
   };
   const framework = frameworkLibs.find((lib) => lib in dependencies.std || lib in dependencies.dev);
 
-  // See #591 - we should warn in case somebody shared piral packages
-  for (const external of externals) {
-    if (external.type === 'local' && external.name.startsWith('piral-') && external.name.indexOf('/') === -1) {
-      log('generalWarning_0001', `The dependency "${external.name}" should not be shared.`);
-    }
-  }
-
   return {
     ...info,
     externals,
@@ -621,6 +611,17 @@ export async function retrievePiletsInfo(entryFile: string) {
   };
 }
 
+export function validateSharedDependencies(externals: Array<SharedDependency>) {
+  // See #591 - we should warn in case somebody shared piral packages
+  for (const external of externals) {
+    const name = external.name;
+
+    if (external.type === 'local' && name.startsWith('piral-') && name.indexOf('/') === -1) {
+      log('invalidSharedDependency_0029', name);
+    }
+  }
+}
+
 export function isValidDependency(name: string) {
   // super simple check at the moment
   // just to filter out things like "redux-saga/effects" and "@scope/redux-saga/effects"
@@ -773,7 +774,7 @@ export async function retrievePiletData(target: string, app?: string) {
   const proposedRoot = piletJson ? dirname(piletJson) : target;
   const root = await findPiletRoot(proposedRoot);
   const piletPackage = await readJson(root, 'package.json');
-  const piletDefinition: PiletDefinition = piletJson && await readJson(proposedRoot, 'pilet.json');
+  const piletDefinition: PiletDefinition = piletJson && (await readJson(proposedRoot, 'pilet.json'));
   const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, target);
   const apps: Array<AppDefinition> = [];
 

package/src/common/platform.ts

@@ -0,0 +1,27 @@
+import { fail } from './log';
+import { PlatformStartShellOptions, PlatformStartModuleOptions } from '../types';
+
+export interface WebPlatformSettings {
+  platform: 'web';
+}
+
+export interface NodePlatformSettings {
+  platform: 'node';
+}
+
+export type PlatformSettings = WebPlatformSettings | NodePlatformSettings;
+
+export interface PlatformTarget {
+  startShell(options: PlatformStartShellOptions): Promise<void>;
+  startModule(options: PlatformStartModuleOptions): Promise<void>;
+}
+
+export function configurePlatform(target: Partial<PlatformSettings> = {}): PlatformTarget {
+  const { platform = 'web' } = target;
+
+  if (platform === 'web') {
+    return require('../platforms/web');
+  }
+
+  return fail('platformNotSupported_0190', platform);
+}

package/src/common/utils.ts

@@ -0,0 +1,3 @@
+export function onlyUnique<T>(value: T, index: number, self: Array<T>) {
+  return self.indexOf(value) === index;
+}

package/src/messages.ts

@@ -642,6 +642,70 @@ export function importMapFileNotFound_0028(dir: string, file: string): QuickMess
   return [LogLevels.error, '0028', `The importmap "${file}" could not be found at "${dir}".`];
 }
 
+/**
+ * @kind Warning
+ *
+ * @summary
+ * The given dependency seems to be a Piral plugin and should not be exposed
+ * as a shared dependency.
+ *
+ * @abstract
+ * While you should be quite restrictive in general regarding sharing dependencies,
+ * there are some dependencies that should never be shared. One area are dependencies
+ * that are only meant for the app shell and don't make sense somewhere else.
+ *
+ * Even though many dependencies might exist that fall into that area the only ones
+ * we know for sure are the so-called Piral plugins. These are dependencies that only
+ * make sense to be used within an app shell, i.e., a Piral instance (or host application).
+ *
+ * When the Piral CLI detects that you want to share such a dependency from an app shell,
+ * or alternatively within a pilet directly, it will print a warning. There might be false
+ * positives here, so having an error here might be a bit too much. Nevertheless, depending
+ * on your scenario you might want to treat these warnings as errors.
+ *
+ * @see
+ * - [Sharing dependencies](https://docs.piral.io/concepts/I08-importmap)
+ *
+ * @example
+ * Check the contents of the available package.json:
+ *
+ * ```sh
+ * cat package.json
+ * ```
+ *
+ * The displayed content should look similar to (i.e., contain an importmap such as):
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "piral-ng": ""
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * This would share the whole Piral plugin, which does not make much sense. First of all,
+ * the plugin is presumably already installed - it even could only be installed in a
+ * Piral instance. Second, there is no use of the exported function somewhere else.
+ *
+ * Instead, you potentially might want to share a submodule. For instance, in the example
+ * above the "piral-ng/common" submodule should be shared.
+ *
+ * ```json
+ * {
+ *   "importmap": {
+ *     "imports": {
+ *       "piral-ng/common": ""
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function invalidSharedDependency_0029(name: string): QuickMessage {
+  return [LogLevels.warning, '0029', `The dependency "${name}" should not be shared.`];
+}
+
 /**
  * @kind Error
  *
@@ -2491,6 +2555,7 @@ export function invalidSchemaVersion_0171(schemaVersion: string, schemas: Array<
  * - [Webpack](https://webpack.js.org)
  * - [Parcel](https://parceljs.org)
  * - [esbuild](https://esbuild.github.io)
+ * - [rspack](https://www.rspack.dev/)
  * - [Pluggable bundlers](https://docs.piral.io/concepts/T02-bundlers)
  *
  * @example
@@ -2523,6 +2588,7 @@ export function bundlerMissing_0172(bundlerName: string, installed: Array<string
  * - [Webpack](https://webpack.js.org)
  * - [Parcel](https://parceljs.org)
  * - [esbuild](https://esbuild.github.io)
+ * - [rspack](https://www.rspack.dev/)
  * - [Pluggable bundlers](https://docs.piral.io/concepts/T02-bundlers)
  *
  * @example
@@ -2555,6 +2621,7 @@ export function defaultBundlerMissing_0173(): QuickMessage {
  * - [Webpack](https://webpack.js.org)
  * - [Parcel](https://parceljs.org)
  * - [esbuild](https://esbuild.github.io)
+ * - [rspack](https://www.rspack.dev/)
  * - [Pluggable bundlers](https://docs.piral.io/concepts/T02-bundlers)
  *
  * @example
@@ -2663,6 +2730,26 @@ export function piletJsonNotAvailable_0180(root: string): QuickMessage {
   return [LogLevels.warning, '0180', `No "pilet.json" was found for the pilet at "${root}".`];
 }
 
+/**
+ * @kind Error
+ *
+ * @summary
+ * Using the given platform is not supported.
+ *
+ * @abstract
+ * The Piral instance can run on multiple platforms. The platform is specified via
+ * the piral.json file.
+ *
+ * The standard platform is "web", which starts a web server using the server
+ * proxy kras.
+ *
+ * @example
+ * (tbd)
+ */
+export function platformNotSupported_0190(platform: string): QuickMessage {
+  return [LogLevels.error, '0190', `The given platform "${platform}" is not supported.`];
+}
+
 /**
  * @kind Warning
  *