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

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,60 @@ 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);
+
+        try {
+          const response = await axios.default.get(url.href, { responseType: 'arraybuffer' });
+          await writeFile(target, response.data);
+        } catch (ex) {
+          log('generalDebug_0003', `HTTP request for emulator asset retrieval failed: ${ex}`);
+          log(
+            fileInfo ? 'optionalEmulatorAssetUpdateSkipped_0122' : 'requiredEmulatorAssetDownloadSkipped_0123',
+            url.href,
+          );
+          return !!fileInfo;
+        }
+      }
+
+      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 +395,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();

package/src/injectors/piral-injector.ts

@@ -1,15 +1,10 @@
 import { join } from 'path';
 import { EventEmitter } from 'events';
-import { readFileSync, existsSync, statSync } from 'fs';
-import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration } from 'kras';
+import { readFile, stat } from 'fs/promises';
+import { KrasInjector, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
 import { mime } from '../external';
 import { Bundler } from '../types';
 
-/**
- * The maximum amount of retries when sending a response
- */
-const maxRetrySendResponse = 4;
-
 export interface PiralInjectorConfig extends KrasInjectorConfig {
   bundler: Bundler;
   publicUrl: string;
@@ -17,6 +12,20 @@ export interface PiralInjectorConfig extends KrasInjectorConfig {
   headers?: Record<string, string>;
 }
 
+/**
+ * The maximum amount of retries when sending a response
+ */
+const maxRetrySendResponse = 4;
+
+async function isNoFile(target: string) {
+  try {
+    const info = await stat(target);
+    return !info.isFile();
+  } catch {
+    return true;
+  }
+}
+
 export default class PiralInjector implements KrasInjector {
   public config: PiralInjectorConfig;
 
@@ -63,7 +72,7 @@ export default class PiralInjector implements KrasInjector {
 
   setOptions() {}
 
-  sendContent(content: Buffer | string, type: string, url: string): KrasResponse {
+  sendContent(content: Buffer | string, type: string, url: string): KrasResult {
     const { headers } = this.config;
     return {
       injector: { name: this.name },
@@ -80,8 +89,8 @@ export default class PiralInjector implements KrasInjector {
     };
   }
 
-  sendIndexFile(target: string, url: string): KrasResponse {
-    const indexHtml = readFileSync(target, 'utf8');
+  async sendIndexFile(target: string, url: string): Promise<KrasResult> {
+    const indexHtml = await readFile(target, 'utf8');
     const { feed } = this.config;
 
     if (feed) {
@@ -96,7 +105,7 @@ export default class PiralInjector implements KrasInjector {
     return this.sendContent(indexHtml, mime.getType(target), url);
   }
 
-  sendResponse(path: string, target: string, dir: string, url: string, recursionDepth = 0): KrasResponse {
+  async sendResponse(path: string, target: string, dir: string, url: string, recursionDepth = 0): Promise<KrasResult> {
     if (recursionDepth > maxRetrySendResponse) {
       return undefined;
     }
@@ -104,17 +113,18 @@ export default class PiralInjector implements KrasInjector {
     const { bundler } = this.config;
     const newTarget = join(bundler.bundle.dir, bundler.bundle.name);
 
-    if (!path || !existsSync(target) || !statSync(target).isFile()) {
-      return this.sendResponse(bundler.bundle.name, newTarget, dir, url, recursionDepth + 1);
+    if (!path || (await isNoFile(target))) {
+      return await this.sendResponse(bundler.bundle.name, newTarget, dir, url, recursionDepth + 1);
     } else if (target === newTarget) {
-      return this.sendIndexFile(target, url);
+      return await this.sendIndexFile(target, url);
+    } else {
+      const type = mime.getType(target) ?? 'application/octet-stream';
+      const content = await readFile(target);
+      return this.sendContent(content, type, url);
     }
-
-    const type = mime.getType(target) ?? 'application/octet-stream';
-    return this.sendContent(readFileSync(target), type, url);
   }
 
-  handle(req: KrasRequest): KrasResponse {
+  async handle(req: KrasRequest): Promise<KrasResult> {
     if (!req.target) {
       const { bundler, publicUrl } = this.config;
 
@@ -122,8 +132,9 @@ export default class PiralInjector implements KrasInjector {
         const pathLength = publicUrl.length || 1;
         const path = req.url.substring(pathLength);
         const dir = bundler.bundle.dir;
-        const target = join(dir, path.split('?')[0]);
-        return bundler.ready().then(() => this.sendResponse(path, target, dir, req.url));
+        const target = join(dir, path.split('?').shift());
+        await bundler.ready();
+        return await this.sendResponse(path, target, dir, req.url);
       }
     }
   }

package/src/messages.ts

@@ -2492,6 +2492,99 @@ export function publishFeedMissingVersion_0116(): QuickMessage {
   ];
 }
 
+/**
+ * @kind Info
+ *
+ * @summary
+ * The remote emulator could not be updated using its given manifest URL.
+ *
+ * @abstract
+ * The remote emulator could not be retrieved from its specified URL. This could be due to a problem with
+ * the network or due to the emulator website not being available right now.
+ *
+ * This is just an informative message. In the current scenario the emulator has been downloaded previously
+ * already. Therefore, only potential updates are blocked due to the error.
+ *
+ * If the error persists please try to access the emulator's URL in your browser. In case this works make
+ * sure that the browser does not have different proxy settings compared ot the rest of your system.
+ *
+ * @see
+ * - [Chrome proxy settings](https://oxylabs.io/resources/integrations/chrome)
+ * - [Firefox proxy settings](https://support.mozilla.org/en-US/kb/connection-settings-firefox)
+ */
+export function skipEmulatorUpdate_0120(manifestUrl: string): QuickMessage {
+  return [LogLevels.info, '0120', `Failed to retrieve current emulator from "${manifestUrl}". Skipping update.`];
+}
+
+/**
+ * @kind Warning
+ *
+ * @summary
+ * The remote emulator could not be updated as the given manifest URL returns a differently named emulator.
+ *
+ * @abstract
+ * When a remote emulator is first installed it will be integrated using its specified name as shell name.
+ * The remote emulator is always auto-updated whenever the Piral CLI is running pilet commands. However,
+ * in case the current emulator manifest has a different name the update will be blocked. In this case a
+ * reinstallation of the emulator is necessary.
+ *
+ * Use "pilet remove-piral-instance" and "pilet add-piral-instance" to remove the old instance (by its given
+ * name) and add the new instance (by the manifest URL).
+ *
+ * @see
+ * - [Chrome proxy settings](https://oxylabs.io/resources/integrations/chrome)
+ * - [Firefox proxy settings](https://support.mozilla.org/en-US/kb/connection-settings-firefox)
+ */
+export function remoteEmulatorNameChanged_0121(name: string): QuickMessage {
+  return [LogLevels.warning, '0121', `The name of the emulator has changed. Skipping updates for "${name}".`];
+}
+
+/**
+ * @kind Info
+ *
+ * @summary
+ * An asset of the remote emulator could not be updated.
+ *
+ * @abstract
+ * The metadata of an remote emulator has been updated, however, one of the asset files could
+ * not be updated. The previously downloaded version of this file will be used as a fallback.
+ *
+ * Using the previously downloaded version of a file might just work, however, for several
+ * reasons this might also break. In any case, if you see this info then any kinds of issues
+ * appearing could potentially be solved by just giving your machine network access again or
+ * waiting for the remote sources to be accessible again.
+ *
+ * @see
+ * - [Chrome proxy settings](https://oxylabs.io/resources/integrations/chrome)
+ * - [Firefox proxy settings](https://support.mozilla.org/en-US/kb/connection-settings-firefox)
+ */
+export function optionalEmulatorAssetUpdateSkipped_0122(url: string): QuickMessage {
+  return [LogLevels.info, '0122', ``];
+}
+
+/**
+ * @kind Warning
+ *
+ * @summary
+ * An asset of the remote emulator could not be downloaded.
+ *
+ * @abstract
+ * The metadata of an remote emulator has been downloaded, however, one of the asset files
+ * could not be downloaded. Consequently, the fallback (index.html) will be used as
+ * replacement in the dev server.
+ *
+ * If you see this warning then any kinds of issues appearing could potentially be solved by
+ * just giving your machine network access again or waiting for the remote sources to be
+ * accessible again.
+ *
+ * @see
+ * - [Chrome proxy settings](https://oxylabs.io/resources/integrations/chrome)
+ * - [Firefox proxy settings](https://support.mozilla.org/en-US/kb/connection-settings-firefox)
+ */
+export function requiredEmulatorAssetDownloadSkipped_0123(url: string): QuickMessage {
+  return [LogLevels.warning, '0123', ``];
+}
+
 /**
  * @kind Warning
  *