piral-cli 1.4.0-beta.6247 → 1.4.0-beta.6252

package/src/apps/upgrade-pilet.ts

@@ -107,6 +107,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
   }
 
   for (const { appPackage } of apps) {
+    //TODO distinguish if it's a website / remote emulator or an npm package
     const sourceName = appPackage.name;
     const language = /\.jsx?$/.test(source) ? 'js' : 'ts';
 
@@ -121,7 +122,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     }
 
     const monorepoRef = await isMonorepoPackageRef(sourceName, fullBase);
-    const [packageRef, packageVersion] = await getCurrentPackageDetails(
+    const [packageRef] = await getCurrentPackageDetails(
       fullBase,
       sourceName,
       currentVersion,
@@ -162,7 +163,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo, data);
     }
 
-    await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);
+    await patchPiletPackage(root, piralInfo, isEmulator);
 
     if (install) {
       progress(`Updating dependencies ...`);

package/src/common/package.ts

@@ -11,11 +11,11 @@ import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, tryResolvePackage, isNpmPackage } from './npm';
 import { makePiletExternals, makeExternals, findPackageRoot, findSpecificVersion, makeNpmAlias } from './npm';
-import { scaffoldFromEmulatorWebsite } from './website';
+import { scaffoldFromEmulatorWebsite, updateFromEmulatorWebsite } from './website';
 import { getDependencies, getDependencyPackages, getDevDependencies } from './language';
 import { getDevDependencyPackages, getFrameworkDependencies } from './language';
-import { piralJsonSchemaUrl, piletJsonSchemaUrl, filesTar, filesOnceTar, bundlerNames } from './constants';
-import { frameworkLibs, declarationEntryExtensions, piralJson, piletJson, packageJson } from './constants';
+import { piralJsonSchemaUrl, filesTar, filesOnceTar, bundlerNames, packageJson } from './constants';
+import { frameworkLibs, declarationEntryExtensions, piralJson, piletJson } from './constants';
 import { getModulePath } from '../external';
 import { PiletsInfo, SharedDependency, PiletDefinition, AppDefinition } from '../types';
 import { SourceLanguage, PiralInstancePackageData, PiralInstanceDetails } from '../types';
@@ -156,12 +156,19 @@ export async function findPiralInstance(
 
   if (path) {
     log('generalDebug_0003', `Following the app package in "${path}" ...`);
+    const url = details?.url;
     const root = dirname(path);
     const appPackage = await readJson(root, basename(path));
-    const relPath = appPackage && appPackage.app;
+    const relPath = appPackage.app;
     appPackage.app = relPath && resolve(root, relPath);
     appPackage.root = root;
     appPackage.port = details?.port || 0;
+
+    if (url) {
+      log('generalDebug_0003', `Updating the emulator from remote "${url}" ...`);
+      await updateFromEmulatorWebsite(root, url);
+    }
+
     return appPackage;
   } else if (details?.url) {
     const { url, ...rest } = details;
@@ -216,11 +223,11 @@ export async function patchPiralPackage(
   version: string,
   bundler?: string,
 ) {
-  log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
+  log('generalDebug_0003', `Patching the ${packageJson} in "${root}" ...`);
   const pkg = await getPiralPackage(app, data, version, bundler);
 
-  await updateExistingJson(root, 'package.json', pkg);
-  log('generalDebug_0003', `Succesfully patched the package.json.`);
+  await updateExistingJson(root, packageJson, pkg);
+  log('generalDebug_0003', `Succesfully patched the ${packageJson}.`);
 
   await updateExistingJson(root, piralJson, {
     $schema: piralJsonSchemaUrl,
@@ -353,7 +360,7 @@ export async function copyScaffoldingFiles(
 }
 
 async function extendPackageOverridesFromTemplateFragment(root: string, piralInfo: any, files: Array<FileDescriptor>) {
-  const packageTarget = resolve(root, 'package.json');
+  const packageTarget = resolve(root, packageJson);
 
   for (let i = files.length; i--; ) {
     const file = files[i];
@@ -384,7 +391,7 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
 
 function tryFindPackageVersion(packageName: string): string {
   try {
-    const { version } = require(`${packageName}/package.json`);
+    const { version } = require(`${packageName}/${packageJson}`);
     return version;
   } catch {
     return undefined;
@@ -447,7 +454,7 @@ export async function retrievePiralRoot(baseDir: string, entry: string) {
   log('generalDebug_0003', `Retrieving Piral root from "${rootDir}" ...`);
 
   if (!declarationEntryExtensions.includes(extname(rootDir).toLowerCase())) {
-    const packageName = basename(rootDir) === 'package.json' ? rootDir : join(rootDir, 'package.json');
+    const packageName = basename(rootDir) === packageJson ? rootDir : join(rootDir, packageJson);
     log('generalDebug_0003', `Trying to get entry point from "${packageName}".`);
     const exists = await checkExists(packageName);
 
@@ -527,9 +534,9 @@ export async function findPackageVersion(rootPath: string, packageName: string |
     try {
       log('generalDebug_0003', `Finding the version of "${packageName}" in "${rootPath}".`);
       const moduleName = getModulePath(rootPath, pckg);
-      const packageJson = await findFile(moduleName, 'package.json');
-      const root = dirname(packageJson);
-      const { version } = await readJson(root, 'package.json');
+      const packageJsonPath = await findFile(moduleName, packageJson);
+      const root = dirname(packageJsonPath);
+      const { version } = await readJson(root, packageJson);
       return version;
     } catch {}
   }
@@ -635,31 +642,18 @@ export function isValidDependency(name: string) {
 
 export async function patchPiletPackage(
   root: string,
-  name: string,
-  version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
-  newInfo?: { language: SourceLanguage; bundler: string; details: PiralInstanceDetails },
+  newInfo?: { language: SourceLanguage; bundler: string },
 ) {
-  log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
-  const pkg = await getPiletPackage(root, name, version, piralInfo, fromEmulator, newInfo);
-
+  log('generalDebug_0003', `Patching the ${packageJson} in "${root}" ...`);
+  const pkg = await getPiletPackage(root, piralInfo, fromEmulator, newInfo);
   await updateExistingJson(root, packageJson, pkg);
-  log('generalDebug_0003', `Succesfully patched the package.json.`);
-
-  await updateExistingJson(root, piletJson, {
-    $schema: piletJsonSchemaUrl,
-    piralInstances: {
-      [name]: newInfo?.details || {},
-    },
-  });
-  log('generalDebug_0003', `Succesfully patched the pilet.json.`);
+  log('generalDebug_0003', `Succesfully patched the ${packageJson}.`);
 }
 
 async function getPiletPackage(
   root: string,
-  name: string,
-  version: string,
   piralInfo: PiralPackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
@@ -701,11 +695,9 @@ async function getPiletPackage(
 
       return deps;
     }, {}),
-    [name]: `${version || piralInfo.version}`,
     ['piral-cli']: toolVersion,
   };
   const dependencies: Record<string, string> = {
-    [name]: undefined,
     ['piral-cli']: undefined,
   };
 
@@ -716,7 +708,7 @@ async function getPiletPackage(
   return deepMerge(packageOverrides, {
     importmap: {
       imports: {},
-      inherit: [name],
+      inherit: [],
     },
     devDependencies,
     dependencies,
@@ -768,20 +760,20 @@ export function combinePiletExternals(
 }
 
 export async function findPiletRoot(proposedRoot: string) {
-  const packageJson = await findFile(proposedRoot, 'package.json');
+  const packageJsonPath = await findFile(proposedRoot, packageJson);
 
-  if (!packageJson) {
+  if (!packageJsonPath) {
     fail('packageJsonMissing_0075');
   }
 
-  return dirname(packageJson);
+  return dirname(packageJsonPath);
 }
 
 export async function retrievePiletData(target: string, app?: string) {
   const piletJsonPath = await findFile(target, piletJson);
   const proposedRoot = piletJsonPath ? dirname(piletJsonPath) : target;
   const root = await findPiletRoot(proposedRoot);
-  const piletPackage = await readJson(root, 'package.json');
+  const piletPackage = await readJson(root, packageJson);
   const piletDefinition: PiletDefinition = piletJsonPath && (await readJson(proposedRoot, piletJson));
   const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root);
   const apps: Array<AppDefinition> = [];

package/src/common/shell.ts

@@ -1,35 +1,76 @@
 import { progress } from './log';
+import { packageJson, piletJson } from './constants';
+import { readJson, updateExistingJson, writeJson } from './io';
 import { scaffoldFromEmulatorWebsite } from './website';
 import { combinePackageRef, getPackageName, getPackageVersion } from './npm';
 import { dissectPackageName, installNpmPackage, isLinkedPackage } from './npm';
-import { NpmClientType, PiralInstanceDetails } from '../types';
+import { NpmClientType, PackageType, PiralInstanceDetails } from '../types';
+
+async function updatePiletJson(target: string, appName: string, appDetails: PiralInstanceDetails) {
+  const oldContent = await readJson(target, piletJson);
+  const newContent = {
+    ...oldContent,
+    piralInstances: {
+      ...oldContent.piralInstances,
+      [appName]: appDetails,
+    },
+  };
+  await writeJson(target, piletJson, newContent, true);
+  await updateExistingJson(target, packageJson, {
+    importmap: {
+      inherit: [appName],
+    },
+  });
+}
+
+async function setupPiralInstance(
+  sourceName: string,
+  type: PackageType,
+  hadVersion: boolean,
+  rootDir: string,
+  sourceVersion: string,
+  npmClient: NpmClientType,
+) {
+  if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
+    const packageRef = combinePackageRef(sourceName, sourceVersion, type);
+
+    progress(`Installing npm package %s ...`, packageRef);
+    await installNpmPackage(npmClient, packageRef, rootDir, '--save-dev', '--save-exact');
+    return await getPackageName(rootDir, sourceName, type);
+  } else {
+    progress(`Using locally available npm package %s ...`, sourceName);
+    const packageName = await getPackageName(rootDir, sourceName, type);
+    const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
+    await updateExistingJson(rootDir, packageJson, {
+      devDependencies: {
+        [packageName]: packageVersion,
+      },
+    });
+    return packageName;
+  }
+}
 
 export async function installPiralInstance(
   usedSource: string,
   baseDir: string,
   rootDir: string,
   npmClient: NpmClientType,
-): Promise<[name: string, version: string, details: PiralInstanceDetails]> {
+  selected?: boolean,
+): Promise<string> {
   const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
 
   if (type === 'remote') {
-    progress(`Downloading emulator from %s ...`, sourceName);
-    const emulatorJson = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
-    const details = {
+    const packageName = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
+    await updatePiletJson(rootDir, packageName, {
+      selected,
       url: sourceName,
-    };
-
-    return [emulatorJson.name, emulatorJson.version, details];
-  } else if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
-    const packageRef = combinePackageRef(sourceName, sourceVersion, type);
-
-    progress(`Installing npm package %s ...`, packageRef);
-    await installNpmPackage(npmClient, packageRef, rootDir, '--save-dev', '--save-exact');
+    });
+    return packageName;
   } else {
-    progress(`Using locally available npm package %s ...`, sourceName);
+    const packageName = await setupPiralInstance(sourceName, type, hadVersion, rootDir, sourceVersion, npmClient);
+    await updatePiletJson(rootDir, packageName, {
+      selected,
+    });
+    return packageName;
   }
-
-  const packageName = await getPackageName(rootDir, sourceName, type);
-  const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
-  return [packageName, packageVersion, {}];
 }

package/src/common/website.ts

@@ -1,10 +1,10 @@
-import { resolve as resolveUrl } from 'url';
-import { join, resolve } from 'path';
+import { join, relative, resolve } from 'path';
 import { createPiralStubIndexIfNotExists } from './template';
 import { packageJson } from './constants';
 import { ForceOverwrite } from './enums';
-import { createDirectory, writeBinary } from './io';
+import { createDirectory, readJson, writeBinary } from './io';
 import { writeJson } from './io';
+import { progress, log } from './log';
 import { axios } from '../external';
 import { EmulatorWebsiteManifestFiles, EmulatorWebsiteManifest } from '../types';
 
@@ -13,22 +13,22 @@ async function downloadEmulatorFiles(manifestUrl: string, target: string, files:
 
   await Promise.all(
     requiredFiles.map(async (file) => {
-      const res = await axios.default.get(resolveUrl(manifestUrl, file), { responseType: 'arraybuffer' });
+      const url = new URL(file, manifestUrl);
+      const res = await axios.default.get(url.href, { responseType: 'arraybuffer' });
       const data: Buffer = res.data;
       await writeBinary(target, file, data);
     }),
   );
 }
 
-export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string) {
-  const response = await axios.default.get(manifestUrl);
-  const emulatorJson: EmulatorWebsiteManifest = response.data;
-
-  const targetDir = resolve(rootDir, 'node_modules', emulatorJson.name);
-  const appDirName = 'app';
+async function createEmulatorFiles(
+  targetDir: string,
+  appDir: string,
+  manifestUrl: string,
+  emulatorJson: EmulatorWebsiteManifest,
+) {
   const mainFile = 'index.js';
-  const appDir = resolve(targetDir, appDirName);
-  await createDirectory(appDir);
+  const appDirName = relative(targetDir, appDir);
 
   await writeJson(
     targetDir,
@@ -45,10 +45,10 @@ export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl:
         source: manifestUrl,
         generated: true,
       },
-      files: emulatorJson.files,
-      main: `./${join(appDirName, mainFile)}`,
-      typings: `./${join(appDirName, emulatorJson.files.typings)}`,
-      app: `./${join(appDirName, emulatorJson.files.app)}`,
+      files: emulatorJson.files.assets,
+      main: join(appDirName, mainFile),
+      typings: join(appDirName, emulatorJson.files.typings),
+      app: join(appDirName, emulatorJson.files.app),
       peerDependencies: {},
       optionalDependencies: emulatorJson.dependencies.optional,
       devDependencies: emulatorJson.dependencies.included,
@@ -63,5 +63,35 @@ export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl:
   });
 
   await downloadEmulatorFiles(manifestUrl, appDir, emulatorJson.files);
-  return emulatorJson;
+}
+
+export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl: string) {
+  progress(`Updating emulator from %s ...`, manifestUrl);
+
+  try {
+    const response = await axios.default.get(manifestUrl);
+    const nextEmulator: EmulatorWebsiteManifest = response.data;
+    const currentEmulator = await readJson(targetDir, packageJson);
+
+    if (currentEmulator.name !== nextEmulator.name) {
+      log('remoteEmulatorNameChanged_0121', currentEmulator.name);
+    } else if (currentEmulator.piralCLI.timstamp !== nextEmulator.timestamp) {
+      const appDir = resolve(targetDir, 'app');
+      await createEmulatorFiles(targetDir, appDir, manifestUrl, nextEmulator);
+    }
+  } catch (ex) {
+    log('generalDebug_0003', `HTTP request for emulator update failed: ${ex}`);
+    log('skipEmulatorUpdate_0120', manifestUrl);
+  }
+}
+
+export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string) {
+  progress(`Downloading emulator from %s ...`, manifestUrl);
+  const response = await axios.default.get(manifestUrl);
+  const emulatorJson: EmulatorWebsiteManifest = response.data;
+  const targetDir = resolve(rootDir, 'node_modules', emulatorJson.name);
+  const appDir = resolve(targetDir, 'app');
+  await createDirectory(appDir);
+  await createEmulatorFiles(targetDir, appDir, manifestUrl, emulatorJson);
+  return emulatorJson.name;
 }

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

@@ -40,7 +40,7 @@ describe('Piral-CLI pilet injector', () => {
     expect(injector.active).toBeFalsy();
   });
 
-  it('PiletInjector does not send empty content', () => {
+  it('PiletInjector does not send empty content', async () => {
     // Arrange
     const core = new EventEmitter();
     const injector = new PiletInjector(optionsMock, configMock, core);
@@ -51,7 +51,7 @@ describe('Piral-CLI pilet injector', () => {
 
     // Act
     try {
-      injector.sendFile(target, url); // this file does not exist
+      await injector.sendFile(target, url); // this file does not exist
     } catch {
       hasFailed = true;
     }
@@ -113,7 +113,7 @@ describe('Piral-CLI pilet injector', () => {
     expect(res).toBeUndefined();
   });
 
-  it('PiletInjector wont crash on request with no target', () => {
+  it('PiletInjector wont crash on request with no target', async () => {
     // Arrange
     const optionsMock = {
       pilets: [],
@@ -136,7 +136,7 @@ describe('Piral-CLI pilet injector', () => {
     } as KrasRequest;
 
     // Act
-    const res = injector.handle(request);
+    const res = await injector.handle(request);
 
     // Assert
     expect(res).toBeUndefined();