piral-cli 0.15.0-beta.4544 → 0.15.0-beta.4574

package/src/common/package.ts

@@ -18,10 +18,21 @@ import {
   FileInfo,
   PiletsInfo,
   TemplateFileLocation,
-  PackageData,
+  PiletPackageData,
+  PiralPackageData,
   SharedDependency,
+  PiletDefinition,
+  AppDefinition,
+  PiralInstancePackageData,
 } from '../types';
 
+export interface PiralInstanceData {
+  packageName: Framework;
+  language: SourceLanguage;
+  reactVersion: number;
+  reactRouterVersion: number;
+}
+
 async function appendBundler(devDependencies: Record<string, string>, bundler: string, proposedVersion: string) {
   if (bundler && bundler !== 'none') {
     if (isValidDependency(bundler)) {
@@ -140,49 +151,56 @@ export function getPiralPath(root: string, name: string) {
   return dirname(path);
 }
 
-function findPackage(pck: string | Array<string>, baseDir: string) {
-  if (Array.isArray(pck)) {
-    for (const item of pck) {
-      const result = findPackage(item, baseDir);
-
-      if (result) {
-        return result;
-      }
+function findPiralInstances(
+  proposedApps: Array<string>,
+  piletPackage: PiletPackageData,
+  piletDefinition: undefined | PiletDefinition,
+  baseDir: string,
+): Array<PiralInstancePackageData> {
+  if (proposedApps) {
+    // do nothing
+  } else if (piletDefinition) {
+    const availableApps = Object.keys(piletDefinition.piralInstances || {});
+    proposedApps = availableApps.filter((m) => piletDefinition.piralInstances[m].selected);
+
+    if (proposedApps.length === 0) {
+      proposedApps = availableApps.slice(0, 1);
     }
   } else {
-    const path = findPackageRoot(pck, baseDir);
-
-    if (path) {
-      log('generalDebug_0003', `Following the app package in "${path}" ...`);
-      const appPackage = require(path);
-      const root = dirname(path);
-      const relPath = appPackage && appPackage.app;
-      appPackage.app = relPath && resolve(root, relPath);
-      appPackage.root = root;
-      return appPackage;
-    }
+    proposedApps = [piletPackage.piral?.name].filter(Boolean);
   }
 
-  return undefined;
+  if (proposedApps.length > 0) {
+    return proposedApps.map((proposedApp) => {
+      const path = findPackageRoot(proposedApp, baseDir);
+
+      if (path) {
+        log('generalDebug_0003', `Following the app package in "${path}" ...`);
+        const appPackage = require(path);
+        const root = dirname(path);
+        const relPath = appPackage && appPackage.app;
+        appPackage.app = relPath && resolve(root, relPath);
+        appPackage.root = root;
+        return appPackage;
+      }
+
+      fail('appInstanceNotFound_0010', proposedApp);
+    });
+  }
+
+  return [];
 }
 
-export function readPiralPackage(root: string, name: string): Promise<PackageData> {
+export function readPiralPackage(root: string, name: string): Promise<PiralPackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
   return readJson(path, 'package.json');
 }
 
-export interface PiralPackageData {
-  packageName: Framework;
-  language: SourceLanguage;
-  reactVersion: number;
-  reactRouterVersion: number;
-}
-
 export async function patchPiralPackage(
   root: string,
   app: string,
-  data: PiralPackageData,
+  data: PiralInstanceData,
   version: string,
   bundler?: string,
 ) {
@@ -196,7 +214,7 @@ export async function patchPiralPackage(
   log('generalDebug_0003', `Succesfully patched the pilet.json.`);
 }
 
-export async function getPiralPackage(app: string, data: PiralPackageData, version: string, bundler?: string) {
+export async function getPiralPackage(app: string, data: PiralInstanceData, version: string, bundler?: string) {
   const framework = data.packageName;
   const devDependencies = {
     ...getDevDependencies(
@@ -359,7 +377,7 @@ function tryFindPackageVersion(packageName: string): string {
 export async function copyPiralFiles(
   root: string,
   name: string,
-  piralInfo: PackageData,
+  piralInfo: PiralPackageData,
   forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
@@ -379,7 +397,7 @@ export async function copyPiralFiles(
   await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
-export function getPiletsInfo(piralInfo: Partial<PackageData>): PiletsInfo {
+export function getPiletsInfo(piralInfo: Partial<PiralPackageData>): PiletsInfo {
   const {
     files = [],
     scripts = {},
@@ -538,7 +556,7 @@ export async function patchPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: PackageData,
+  piralInfo: PiralPackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -560,7 +578,7 @@ export async function getPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: PackageData,
+  piralInfo: PiralPackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -624,7 +642,7 @@ export async function getPiletPackage(
 /**
  * Returns true if its an emulator package, otherwise it has to be a "raw" app shell.
  */
-export function checkAppShellPackage(appPackage: PackageData) {
+export function checkAppShellPackage(appPackage: PiralPackageData) {
   const { piralCLI = { generated: false, version: cliVersion } } = appPackage;
 
   if (piralCLI.generated) {
@@ -665,7 +683,9 @@ export function combinePiletExternals(
 }
 
 export async function retrievePiletData(target: string, app?: string) {
-  const packageJson = await findFile(target, 'package.json');
+  const piletJson = await findFile(target, 'pilet.json');
+  const proposedRoot = piletJson ? dirname(piletJson) : target;
+  const packageJson = await findFile(proposedRoot, 'package.json');
 
   if (!packageJson) {
     fail('packageJsonMissing_0075');
@@ -673,18 +693,31 @@ export async function retrievePiletData(target: string, app?: string) {
 
   const root = dirname(packageJson);
   const piletPackage = require(packageJson);
-  const appPackage = findPackage(
-    app || (piletPackage.piral && piletPackage.piral.name) || Object.keys(piletPackage.devDependencies),
-    target,
-  );
-  const appFile: string = appPackage?.app;
-  const appRoot: string = appPackage?.root;
+  const piletDefinition = piletJson && require(piletJson);
+  const appPackages = findPiralInstances(app && [app], piletPackage, piletDefinition, target);
+  const apps: Array<AppDefinition> = [];
+
+  if (appPackages.length === 0) {
+    fail('appInstancesNotGiven_0012');
+  }
+
+  for (const appPackage of appPackages) {
+    const appFile: string = appPackage?.app;
+    const appRoot: string = appPackage?.root;
 
-  if (!appFile || !appRoot) {
-    fail('appInstanceInvalid_0011');
+    if (!appFile || !appRoot) {
+      fail('appInstanceInvalid_0011');
+    }
+
+    const emulator = checkAppShellPackage(appPackage);
+    apps.push({
+      appPackage,
+      appFile,
+      appRoot,
+      emulator,
+    });
   }
 
-  const emulator = checkAppShellPackage(appPackage);
   const importmap = await readImportmap(root, piletPackage);
 
   return {
@@ -694,11 +727,8 @@ export async function retrievePiletData(target: string, app?: string) {
     peerModules: piletPackage.peerModules || [],
     ignored: checkArrayOrUndefined(piletPackage, 'preservedDependencies'),
     importmap,
-    appFile,
-    appRoot,
+    apps,
     piletPackage,
-    appPackage,
-    emulator,
     root,
   };
 }

package/src/injectors/pilet-injector.test.ts

@@ -16,7 +16,7 @@ const configMock: any = {
   port: 1234,
 };
 
-describe('Piral-CLI piral injector', () => {
+describe('Piral-CLI pilet injector', () => {
   it('PiletInjector is active when configured', () => {
     const core = new EventEmitter();
     const injector = new PiletInjector(optionsMock, configMock, core);
@@ -33,7 +33,7 @@ describe('Piral-CLI piral injector', () => {
     injector.name;
     injector.getOptions();
     //injector.getMetaOf(0);
-    injector.getMeta('http://localhost:9000');
+    injector.getIndexMeta('http://localhost:9000');
 
     // Assert
     expect(injector.active).toBeFalsy();

package/src/injectors/pilet-injector.ts

@@ -106,8 +106,7 @@ export default class PiletInjector implements KrasInjector {
 
           for (const id of Object.keys(cbs)) {
             const { baseUrl, notify } = cbs[id];
-            const basePath = this.getPiletApi(baseUrl);
-            const meta = JSON.stringify(p.getMeta(basePath));
+            const meta = this.getPiletMeta(baseUrl, p);
             notify(meta);
           }
         }),
@@ -147,9 +146,15 @@ export default class PiletInjector implements KrasInjector {
     }
   }
 
-  async getMeta(baseUrl: string) {
+  getPiletMeta(baseUrl: string, pilet: Pilet) {
+    const basePath = this.getPiletApi(baseUrl);
+    return JSON.stringify(pilet.getMeta(basePath));
+  }
+
+  async getIndexMeta(baseUrl: string) {
     const { pilets, feed } = this.config;
-    const localPilets = pilets.map((pilet) => pilet.getMeta?.(baseUrl)).filter(Boolean);
+    const basePath = this.getPiletApi(baseUrl);
+    const localPilets = pilets.map((pilet) => pilet.getMeta?.(basePath)).filter(Boolean);
     const mergedPilets = this.mergePilets(localPilets, await this.loadRemoteFeed(feed));
     return JSON.stringify(mergedPilets);
   }
@@ -210,7 +215,7 @@ export default class PiletInjector implements KrasInjector {
 
     if (!path) {
       await bundler?.ready();
-      const content = await this.getMeta(baseUrl);
+      const content = await this.getIndexMeta(baseUrl);
       return this.sendContent(content, 'application/json', url);
     } else {
       return bundler?.ready().then(() => {

package/src/messages.ts

@@ -180,6 +180,53 @@ export function appInstanceInvalid_0011(): QuickMessage {
   return [LogLevels.error, '0011', `Could not find a valid Piral instance.`];
 }
 
+/**
+ * @kind Error
+ *
+ * @summary
+ * Reported when no valid Piral instance was specified.
+ *
+ * @abstract
+ * The Piral instance is defined either in the package.json or in the pilet.json.
+ *
+ * The resolution of the Piral instance is done via the `require.resolve` function of Node.js. Thus, if the defined module is simply not yet installed this error will be shown.
+ *
+ * @see
+ * - [npm i](https://docs.npmjs.com/cli/install)
+ * - [npm install is missing modules](https://stackoverflow.com/questions/24652681/npm-install-is-missing-modules)
+ *
+ * @example
+ * Assuming that the available pilet.json of your pilet contains content such as:
+ *
+ * ```json
+ * {
+ *   // ...
+ *   "piralInstances": {
+ *     "my-app-shell": {}
+ *   }
+ * }
+ * ```
+ *
+ * However, running
+ *
+ * ```sh
+ * ls node_modules/my-app-shell
+ * ```
+ *
+ * returns an error.
+ *
+ * To mitigate it try running
+ *
+ * ```sh
+ * npm i
+ * ```
+ *
+ * which will install all dependencies.
+ */
+export function appInstancesNotGiven_0012(): QuickMessage {
+  return [LogLevels.error, '0012', `No Piral instances have been provided.`];
+}
+
 /**
  * @kind Error
  *

package/src/rules/pilet-has-externals-as-peers.test.ts

@@ -38,13 +38,13 @@ describe('Rule pilet-has-externals-as-peers', () => {
 
   function createContext(externals: string[]): PiletRuleContext {
     return {
-      data: {
+      apps: [{
         appPackage: {
           pilets: {
             externals,
           },
         },
-      },
+      }],
       peerDependencies,
       peerModules,
       entry: 'test-entry',

package/src/rules/pilet-has-externals-as-peers.ts

@@ -21,7 +21,8 @@ Received: Missing "${missingNames.join('", "')}".
  */
 export default async function (context: PiletRuleContext, options: Options = 'ignore') {
   if (options !== 'ignore') {
-    const externals = await retrieveExternals(context.data.appRoot, context.data.appPackage);
+    const [app] = context.apps;
+    const externals = await retrieveExternals(app.appRoot, app.appPackage);
     const markedPeerDependencies = Object.keys(context.peerDependencies);
     const markedPeerModules = context.peerModules;
     const missingExternals = externals

package/src/rules/pilet-has-no-self-reference.ts

@@ -8,7 +8,7 @@ export type Options = 'ignore' | 'active';
  */
 export default async function (context: PiletRuleContext, options: Options = 'ignore') {
   if (options !== 'ignore') {
-    const { name } = context.data.appPackage;
+    const { name } = context.apps[0].appPackage;
     const names = ['piral', 'piral-core', 'piral-base', name];
     const files = await getSourceFiles(context.entry);
     const testers: Array<RegExp> = [];

package/src/rules/pilet-stays-small.ts

@@ -50,7 +50,7 @@ function getFileSizeInKB(path: string) {
 export default async function (context: PiletRuleContext, options: Options = -50) {
   if (options !== 0 && typeof options === 'number') {
     const maxSize = Math.abs(options);
-    const { main } = context.data.piletPackage;
+    const { main } = context.piletPackage;
     const path = await getPiletMainPath(main, context.root);
 
     if (path) {

package/src/rules/pilet-uses-latest-piral.ts

@@ -8,7 +8,7 @@ export type Options = 'suggest' | 'required' | 'ignore';
  */
 export default async function (context: PiletRuleContext, options: Options = 'suggest') {
   if (options !== 'ignore') {
-    const { name, version } = context.data.appPackage;
+    const { name, version } = context.apps[0].appPackage;
     const demanded = (context.devDependencies && context.devDependencies[name]) || '';
     const isfixed = demanded.startsWith('git+') || demanded.startsWith('file:');
 

package/src/types/common.ts

@@ -1,3 +1,52 @@
+export interface Importmap {
+  imports: Record<string, string>;
+  inherit: Array<string>;
+}
+
+export interface PackageData {
+  name: string;
+  version: string;
+  description: string;
+  importmap?: Importmap;
+  main: string;
+  author:
+    | string
+    | {
+        name?: string;
+        url?: string;
+        email?: string;
+      };
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+}
+
+// Shape of the package.json of a pilet
+export interface PiletPackageData extends PackageData {
+  piral?: {
+    name: string;
+  };
+  custom?: any;
+}
+
+// Shape of the package.json of a Piral instance or emulator
+export interface PiralPackageData extends PackageData {
+  pilets?: PiletsInfo;
+  piralCLI?: { generated: boolean; version: string };
+}
+
+export interface PiralInstancePackageData extends PiralPackageData {
+  root: string;
+  app: string;
+}
+
+export interface AppDefinition {
+  appPackage: PiralInstancePackageData;
+  appFile: string;
+  appRoot: string;
+  emulator: boolean;
+}
+
 export enum LogLevels {
   /**
    * Logging disabled
@@ -101,14 +150,8 @@ export interface PiralRuleContext extends RuleContext {
 }
 
 export interface PiletRuleContext extends RuleContext {
-  data: PiralData;
+  apps: Array<AppDefinition>;
+  piletPackage: any;
   peerModules: Array<string>;
   importmap: Array<SharedDependency>;
 }
-
-export interface PiralData {
-  appRoot: string;
-  appFile: string;
-  appPackage: any;
-  piletPackage: any;
-}

package/src/types/internal.ts

@@ -1,23 +1,15 @@
-import type { LogLevels, PiletsInfo } from './common';
+import type { LogLevels } from './common';
 
-export interface PackageData {
-  name: string;
-  version: string;
-  description: string;
-  main: string;
-  author:
-    | string
-    | {
-        name?: string;
-        url?: string;
-        email?: string;
-      };
-  custom?: any;
-  pilets?: PiletsInfo;
-  piralCLI?: { generated: boolean; version: string };
-  dependencies: Record<string, string>;
-  peerDependencies: Record<string, string>;
-  devDependencies: Record<string, string>;
+/**
+ * Shape of the pilet.json
+ */
+export interface PiletDefinition {
+  piralInstances?: Record<
+    string,
+    {
+      selected?: boolean;
+    }
+  >;
 }
 
 export interface PackageFiles {