piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/platforms/node.ts

@@ -0,0 +1,16 @@
+import { PlatformStartShellOptions, PlatformStartModuleOptions } from '../types';
+
+async function startModule(options: PlatformStartModuleOptions) {
+  //TODO
+}
+
+async function startShell(options: PlatformStartShellOptions) {
+  //TODO
+}
+
+export function setup() {
+  return {
+    startModule,
+    startShell,
+  };
+}

package/src/platforms/web.ts

@@ -0,0 +1,148 @@
+import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
+import { dirname, join, resolve } from 'path';
+import { createInitialKrasConfig, notifyServerOnline } from '../common/injectors';
+import { log } from '../common/log';
+import { config } from '../common/config';
+import { openBrowser } from '../common/browser';
+import { checkExistingDirectory, findFile } from '../common/io';
+import { getAvailablePort } from '../common/port';
+import { PlatformStartShellOptions, PlatformStartModuleOptions } from '../types';
+
+async function startModule(options: PlatformStartModuleOptions) {
+  const {
+    appDir,
+    fullBase,
+    open,
+    feed,
+    publicUrl,
+    customkrasrc,
+    originalPort,
+    hooks,
+    registerWatcher,
+    registerEnd,
+    pilets,
+    maxListeners,
+  } = options;
+
+  const sources = pilets.map((m) => m.mocks).filter(Boolean);
+  const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
+  const baseMocks = resolve(fullBase, 'mocks');
+  const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
+  const configs = [...pilets.map((p) => resolve(p.root, krasrc))];
+
+  const required = {
+    injectors: {
+      piral: {
+        active: false,
+      },
+      pilet: {
+        active: true,
+        pilets,
+        app: appDir,
+        publicUrl,
+        handle: ['/', api],
+        api,
+      },
+    },
+  };
+
+  if (appDir) {
+    const appPackageJson = await findFile(appDir, 'package.json');
+
+    if (appPackageJson) {
+      configs.unshift(resolve(dirname(appPackageJson), krasrc));
+    }
+  }
+
+  if (customkrasrc) {
+    configs.push(resolve(fullBase, customkrasrc));
+  }
+
+  configs.forEach(registerWatcher);
+
+  const port = await getAvailablePort(originalPort);
+  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 });
+
+  registerEnd(() => krasServer.stop());
+}
+
+async function startShell(options: PlatformStartShellOptions) {
+  const {
+    fullBase,
+    open,
+    root,
+    targetDir,
+    feed,
+    publicUrl,
+    bundler,
+    customkrasrc,
+    originalPort,
+    hooks,
+    registerWatcher,
+    registerEnd,
+  } = options;
+  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(registerWatcher);
+
+  const port = await getAvailablePort(originalPort);
+  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 });
+
+  registerEnd(() => krasServer.stop());
+}
+
+export function setup() {
+  return {
+    startModule,
+    startShell,
+  };
+}

package/src/plugin.ts

@@ -1,10 +1,39 @@
 import { readdir, stat } from 'fs';
-import { join, resolve } from 'path';
-import { log } from './common';
+import { join, resolve, sep, posix } from 'path';
+import { cliName, cliVersion, log } from './common';
 import { inject } from './inject';
 
-function getLocalPackageDir() {
-  return resolve(__dirname, '..', '..');
+function getContainerDir() {
+  const currentDir = __dirname.split(sep).join(posix.sep);
+
+  if (!currentDir.includes(`/.pnpm/${cliName}@${cliVersion}/node_modules/${cliName}/`)) {
+    return resolve(__dirname, '..', '..');
+  }
+
+  return undefined;
+}
+
+async function getLocalPackageDir() {
+  const proposedDirs = [
+    getContainerDir(),
+    resolve(process.cwd(), 'node_modules'),
+    resolve(process.cwd(), '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', '..', 'node_modules'),
+  ];
+
+  // Right now we always take the first one, but in the future this may be different
+  // once we come up with more / better criteria to identify if its a good/valid
+  // plugin root directory
+  for (const dir of proposedDirs.filter(Boolean)) {
+    log('generalDebug_0003', `Checking for potential plugin directory "${dir}" ...`);
+
+    if (await isDirectory(dir)) {
+      return dir;
+    }
+  }
+
+  return undefined;
 }
 
 function isDirectory(dir: string) {
@@ -83,7 +112,7 @@ async function getAllPlugins(rootDir: string): Promise<Array<string>> {
 }
 
 export async function loadPlugins() {
-  const localDir = getLocalPackageDir();
+  const localDir = await getLocalPackageDir();
   const allPlugins = await getAllPlugins(localDir);
 
   for (const pluginPath of allPlugins) {

package/src/questionnaire.ts

@@ -7,6 +7,7 @@ type FlagType = 'string' | 'number' | 'boolean' | 'object';
 interface Flag {
   name: string;
   type?: FlagType;
+  alias: Array<string>;
   values?: Array<any>;
   describe?: string;
   default?: any;
@@ -16,16 +17,23 @@ interface Flag {
 function getCommandData(retrieve: any) {
   const instructions: Array<Flag> = [];
   const fn = {
+    alias(name: string, altName: string) {
+      return this.swap(name, (flag) => ({
+        ...flag,
+        alias: [...flag.alias, altName],
+      }));
+    },
     positional(name: string, info: Flag) {
       instructions.push({
         ...info,
+        alias: [],
         name,
       });
       return this;
     },
     swap(name: string, swapper: (flag: Flag) => Flag) {
       const [flag] = instructions.filter((m) => m.name === name);
-      const newFlag = swapper(flag || { name });
+      const newFlag = swapper(flag || { name, alias: [] });
 
       if (!flag) {
         instructions.push(newFlag);
@@ -102,6 +110,8 @@ function getValue(type: FlagType, value: string) {
       return +value;
     case 'string':
       return value;
+    case 'object':
+      return value;
   }
 }
 
@@ -133,7 +143,7 @@ export function runQuestionnaireFor(
   const questions = instructions
     .filter((instruction) => !ignored.includes(instruction.name))
     .filter((instruction) => !acceptAll || (instruction.default === undefined && instruction.required))
-    .filter((instruction) => args[instruction.name] === undefined)
+    .filter((instruction) => [...instruction.alias, instruction.name].every((m) => args[m] === undefined))
     .filter((instruction) => instruction.type !== 'object')
     .map((instruction) => ({
       name: instruction.name,
@@ -144,12 +154,16 @@ export function runQuestionnaireFor(
       validate: instruction.type === 'number' ? (input: string) => !isNaN(+input) : () => true,
     }));
 
+
   return inquirer.prompt(questions).then((answers) => {
     const parameters: any = {};
 
     for (const instruction of instructions) {
       const name = instruction.name;
-      const value = answers[name] ?? ignoredInstructions[name] ?? args[name];
+      const value =
+        answers[name] ??
+        ignoredInstructions[name] ??
+        [...instruction.alias, instruction.name].map((m) => args[m]).find((v) => v !== undefined);
       parameters[name] = value !== undefined ? getValue(instruction.type, value as any) : instruction.default;
     }
 

package/src/release.ts

@@ -1,8 +1,19 @@
-import { basename, resolve } from 'path';
-import { copy, fail } from './common';
+import { basename, dirname, relative, resolve } from 'path';
+import { copy, fail, findFile, FormDataObj, postForm, readBinary } from './common';
 import { availableReleaseProviders } from './helpers';
 import { ReleaseProvider } from './types';
 
+async function getVersion(directory: string) {
+  const data = await findFile(directory, 'package.json');
+
+  if (!data) {
+    fail('packageJsonNotFound_0020');
+  }
+
+  const { version } = require(data);
+  return version;
+}
+
 export interface QualifiedReleaseProvider {
   name: string;
   action: ReleaseProvider;
@@ -12,7 +23,7 @@ const providers: Record<string, ReleaseProvider> = {
   none() {
     return Promise.resolve();
   },
-  async xcopy(files, args) {
+  async xcopy(_, files, args) {
     const { target } = args;
 
     if (!target) {
@@ -21,6 +32,31 @@ const providers: Record<string, ReleaseProvider> = {
 
     await Promise.all(files.map(async (file) => copy(file, resolve(target, basename(file)))));
   },
+  async feed(directory, files, args, interactive) {
+    const { url, apiKey, scheme = 'basic', version = await getVersion(directory) } = args;
+
+    if (!url) {
+      fail('publishFeedMissingUrl_0115');
+    }
+
+    if (!version) {
+      fail('publishFeedMissingVersion_0116');
+    }
+
+    const data: FormDataObj = {
+      version,
+      type: 'custom',
+    };
+
+    for (const file of files) {
+      const relPath = relative(directory, file);
+      const fileName = basename(file);
+      const content = await readBinary(dirname(file), fileName);
+      data[relPath] = [content, fileName];
+    }
+
+    await postForm(url, scheme as any, apiKey, data, {}, undefined, interactive);
+  },
 };
 
 function findReleaseProvider(providerName: string) {
@@ -43,7 +79,13 @@ export function setReleaseProvider(provider: QualifiedReleaseProvider) {
   }
 }
 
-export function publishArtifacts(providerName: string, files: Array<string>, args: Record<string, string>) {
+export function publishArtifacts(
+  providerName: string,
+  directory: string,
+  files: Array<string>,
+  args: Record<string, string>,
+  interactive: boolean,
+) {
   const runRelease = findReleaseProvider(providerName);
-  return runRelease(files, args);
+  return runRelease(directory, files, args, interactive);
 }

package/src/rules/index.ts

@@ -19,7 +19,7 @@ function getRules<T extends RuleContext>(target: 'pilet' | 'piral') {
             .map((fileName) => {
               log('generalDebug_0003', `Including module "${fileName}" ...`);
               const run = require(`./${fileName}`).default;
-              const name = fileName.substr(prefix.length).replace(/\.js$/, '');
+              const name = fileName.substring(prefix.length).replace(/\.js$/, '');
               log('generalDebug_0003', `Included rule with name: "${name}".`);
               return {
                 run,

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

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

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

@@ -1,5 +1,5 @@
 import { PiletRuleContext } from '../types';
-import { getPiletsInfo, getSourceFiles, isValidDependency } from '../common';
+import { retrieveExternals, getSourceFiles, isValidDependency } from '../common';
 
 export type Options = 'ignore' | 'active' | 'only-used';
 
@@ -20,15 +20,17 @@ Received: Missing "${missingNames.join('", "')}".
  * Checks that "externals" dependencies have been specified in "peerDependencies".
  */
 export default async function (context: PiletRuleContext, options: Options = 'ignore') {
-  if (options !== 'ignore') {
-    const { externals } = getPiletsInfo(context.data.appPackage);
+  // only check if options are not set to ignore and if importmap feature is not used
+  if (options !== 'ignore' && !context.piletPackage.importmap) {
+    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
-      .map((name) => {
-        const valid = isValidDependency(name);
-        const missing = !(valid ? markedPeerDependencies : markedPeerModules).includes(name);
-        return { name, valid, missing };
+      .map((external) => {
+        const valid = isValidDependency(external.name);
+        const missing = !(valid ? markedPeerDependencies : markedPeerModules).includes(external.name);
+        return { name: external.name, valid, missing };
       })
       .filter((m) => m.missing);
 

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

@@ -1,4 +1,4 @@
-import { findLatestVersion } from '../common';
+import { isMonorepoPackageRef, findLatestVersion } from '../common';
 import { PiletRuleContext } from '../types';
 
 export type Options = 'suggest' | 'required' | 'ignore';
@@ -8,22 +8,32 @@ 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:');
 
     if (!isfixed) {
-      const latestVersion = await findLatestVersion(name);
+      const isMonorepoRef = await isMonorepoPackageRef(name, context.root);
 
-      if (version !== latestVersion) {
-        const notify = options === 'required' ? context.error : context.warning;
-        notify(
-          `
-The used version of "${name}" is outdated.
-  Expected: v${latestVersion}.
-  Received: v${version}.
-`,
-        );
+      // either we are not in a monorepo or the app shell is not part of the monorepo
+      if (!isMonorepoRef) {
+        const latestVersion = await findLatestVersion(name).catch((err) => {
+          context.warning(`
+  The used version of "${name}" could not be determined: ${err}.
+          `);
+          return version;
+        });
+
+        if (version !== latestVersion) {
+          const notify = options === 'required' ? context.error : context.warning;
+          notify(
+            `
+  The used version of "${name}" is outdated.
+    Expected: v${latestVersion}.
+    Received: v${version}.
+  `,
+          );
+        }
       }
     }
   }

package/src/rules/piral-has-valid-externals.ts

@@ -6,38 +6,19 @@ export type Options = void;
  * Checks that the externals to be used in pilets are valid.
  */
 export default function (context: PiralRuleContext, options: Options = undefined) {
-  const { externals } = context.info;
+  const { externals } = context;
+  const invalidDepRefs = externals
+    .filter((ext) => !ext.parents || ext.parents.length === 0)
+    .map((ext) => ext.name)
+    .filter((name) => context.dependencies[name] === undefined && context.devDependencies[name] === undefined);
 
-  if (!Array.isArray(externals)) {
-    context.error(
+  for (const invalidDepRef of invalidDepRefs) {
+    context.warning(
       `
-The shared dependencies in pilets.external are invalid.
-  Expected: <Array>.
-  Received: <${typeof externals}>.
+The shared dependency "${invalidDepRef}" is not listed in the "dependencies" and "devDependencies".
+Expected: "${invalidDepRef}" in dependencies.
+Received: <none>.
 `,
     );
-  } else {
-    const invalidDepTypes = externals.filter((ext) => typeof ext !== 'string');
-    const invalidDepRefs = externals.filter((ext) => typeof ext === 'string' && !context.dependencies[ext]);
-
-    if (invalidDepTypes.length > 0) {
-      context.error(
-        `
-The shared dependencies in pilets.external are invalid.
-  Expected: Only names (<string>) in the array.
-  Received: Found ${invalidDepTypes.length} non-<string> entries.
-`,
-      );
-    }
-
-    for (const invalidDepRef of invalidDepRefs) {
-      context.warning(
-        `
-The shared dependency "${invalidDepRef}" is listed in pilets.external, but not in dependencies.
-  Expected: "${invalidDepRef}" in dependencies.
-  Received: <none>.
-`,
-      );
-    }
   }
 }

package/src/types/common.ts

@@ -1,3 +1,54 @@
+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;
+  port: number;
+}
+
+export interface AppDefinition {
+  appPackage: PiralInstancePackageData;
+  appFile: string;
+  appRoot: string;
+  appPort: number;
+  emulator: boolean;
+}
+
 export enum LogLevels {
   /**
    * Logging disabled
@@ -41,8 +92,39 @@ export interface Bundler {
   ready(): Promise<void>;
 }
 
+export interface PlatformStartModuleOptions {
+  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 {
-  (files: Array<string>, args: Record<string, string>): Promise<void>;
+  (directory: string, files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;
 }
 
 export interface TemplateFileLocation {
@@ -54,7 +136,7 @@ export interface TemplateFileLocation {
 
 export interface PiletsInfo {
   files: Array<string | TemplateFileLocation>;
-  externals: Array<string>;
+  template: string;
   devDependencies: Record<string, string | true>;
   scripts: Record<string, string>;
   validators: Record<string, any>;
@@ -76,6 +158,17 @@ export interface RuleContext {
   peerDependencies: Record<string, string>;
 }
 
+export interface SharedDependency {
+  id: string;
+  requireId: string;
+  name: string;
+  ref: string;
+  type: 'local' | 'remote';
+  entry: string;
+  parents?: Array<string>;
+  alias?: string;
+}
+
 export interface RuleRunner<T extends RuleContext> {
   (context: T, options: any): void | Promise<void>;
 }
@@ -87,15 +180,12 @@ export interface Rule<T extends RuleContext> {
 
 export interface PiralRuleContext extends RuleContext {
   info: PiletsInfo;
+  externals: Array<SharedDependency>;
 }
 
 export interface PiletRuleContext extends RuleContext {
-  data: PiralData;
-  peerModules: Array<string>;
-}
-
-export interface PiralData {
-  appFile: string;
-  appPackage: any;
+  apps: Array<AppDefinition>;
   piletPackage: any;
+  peerModules: Array<string>;
+  importmap: Array<SharedDependency>;
 }