piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/apps/remove-piral-instance-pilet.ts

@@ -0,0 +1,92 @@
+import { dirname, resolve } from 'path';
+import { LogLevels, NpmClientType } from '../types';
+import {
+  setLogLevel,
+  progress,
+  log,
+  matchAnyPilet,
+  findFile,
+  readJson,
+  writeJson,
+  logDone,
+  findPiletRoot,
+  determineNpmClient,
+  uninstallNpmPackage,
+  piletJson,
+} from '../common';
+
+export interface RemovePiralInstancePiletOptions {
+  /**
+   * Sets the log level to use (1-5).
+   */
+  logLevel?: LogLevels;
+
+  /**
+   * The name of the Piral instance to remove.
+   */
+  app?: string;
+
+  /**
+   * Sets the source directory for adding the Piral instance.
+   */
+  source?: string;
+
+  /**
+   * The npm client to be used when scaffolding.
+   * @example 'yarn'
+   */
+  npmClient?: NpmClientType;
+}
+
+export const removePiralInstancePiletDefaults: RemovePiralInstancePiletOptions = {
+  logLevel: LogLevels.info,
+  app: undefined,
+  source: '.',
+  npmClient: undefined,
+};
+
+export async function removePiralInstancePilet(baseDir = process.cwd(), options: RemovePiralInstancePiletOptions = {}) {
+  const {
+    npmClient: defaultNpmClient = removePiralInstancePiletDefaults.npmClient,
+    logLevel = removePiralInstancePiletDefaults.logLevel,
+    source = removePiralInstancePiletDefaults.source,
+    app = removePiralInstancePiletDefaults.app,
+  } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  setLogLevel(logLevel);
+  progress('Reading configuration ...');
+
+  const npmClient = await determineNpmClient(fullBase, defaultNpmClient);
+  const allEntries = await matchAnyPilet(fullBase, [source]);
+
+  const tasks = allEntries.map(async (entryModule) => {
+    const targetDir = dirname(entryModule);
+    const piletJsonPath = await findFile(targetDir, piletJson);
+
+    if (piletJsonPath) {
+      const piletJsonDir = dirname(piletJsonPath);
+      const oldContent = await readJson(piletJsonDir, piletJson);
+      const root = await findPiletRoot(piletJsonDir);
+
+      if ('piralInstances' in oldContent && app in oldContent.piralInstances) {
+        const newContent = {
+          ...oldContent,
+          piralInstances: {
+            ...oldContent.piralInstances,
+            [app]: undefined,
+          },
+        };
+
+        await writeJson(piletJsonDir, piletJson, newContent, true);
+      }
+
+      await uninstallNpmPackage(npmClient, app, root);
+    } else {
+      log('piletJsonNotAvailable_0180', targetDir);
+    }
+  });
+
+  await Promise.all(tasks);
+
+  logDone(`Removed the Piral instance!`);
+}

package/src/apps/run-emulator-piral.ts

@@ -0,0 +1,154 @@
+import { tmpdir } from 'os';
+import { mkdtemp } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
+import { LogLevels, NpmClientType } from '../types';
+import {
+  config,
+  openBrowser,
+  notifyServerOnline,
+  setLogLevel,
+  progress,
+  log,
+  createInitialKrasConfig,
+  getAvailablePort,
+  installPiralInstance,
+  createFileIfNotExists,
+  ForceOverwrite,
+  findPiralInstance,
+  determineNpmClient,
+} from '../common';
+
+export interface RunEmulatorPiralOptions {
+  /**
+   * Sets the log level to use (1-5).
+   */
+  logLevel?: LogLevels;
+
+  /**
+   * The name of the app shell emulator to use.
+   */
+  app?: string;
+
+  /**
+   * Sets if the (system default) browser should be auto-opened.
+   */
+  open?: boolean;
+
+  /**
+   * Sets the port to use for the debug server.
+   */
+  port?: number;
+
+  /**
+   * The URL of a pilet feed(s) used to include locally missing pilets.
+   */
+  feed?: string | Array<string>;
+
+  /**
+   * The npm client to be used when scaffolding.
+   * @example 'yarn'
+   */
+  npmClient?: NpmClientType;
+
+  /**
+   * The package registry to use for resolving the specified Piral app.
+   */
+  registry?: string;
+}
+
+export const runEmulatorPiralDefaults: RunEmulatorPiralOptions = {
+  logLevel: LogLevels.info,
+  open: config.openBrowser,
+  port: config.port,
+  registry: config.registry,
+  npmClient: undefined,
+};
+
+function createTempDir() {
+  const root = join(tmpdir(), 'piral-cli-');
+
+  return new Promise<string>((resolve, reject) =>
+    mkdtemp(root, (err, dir) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(dir);
+      }
+    }),
+  );
+}
+
+export async function runEmulatorPiral(baseDir = process.cwd(), options: RunEmulatorPiralOptions = {}) {
+  const {
+    open = runEmulatorPiralDefaults.open,
+    port: originalPort = runEmulatorPiralDefaults.port,
+    logLevel = runEmulatorPiralDefaults.logLevel,
+    npmClient: defaultNpmClient = runEmulatorPiralDefaults.npmClient,
+    registry = runEmulatorPiralDefaults.registry,
+    app,
+    feed,
+  } = options;
+  const publicUrl = '/';
+  const api = config.piletApi;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const baseMocks = resolve(fullBase, 'mocks');
+  setLogLevel(logLevel);
+
+  progress('Reading configuration ...');
+
+  process.stderr?.setMaxListeners(16);
+  process.stdout?.setMaxListeners(16);
+  process.stdin?.setMaxListeners(16);
+
+  const appRoot = await createTempDir();
+
+  if (registry !== runEmulatorPiralDefaults.registry) {
+    progress(`Setting up npm registry (%s) ...`, registry);
+
+    await createFileIfNotExists(
+      appRoot,
+      '.npmrc',
+      `registry=${registry}
+always-auth=true`,
+      ForceOverwrite.yes,
+    );
+  }
+
+  const npmClient = await determineNpmClient(appRoot, defaultNpmClient);
+  const [packageName] = await installPiralInstance(app, fullBase, appRoot, npmClient);
+  const piral = await findPiralInstance(packageName, appRoot, originalPort);
+  const port = await getAvailablePort(piral.port);
+
+  const krasBaseConfig = resolve(fullBase, krasrc);
+  const krasRootConfig = resolve(appRoot, krasrc);
+  const initial = createInitialKrasConfig(baseMocks, [], { [api]: '' }, feed);
+  const required = {
+    injectors: {
+      piral: {
+        active: false,
+      },
+      pilet: {
+        active: true,
+        pilets: [],
+        app: dirname(piral.app),
+        publicUrl,
+        handle: [publicUrl, api],
+        api,
+      },
+    },
+  };
+  const configs = [krasBaseConfig, krasRootConfig];
+  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 krasServer.start();
+  openBrowser(open, port, publicUrl, !!krasConfig.ssl);
+  await new Promise((resolve) => krasServer.on('close', resolve));
+}

package/src/apps/upgrade-pilet.ts

@@ -1,8 +1,7 @@
 import { resolve } from 'path';
 import { LogLevels, NpmClientType } from '../types';
 import {
-  readJson,
-  installPackage,
+  installNpmPackage,
   checkExistingDirectory,
   patchPiletPackage,
   copyPiralFiles,
@@ -10,7 +9,7 @@ import {
   readPiralPackage,
   getPiletsInfo,
   runScript,
-  installDependencies,
+  installNpmDependencies,
   getCurrentPackageDetails,
   checkAppShellPackage,
   setLogLevel,
@@ -22,9 +21,9 @@ import {
   ForceOverwrite,
   copyScaffoldingFiles,
   getPiralPath,
-  detectMonorepo,
-  bootstrapMonorepo,
   isMonorepoPackageRef,
+  getPiletScaffoldData,
+  retrievePiletData,
 } from '../common';
 
 export interface UpgradePiletOptions {
@@ -58,11 +57,16 @@ export interface UpgradePiletOptions {
   install?: boolean;
 
   /**
-   * Defines the used NPM client. By default, "npm" is used
+   * Defines the used npm client. By default, "npm" is used
    * if no other client is autodetected. The autodetection
-   * works against Lerna, PNPM, and Yarn.
+   * works against Lerna, pnpm, and Yarn.
    */
   npmClient?: NpmClientType;
+
+  /**
+   * Places additional variables that should used when scaffolding.
+   */
+  variables?: Record<string, string>;
 }
 
 export const upgradePiletDefaults: UpgradePiletOptions = {
@@ -72,6 +76,7 @@ export const upgradePiletDefaults: UpgradePiletOptions = {
   logLevel: LogLevels.info,
   install: true,
   npmClient: undefined,
+  variables: {},
 };
 
 export async function upgradePilet(baseDir = process.cwd(), options: UpgradePiletOptions = {}) {
@@ -81,21 +86,29 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     forceOverwrite = upgradePiletDefaults.forceOverwrite,
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
+    variables = upgradePiletDefaults.variables,
+    npmClient: defaultNpmClient = upgradePiletDefaults.npmClient,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
-  const root = resolve(baseDir, target);
   const valid = await checkExistingDirectory(root);
 
   if (!valid) {
     fail('invalidPiletTarget_0040');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
-  const pckg = await readJson(root, 'package.json');
-  const { devDependencies = {}, dependencies = {}, piral } = pckg;
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
+  const { apps, piletPackage } = await retrievePiletData(root);
+  const { devDependencies = {}, dependencies = {}, source } = piletPackage;
+
+  if (apps.length === 0) {
+    fail('appInstancesNotGiven_0012');
+  }
 
-  if (piral && typeof piral === 'object') {
-    const sourceName = piral.name;
+  for (const { appPackage } of apps) {
+    const sourceName = appPackage.name;
+    const language = /\.jsx?$/.test(source) ? 'js' : 'ts';
 
     if (!sourceName || typeof sourceName !== 'string') {
       fail('invalidPiletPackage_0042');
@@ -107,9 +120,9 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       fail('invalidPiralReference_0043');
     }
 
-    const monorepoRef = await isMonorepoPackageRef(sourceName, baseDir);
+    const monorepoRef = await isMonorepoPackageRef(sourceName, fullBase);
     const [packageRef, packageVersion] = await getCurrentPackageDetails(
-      baseDir,
+      fullBase,
       sourceName,
       currentVersion,
       version,
@@ -119,8 +132,8 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
 
     if (!monorepoRef) {
       // only install the latest if the shell does come from remote
-      progress(`Updating NPM package to %s ...`, packageRef);
-      await installPackage(npmClient, packageRef, root, '--no-save');
+      progress(`Updating npm package to %s ...`, packageRef);
+      await installNpmPackage(npmClient, packageRef, root, '--no-save');
     }
 
     const piralInfo = await readPiralPackage(root, sourceName);
@@ -136,29 +149,24 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     }
 
     progress(`Taking care of templating ...`);
+    const data = getPiletScaffoldData(language, root, sourceName, variables);
 
     if (isEmulator) {
       // in the emulator case we get the files from the contained tarball
-      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, originalFiles);
+      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, data, originalFiles);
     } 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, sourceName);
       const notOnceFiles = files.filter((m) => typeof m === 'string' || !m.once);
-      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo, data);
     }
 
-    await patchPiletPackage(root, sourceName, packageVersion, piralInfo);
+    await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);
 
     if (install) {
       progress(`Updating dependencies ...`);
-      const monorepoKind = await detectMonorepo(root);
-
-      if (monorepoKind === 'lerna') {
-        await bootstrapMonorepo(root);
-      } else {
-        await installDependencies(npmClient, root);
-      }
+      await installNpmDependencies(npmClient, root);
     }
 
     if (postUpgrade) {
@@ -166,9 +174,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       log('generalDebug_0003', `Run: ${postUpgrade}`);
       await runScript(postUpgrade, root);
     }
-
-    logDone('Pilet upgraded successfully!');
-  } else {
-    fail('invalidPiletPackage_0041');
   }
+
+  logDone('Pilet upgraded successfully!');
 }

package/src/apps/upgrade-piral.ts

@@ -3,7 +3,7 @@ import { LogLevels, NpmClientType } from '../types';
 import {
   readJson,
   checkExistingDirectory,
-  installDependencies,
+  installNpmDependencies,
   setLogLevel,
   progress,
   fail,
@@ -42,9 +42,9 @@ export interface UpgradePiralOptions {
   install?: boolean;
 
   /**
-   * Defines the used NPM client. By default, "npm" is used
+   * Defines the used npm client. By default, "npm" is used
    * if no other client is autodetected. The autodetection
-   * works against Lerna, PNPM, and Yarn.
+   * works against Lerna, pnpm, and Yarn.
    */
   npmClient?: NpmClientType;
 }
@@ -80,9 +80,11 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     target = upgradePiralDefaults.target,
     logLevel = upgradePiralDefaults.logLevel,
     install = upgradePiralDefaults.install,
+    npmClient: defaultNpmClient = upgradePiralDefaults.npmClient,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
-  const root = resolve(baseDir, target);
   const valid = await checkExistingDirectory(root);
   const exists = await checkExists(join(root, 'package.json'));
 
@@ -90,7 +92,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     fail('packageJsonNotFound_0020');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
 
   progress(`Checking provided version ...`);
   const realVersion = await findSpecificVersion('piral-cli', version);
@@ -111,8 +113,8 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
   await updateExistingJson(root, 'package.json', pckg);
 
   if (install) {
-    progress(`Updating the NPM packages to %s ...`, version);
-    await installDependencies(npmClient, root);
+    progress(`Updating the npm packages to %s ...`, version);
+    await installNpmDependencies(npmClient, root);
   }
 
   logDone('Piral instance upgraded successfully!');

package/src/apps/validate-pilet.ts

@@ -1,4 +1,4 @@
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { ruleSummary, runRules, retrievePiletData, getPiletsInfo, setLogLevel, progress, log } from '../common';
 import { getPiletRules } from '../rules';
 import { PiletRuleContext, LogLevels } from '../types';
@@ -32,11 +32,12 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     logLevel = validatePiletDefaults.logLevel,
     app = validatePiletDefaults.app,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
   const rules = await getPiletRules();
-  const entryFile = join(baseDir, entry);
+  const entryFile = join(fullBase, entry);
   const target = dirname(entryFile);
   const {
     dependencies,
@@ -44,31 +45,38 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     devDependencies,
     peerModules,
     root,
+    importmap,
+    apps,
+    piletPackage,
     ignored: _0,
-    emulator: _1,
-    ...data
   } = await retrievePiletData(target, app);
-  const { validators } = getPiletsInfo(data.appPackage);
+
   const errors: Array<string> = [];
   const warnings: Array<string> = [];
-  const context: PiletRuleContext = {
-    error(message) {
-      errors.push(log('generalError_0002', message));
-    },
-    warning(message) {
-      warnings.push(log('generalWarning_0001', message));
-    },
-    logLevel,
-    entry: entryFile,
-    dependencies,
-    devDependencies,
-    peerDependencies,
-    peerModules,
-    root,
-    data,
-  };
 
-  await runRules(rules, context, validators);
+  for (const { appPackage } of apps) {
+    const { validators } = getPiletsInfo(appPackage);
+    const context: PiletRuleContext = {
+      error(message) {
+        errors.push(log('generalError_0002', message));
+      },
+      warning(message) {
+        warnings.push(log('generalWarning_0001', message));
+      },
+      logLevel,
+      entry: entryFile,
+      dependencies,
+      devDependencies,
+      peerDependencies,
+      importmap,
+      peerModules,
+      root,
+      apps,
+      piletPackage,
+    };
+
+    await runRules(rules, context, validators);
+  }
 
   ruleSummary(errors, warnings);
 }

package/src/apps/validate-piral.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { retrievePiralRoot, retrievePiletsInfo, ruleSummary, runRules, config } from '../common';
 import { setLogLevel, progress, log, checkCliCompatibility } from '../common';
 import { getPiralRules } from '../rules';
@@ -22,12 +23,13 @@ export const validatePiralDefaults: ValidatPiralOptions = {
 
 export async function validatePiral(baseDir = process.cwd(), options: ValidatPiralOptions = {}) {
   const { entry = validatePiralDefaults.entry, logLevel = validatePiralDefaults.logLevel } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
   const rules = await getPiralRules();
-  const entryFiles = await retrievePiralRoot(baseDir, entry);
-  const { root, dependencies, ignored: _, ...info } = await retrievePiletsInfo(entryFiles);
+  const entryFiles = await retrievePiralRoot(fullBase, entry);
+  const { root, dependencies, ignored: _, externals, ...info } = await retrievePiletsInfo(entryFiles);
   const errors: Array<string> = [];
   const warnings: Array<string> = [];
 
@@ -41,6 +43,7 @@ export async function validatePiral(baseDir = process.cwd(), options: ValidatPir
       warnings.push(log('generalWarning_0001', message));
     },
     logLevel,
+    externals,
     entry: entryFiles,
     dependencies: dependencies.std,
     devDependencies: dependencies.dev,

package/src/build/bundler-calls.ts

@@ -0,0 +1,133 @@
+import { resolve } from 'path';
+import { fork, ChildProcess } from 'child_process';
+import type { Bundler, BundleDetails, BaseBundleParameters } from '../types';
+
+function getPath(name: string) {
+  return resolve(__dirname, '..', '..', 'lib', 'build', `run-${name}.js`);
+}
+
+type BundleListener = (args: any) => void;
+
+function createBundler(cwd: string, ps: ChildProcess, args: any) {
+  let promise = Promise.resolve();
+  let started = false;
+  const listeners: Array<BundleListener> = [];
+  const bundle: BundleDetails = {
+    dir: cwd,
+    hash: '',
+    name: '',
+  };
+  const setPending = () => {
+    promise = new Promise((done) => {
+      const f = () => {
+        done();
+        bundler.off(f);
+      };
+      bundler.on(f);
+    });
+  };
+  const bundler = {
+    bundle,
+    start() {
+      if (!started) {
+        started = true;
+        ps.send({
+          type: 'bundle',
+          ...args,
+        });
+      }
+    },
+    on(cb: BundleListener) {
+      listeners.push(cb);
+    },
+    off(cb: BundleListener) {
+      listeners.splice(listeners.indexOf(cb), 1);
+    },
+    emit(args: any) {
+      [...listeners].forEach((cb) => cb(args));
+    },
+    ready() {
+      return promise;
+    },
+    setPending,
+  };
+  setPending();
+  return bundler;
+}
+
+export function callDynamic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+  const cwd = args.root;
+  return new Promise<Bundler>((resolve, reject) => {
+    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    ps.stderr && process.stderr && ps.stderr.pipe(process.stderr, { end: false });
+    ps.stdout && process.stdout && ps.stdout.pipe(process.stdout, { end: false });
+    ps.stdin && process.stdin && ps.stdin.pipe(process.stdin, { end: false });
+
+    ps.on('message', (msg: any) => {
+      switch (msg.type) {
+        case 'pending':
+          bundler.setPending();
+          break;
+        case 'update':
+          bundler.bundle.hash = msg.outHash;
+          bundler.bundle.name = msg.outName;
+          bundler.emit(msg.args);
+          break;
+        case 'done':
+          bundler.bundle.dir = msg.outDir;
+          return resolve(bundler);
+        case 'fail':
+          return reject(msg.error);
+      }
+    });
+
+    ps.send(setup, start);
+  });
+}
+
+export function callStatic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+  const cwd = args.root;
+  return new Promise<Bundler>((resolve, reject) => {
+    const ps = fork(getPath(name), [], { cwd, stdio: 'pipe', env: process.env });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    ps.stderr && process.stderr && ps.stderr.pipe(process.stderr, { end: false });
+    ps.stdout && process.stdout && ps.stdout.pipe(process.stdout, { end: false });
+    ps.stdin && process.stdin && ps.stdin.pipe(process.stdin, { end: false });
+
+    ps.on('message', (msg: any) => {
+      switch (msg.type) {
+        case 'done':
+          bundler.bundle.dir = msg.outDir;
+          bundler.bundle.name = msg.outFile;
+          return resolve(bundler);
+        case 'fail':
+          return reject(msg.error);
+      }
+    });
+
+    ps.send(setup, start);
+  });
+}