piral-cli 0.13.8 → 0.14.0-beta.3156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "piral-cli",
-  "version": "0.13.8",
+  "version": "0.14.0-beta.3156",
   "description": "The standard CLI for creating and building a Piral instance or a Pilet.",
   "keywords": [
     "portal",
@@ -70,12 +70,12 @@
   },
   "dependencies": {
     "chalk": "^2.4.2",
-    "dets": "^0.10.1",
+    "dets": "^0.10.2",
     "ejs": "^2.6.2",
     "kras": "^0.12.2",
     "rimraf": "^3.0.0",
     "typescript": "^4.0.2",
     "yargs": "^15.4.1"
   },
-  "gitHead": "26a9a75314886ad9d81ff9d17b5d05296af3d04f"
+  "gitHead": "e368a181defdfca4722d7bd478a9dcd47d90a51b"
 }

package/src/apps/build-pilet.ts

@@ -12,6 +12,7 @@ import {
   ForceOverwrite,
   matchAnyPilet,
   fail,
+  config,
 } from '../common';
 
 export interface BuildPiletOptions {
@@ -93,7 +94,7 @@ export const buildPiletDefaults: BuildPiletOptions = {
   sourceMaps: true,
   contentHash: true,
   optimizeModules: false,
-  schemaVersion: 'v1',
+  schemaVersion: config.schemaVersion,
   declaration: true,
 };
 
@@ -113,9 +114,10 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
     bundlerName,
     app,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  const allEntries = await matchAnyPilet(baseDir, [entry]);
+  const allEntries = await matchAnyPilet(fullBase, [entry]);
 
   if (allEntries.length === 0) {
     fail('entryFileMissing_0077');
@@ -123,12 +125,12 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
 
   const entryModule = allEntries.shift();
   const targetDir = dirname(entryModule);
-  const { peerDependencies, peerModules, root, appPackage, piletPackage, ignored } = await retrievePiletData(
+  const { peerDependencies, peerModules, root, appPackage, piletPackage, ignored, importmap } = await retrievePiletData(
     targetDir,
     app,
   );
   const externals = [...Object.keys(peerDependencies), ...peerModules];
-  const outDir = dirname(resolve(baseDir, target));
+  const outDir = dirname(resolve(fullBase, target));
 
   if (fresh) {
     progress('Removing output directory ...');
@@ -147,6 +149,7 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
       minify,
       externals,
       targetDir,
+      importmap,
       outFile: basename(target),
       outDir,
       entryModule: `./${relative(root, entryModule)}`,

package/src/apps/build-piral.ts

@@ -151,12 +151,13 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     _ = {},
     bundlerName,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const useSubdir = type === 'all' || subdir;
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  const useSubdir = type === 'all' || subdir;
-  const entryFiles = await retrievePiralRoot(baseDir, entry);
+  const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { name, root, ignored, externals, scripts } = await retrievePiletsInfo(entryFiles);
-  const dest = getDestination(entryFiles, resolve(baseDir, target));
+  const dest = getDestination(entryFiles, resolve(fullBase, target));
 
   await checkCliCompatibility(root);
 
@@ -202,9 +203,9 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
 
     if (type !== emulatorSourcesName) {
       await packageEmulator(rootDir);
-      logDone(`Emulator sources available in "${rootDir}".`);
-    } else {
       logDone(`Emulator package available in "${rootDir}".`);
+    } else {
+      logDone(`Emulator sources available in "${rootDir}".`);
     }
 
     logReset();

package/src/apps/debug-pilet.ts

@@ -82,7 +82,7 @@ export const debugPiletDefaults: DebugPiletOptions = {
   port: 1234,
   hmr: true,
   optimizeModules: false,
-  schemaVersion: 'v1',
+  schemaVersion: config.schemaVersion,
 };
 
 const injectorName = resolve(__dirname, '../injectors/pilet.js');
@@ -168,7 +168,7 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
   const pilets = await Promise.all(
     allEntries.map(async (entryModule) => {
       const targetDir = dirname(entryModule);
-      const { peerDependencies, peerModules, root, appPackage, appFile, ignored, emulator } = await retrievePiletData(
+      const { peerDependencies, peerModules, root, appPackage, appFile, ignored, emulator, importmap } = await retrievePiletData(
         targetDir,
         app,
       );
@@ -192,6 +192,7 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
           hmr,
           externals,
           targetDir,
+          importmap,
           entryModule: `./${relative(root, entryModule)}`,
           logLevel,
           version: schemaVersion,

package/src/apps/debug-piral.ts

@@ -86,9 +86,10 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     _ = {},
     bundlerName,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  const entryFiles = await retrievePiralRoot(baseDir, entry);
+  const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
   const krasConfig = readKrasConfig({ port }, krasrc);
 

package/src/apps/declaration-piral.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { setLogLevel, logDone, createPiralDeclaration, ForceOverwrite } from '../common';
 import { LogLevels } from '../types';
 
@@ -37,7 +38,8 @@ export async function declarationPiral(baseDir = process.cwd(), options: Declara
     forceOverwrite = declarationPiralDefaults.forceOverwrite,
     logLevel = declarationPiralDefaults.logLevel,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
-  await createPiralDeclaration(baseDir, entry, target, forceOverwrite, logLevel);
+  await createPiralDeclaration(fullBase, entry, target, forceOverwrite, logLevel);
   logDone(`Declaration created successfully in "${target}"!`);
 }

package/src/apps/new-pilet.ts

@@ -120,10 +120,11 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
     bundlerName = newPiletDefaults.bundlerName,
     variables = newPiletDefaults.variables,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
-  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, source);
+  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(fullBase, source);
   const success = await createDirectory(root);
 
   if (success) {
@@ -204,7 +205,10 @@ always-auth=true`,
       await copyScaffoldingFiles(packageRoot, root, files, piralInfo);
     }
 
-    await patchPiletPackage(root, packageName, packageVersion, piralInfo, { language, bundler: bundlerName });
+    await patchPiletPackage(root, packageName, packageVersion, piralInfo, isEmulator, {
+      language,
+      bundler: bundlerName,
+    });
 
     if (install) {
       progress(`Installing dependencies ...`);

package/src/apps/new-piral.ts

@@ -118,9 +118,10 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
     bundlerName = newPiralDefaults.bundlerName,
     variables = newPiralDefaults.variables,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
   const success = await createDirectory(root);
 
   if (success) {

package/src/apps/pack-pilet.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { createPiletPackage, logDone, setLogLevel, progress } from '../common';
 import { LogLevels } from '../types';
 
@@ -30,8 +31,9 @@ export async function packPilet(baseDir = process.cwd(), options: PackPiletOptio
     target = packPiletDefaults.target,
     logLevel = packPiletDefaults.logLevel,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  await createPiletPackage(baseDir, source, target);
+  await createPiletPackage(fullBase, source, target);
   logDone(`Pilet packed successfully!`);
 }

package/src/apps/publish-pilet.ts

@@ -1,4 +1,4 @@
-import { relative, join, dirname, basename } from 'path';
+import { relative, join, dirname, basename, resolve } from 'path';
 import { buildPilet } from './build-pilet';
 import { LogLevels, PiletSchemaVersion, PiletPublishSource } from '../types';
 import {
@@ -76,7 +76,7 @@ export const publishPiletDefaults: PublishPiletOptions = {
   fresh: false,
   cert: undefined,
   logLevel: LogLevels.info,
-  schemaVersion: 'v1',
+  schemaVersion: config.schemaVersion,
   from: 'local',
   fields: {},
 };
@@ -134,6 +134,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     cert = config.cert ?? publishPiletDefaults.cert,
     fields = publishPiletDefaults.fields,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
@@ -152,7 +153,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
   }
 
   log('generalDebug_0003', 'Getting the tgz files ...');
-  const files = await getFiles(baseDir, source, from, fresh, schemaVersion, ca);
+  const files = await getFiles(fullBase, source, from, fresh, schemaVersion, ca);
   const successfulUploads: Array<string> = [];
   log('generalDebug_0003', 'Received available tgz files.');
 
@@ -164,8 +165,8 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
 
   for (const file of files) {
     log('generalDebug_0003', 'Reading the file for upload ...');
-    const fileName = relative(baseDir, file);
-    const content = await readBinary(baseDir, fileName);
+    const fileName = relative(fullBase, file);
+    const content = await readBinary(fullBase, fileName);
 
     if (content) {
       progress(`Publishing "%s" ...`, file, url);

package/src/apps/publish-piral.ts

@@ -87,6 +87,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     fields = publishPiralDefaults.fields,
     provider = publishPiralDefaults.provider,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
 
   if (type === 'emulator-sources') {
@@ -97,14 +98,14 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
 
   if (type !== 'release') {
     progress('Publishing emulator package ...');
-    await publishEmulator(baseDir, source, fields);
+    await publishEmulator(fullBase, source, fields);
     logDone(`Successfully published emulator.`);
     logReset();
   }
 
   if (type !== 'emulator') {
     progress('Publishing release files ...');
-    await publishRelease(baseDir, source, provider, fields);
+    await publishRelease(fullBase, source, provider, fields);
     logDone(`Successfully published release.`);
     logReset();
   }

package/src/apps/upgrade-pilet.ts

@@ -82,8 +82,9 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
   } = 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) {
@@ -107,9 +108,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,
@@ -148,7 +149,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo);
     }
 
-    await patchPiletPackage(root, sourceName, packageVersion, piralInfo);
+    await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);
 
     if (install) {
       progress(`Updating dependencies ...`);

package/src/apps/upgrade-piral.ts

@@ -81,8 +81,9 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     logLevel = upgradePiralDefaults.logLevel,
     install = upgradePiralDefaults.install,
   } = 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'));
 

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,6 +45,7 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     devDependencies,
     peerModules,
     root,
+    importmap,
     ignored: _0,
     emulator: _1,
     ...data
@@ -63,6 +65,7 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     dependencies,
     devDependencies,
     peerDependencies,
+    importmap,
     peerModules,
     root,
     data,

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,11 +23,12 @@ 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 entryFiles = await retrievePiralRoot(fullBase, entry);
   const { root, dependencies, ignored: _, ...info } = await retrievePiletsInfo(entryFiles);
   const errors: Array<string> = [];
   const warnings: Array<string> = [];

package/src/build/bundler-calls.ts

@@ -0,0 +1,121 @@
+import { resolve } from 'path';
+import { fork, ChildProcess } from 'child_process';
+import { 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();
+  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() {
+      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 });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    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 });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    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);
+  });
+}

package/src/build/run-build-pilet.ts

@@ -0,0 +1,89 @@
+import type { PiletSchemaVersion, LogLevels, SharedDependency, PiletBuildHandler } from '../types';
+import { setStandardEnvs } from '../common';
+
+let handler: PiletBuildHandler;
+
+function run(
+  root: string,
+  piral: string,
+  sourceMaps: boolean,
+  contentHash: boolean,
+  minify: boolean,
+  externals: Array<string>,
+  importmap: Array<SharedDependency>,
+  targetDir: string,
+  outDir: string,
+  outFile: string,
+  entryModule: string,
+  version: PiletSchemaVersion,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: true,
+    piral,
+    root,
+  });
+
+  return handler.create({
+    root,
+    piral,
+    entryModule,
+    targetDir,
+    outDir,
+    outFile,
+    externals,
+    importmap,
+    version,
+    develop: false,
+    sourceMaps,
+    contentHash,
+    minify,
+    logLevel,
+    watch: false,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piral,
+          msg.sourceMaps,
+          msg.contentHash,
+          msg.minify,
+          msg.externals,
+          msg.importmap,
+          msg.targetDir,
+          msg.outDir,
+          msg.outFile,
+          msg.entryModule,
+          msg.version,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        if (result) {
+          process.send({
+            type: 'done',
+            outDir: result.outDir,
+            outFile: result.outFile,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});

package/src/build/run-build-piral.ts

@@ -0,0 +1,88 @@
+import type { PiralBuildHandler, LogLevels } from '../types';
+import { setStandardEnvs } from '../common';
+
+let handler: PiralBuildHandler;
+
+function run(
+  root: string,
+  piral: string,
+  emulator: boolean,
+  sourceMaps: boolean,
+  contentHash: boolean,
+  minify: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  outFile: string,
+  outDir: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: !emulator,
+    root,
+    debugPiral: emulator,
+    debugPilet: emulator,
+    piral,
+    dependencies: externals,
+  });
+
+  return handler.create({
+    root,
+    entryFiles,
+    outFile,
+    outDir,
+    externals,
+    emulator,
+    sourceMaps,
+    contentHash,
+    minify,
+    publicUrl,
+    hmr: false,
+    logLevel,
+    watch: false,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piral,
+          msg.emulator,
+          msg.sourceMaps,
+          msg.contentHash,
+          msg.minify,
+          msg.externals,
+          msg.publicUrl,
+          msg.outFile,
+          msg.outDir,
+          msg.entryFiles,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        if (result) {
+          process.send({
+            type: 'done',
+            outDir: result.outDir,
+            outFile: result.outFile,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});