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

package/src/common/package.ts

@@ -14,8 +14,8 @@ import { makePiletExternals, makeExternals, findPackageRoot, findSpecificVersion
 import { scaffoldFromEmulatorWebsite } 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';
@@ -216,11 +216,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 +353,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 +384,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 +447,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 +527,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 +635,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 +688,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 +701,7 @@ async function getPiletPackage(
   return deepMerge(packageOverrides, {
     importmap: {
       imports: {},
-      inherit: [name],
+      inherit: [],
     },
     devDependencies,
     dependencies,
@@ -768,20 +753,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 { createPiralStubIndexIfNotExists } from './template';
 import { packageJson } from './constants';
 import { ForceOverwrite } from './enums';
 import { createDirectory, writeBinary } from './io';
 import { writeJson } from './io';
+import { progress } from './log';
 import { axios } from '../external';
 import { EmulatorWebsiteManifestFiles, EmulatorWebsiteManifest } from '../types';
 
@@ -13,7 +13,8 @@ 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);
     }),
@@ -21,6 +22,7 @@ async function downloadEmulatorFiles(manifestUrl: string, target: string, files:
 }
 
 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;
 
@@ -45,7 +47,7 @@ export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl:
         source: manifestUrl,
         generated: true,
       },
-      files: emulatorJson.files,
+      files: emulatorJson.files.assets,
       main: `./${join(appDirName, mainFile)}`,
       typings: `./${join(appDirName, emulatorJson.files.typings)}`,
       app: `./${join(appDirName, emulatorJson.files.app)}`,
@@ -63,5 +65,5 @@ export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl:
   });
 
   await downloadEmulatorFiles(manifestUrl, appDir, emulatorJson.files);
-  return 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();

package/src/injectors/pilet-injector.ts

@@ -1,20 +1,14 @@
 import { URL } from 'url';
 import { join } from 'path';
 import { EventEmitter } from 'events';
-import { readFileSync, existsSync, statSync } from 'fs';
-import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
+import { readFile, stat, writeFile } from 'fs/promises';
+import { KrasInjector, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
 import { log } from '../common/log';
 import { getPiletSpecMeta } from '../common/spec';
 import { config as commonConfig } from '../common/config';
 import { axios, mime, jju } from '../external';
 import { Bundler } from '../types';
 
-interface Pilet {
-  bundler: Bundler;
-  root: string;
-  getMeta(basePath: string): PiletMetadata;
-}
-
 export interface PiletInjectorConfig extends KrasInjectorConfig {
   /**
    * The pilets to serve.
@@ -54,31 +48,43 @@ export interface PiletInjectorConfig extends KrasInjectorConfig {
   headers?: Record<string, string>;
 }
 
+interface Pilet {
+  bundler: Bundler;
+  root: string;
+  getMeta(basePath: string): PiletMetadata;
+}
+
 interface PiletMetadata {
   name?: string;
   config?: Record<string, any>;
   [key: string]: unknown;
 }
 
-function getMetaOverride(root: string, metaFile: string) {
+async function getMetaOverride(root: string, metaFile: string) {
   if (metaFile) {
     const metaPath = join(root, metaFile);
+    const exists = await stat(metaPath).then(
+      () => true,
+      () => false,
+    );
 
-    if (existsSync(metaPath)) {
-      return jju.parse(readFileSync(metaPath, 'utf8'));
+    if (exists) {
+      const metaContent = await readFile(metaPath, 'utf8');
+      return jju.parse(metaContent);
     }
   }
 
   return undefined;
 }
 
-function fillPiletMeta(pilet: Pilet, metaFile: string, subPath: string) {
+async function fillPiletMeta(pilet: Pilet, metaFile: string, subPath: string) {
   const { root, bundler } = pilet;
   const packagePath = join(root, 'package.json');
-  const def = jju.parse(readFileSync(packagePath, 'utf8'));
+  const jsonContent = await readFile(packagePath, 'utf8');
+  const def = jju.parse(jsonContent);
   const file = bundler.bundle.name.replace(/^[\/\\]/, '');
   const target = join(bundler.bundle.dir, file);
-  const metaOverride = getMetaOverride(root, metaFile);
+  const metaOverride = await getMetaOverride(root, metaFile);
 
   pilet.getMeta = (parentPath) => {
     const basePath = `${parentPath}${subPath}`;
@@ -96,11 +102,11 @@ function fillPiletMeta(pilet: Pilet, metaFile: string, subPath: string) {
   };
 }
 
+type FeedResponse = { items?: Array<PiletMetadata> } | Array<PiletMetadata> | PiletMetadata;
+
 async function loadFeed(feed: string) {
   try {
-    const response = await axios.default.get<{ items?: Array<PiletMetadata> } | Array<PiletMetadata> | PiletMetadata>(
-      feed,
-    );
+    const response = await axios.default.get<FeedResponse>(feed);
 
     if (Array.isArray(response.data)) {
       return response.data;
@@ -118,16 +124,33 @@ export default class PiletInjector implements KrasInjector {
   public config: PiletInjectorConfig;
   private serverConfig: KrasConfiguration;
   private indexPath: string;
+  private proxyInfo?: {
+    source: string;
+    files: Array<string>;
+    date: Date;
+  };
 
   constructor(config: PiletInjectorConfig, serverConfig: KrasConfiguration, core: EventEmitter) {
     this.config = config;
     this.serverConfig = serverConfig;
 
     if (this.config.active) {
-      const { pilets, api, publicUrl, assetUrl } = config;
+      const { pilets, api, app, publicUrl, assetUrl } = config;
       this.indexPath = `${publicUrl}index.html`;
       const cbs = {};
 
+      if (app.endsWith('/app')) {
+        const packageJson = require(`${app}/../package.json`);
+
+        if (typeof packageJson.piralCLI.source === 'string') {
+          this.proxyInfo = {
+            source: packageJson.piralCLI.source,
+            files: packageJson.files,
+            date: new Date(packageJson.piralCLI.timestamp),
+          };
+        }
+      }
+
       core.on('user-connected', (e) => {
         const baseUrl = assetUrl || e.req.headers.origin;
 
@@ -144,8 +167,8 @@ export default class PiletInjector implements KrasInjector {
       });
 
       pilets.forEach((p, i) =>
-        p.bundler.on(() => {
-          fillPiletMeta(p, config.meta, `/${i}/`);
+        p.bundler.on(async () => {
+          await fillPiletMeta(p, config.meta, `/${i}/`);
 
           for (const id of Object.keys(cbs)) {
             const { baseUrl, notify } = cbs[id];
@@ -251,7 +274,7 @@ export default class PiletInjector implements KrasInjector {
     return merged;
   }
 
-  sendContent(content: Buffer | string, type: string, url: string): KrasResponse {
+  sendContent(content: Buffer | string, type: string, url: string): KrasResult {
     const { headers } = this.config;
 
     return {
@@ -269,8 +292,8 @@ export default class PiletInjector implements KrasInjector {
     };
   }
 
-  sendFile(target: string, url: string): KrasResponse {
-    const content = readFileSync(target);
+  async sendFile(target: string, url: string): Promise<KrasResult> {
+    const content = await readFile(target);
     const type = mime.getType(target) ?? 'application/octet-stream';
     return this.sendContent(content, type, url);
   }
@@ -281,23 +304,25 @@ export default class PiletInjector implements KrasInjector {
     const pilet = pilets[+index];
     const bundler = pilet?.bundler;
 
+    await bundler?.ready();
+
     if (!path) {
-      await bundler?.ready();
       const content = await this.getIndexMeta(baseUrl);
       return this.sendContent(content, 'application/json', url);
-    } else {
-      return bundler?.ready().then(() => {
-        const target = join(bundler.bundle.dir, rest.join('/'));
+    } else if (bundler?.bundle) {
+      const target = join(bundler.bundle.dir, rest.join('/'));
+      const info = await stat(target).catch(() => undefined);
 
-        if (existsSync(target) && statSync(target).isFile()) {
-          return this.sendFile(target, url);
-        }
-      });
+      if (info && info.isFile()) {
+        return await this.sendFile(target, url);
+      }
     }
+
+    return undefined;
   }
 
-  sendIndexFile(target: string, url: string, baseUrl: string): KrasResponse {
-    const indexHtml = readFileSync(target, 'utf8');
+  async sendIndexFile(target: string, url: string, baseUrl: string): Promise<KrasResult> {
+    const indexHtml = await readFile(target, 'utf8');
 
     // mechanism to inject server side debug piletApi config into piral emulator
     const windowInjectionScript = `window['dbg:pilet-api'] = '${this.getPiletApi(baseUrl)}';`;
@@ -308,29 +333,50 @@ export default class PiletInjector implements KrasInjector {
     return this.sendContent(content, mime.getType(target), url);
   }
 
-  handle(req: KrasRequest): KrasResponse {
+  private async shouldLoad(target: string, path: string) {
+    if (this.proxyInfo) {
+      if (!this.proxyInfo.files.includes(path)) {
+        return false;
+      }
+
+      const fileInfo = await stat(target).catch(() => undefined);
+
+      if (!fileInfo || fileInfo.mtime < this.proxyInfo.date) {
+        const url = new URL(path, this.proxyInfo.source);
+        const response = await axios.default.get(url.href, { responseType: 'arraybuffer' });
+        await writeFile(target, response.data);
+      }
+
+      return true;
+    } else {
+      const fileInfo = await stat(target).catch(() => undefined);
+      return fileInfo && fileInfo.isFile();
+    }
+  }
+
+  async handle(req: KrasRequest): Promise<KrasResult> {
     const { app, api, publicUrl, assetUrl } = this.config;
     const baseUrl =
       assetUrl || (req.headers.host ? `${req.encrypted ? 'https' : 'http'}://${req.headers.host}` : undefined);
 
     if (!req.target) {
       if (req.url.startsWith(publicUrl)) {
-        const path = req.url.substring(publicUrl.length).split('?')[0];
+        const path = req.url.substring(publicUrl.length).split('?').shift();
 
         if (app) {
           const target = join(app, path);
 
-          if (existsSync(target) && statSync(target).isFile()) {
+          if (await this.shouldLoad(target, path)) {
             if (req.url === this.indexPath) {
-              return this.sendIndexFile(target, req.url, baseUrl);
+              return await this.sendIndexFile(target, req.url, baseUrl);
             }
 
-            return this.sendFile(target, req.url);
+            return await this.sendFile(target, req.url);
           }
         }
 
         if (req.url !== this.indexPath) {
-          return this.handle({
+          return await this.handle({
             ...req,
             url: this.indexPath,
           });
@@ -339,8 +385,8 @@ export default class PiletInjector implements KrasInjector {
 
       return undefined;
     } else if (req.target === api) {
-      const path = req.url.substring(1).split('?')[0];
-      return this.sendResponse(path, req.url, baseUrl);
+      const path = req.url.substring(1).split('?').shift();
+      return await this.sendResponse(path, req.url, baseUrl);
     }
   }
 }

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

@@ -64,7 +64,7 @@ describe('Piral-CLI piral injector', () => {
     expect(injector.active).toBeFalsy();
   });
 
-  it('PiralInjector can send reponse and fails with invalid path', () => {
+  it('PiralInjector can send reponse and fails with invalid path', async () => {
     // Arrange
     const config = {
       bundler: bundlerMock,
@@ -75,7 +75,7 @@ describe('Piral-CLI piral injector', () => {
     const injector = new PiralInjector(config, undefined as any, new EventEmitter());
 
     // Act
-    const res = injector.sendResponse('some/nice/invalid/path', 'sometarget.file', 'someDir', 'localhost:1234');
+    const res = await injector.sendResponse('some/nice/invalid/path', 'sometarget.file', 'someDir', 'localhost:1234');
 
     // Assert
     expect(res).toBeUndefined();