piral-cli 0.13.8 → 0.14.0-beta.3156

package/src/common/emulator.ts

@@ -81,6 +81,7 @@ export async function createEmulatorSources(
       ...piralPkg.dependencies,
       ...externalDependencies,
     },
+    sharedDependencies: allExternals,
     repository: piralPkg.repository,
     bugs: piralPkg.bugs,
     author: piralPkg.author,

package/src/common/hash.ts

@@ -7,3 +7,8 @@ export function computeHash(content: string | Buffer = '') {
 export function computeMd5(content: string | Buffer = '') {
   return createHash('md5').update(content).digest('hex');
 }
+
+export function computeIntegrity(content: string) {
+  const sum = createHash('sha256').update(content).digest('base64');
+  return `sha256-${sum}`;
+}

package/src/common/http.ts

@@ -4,9 +4,13 @@ import { Stream } from 'stream';
 import { platform, tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { computeHash } from './hash';
 import { axios, FormData } from '../external';
 
 const os = platform();
+const standardHeaders = {
+  'user-agent': `piral-cli/http.node-${os}`,
+};
 
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
@@ -36,14 +40,24 @@ function streamToFile(source: Stream, target: string) {
   });
 }
 
+export function getHashFromUrl(target: string): Promise<string> {
+  return axios.default
+    .get<Buffer>(target, {
+      responseType: 'arraybuffer',
+      headers: standardHeaders,
+    })
+    .then((res) => {
+      log('generalDebug_0003', `Received the contents from "${target}" (status: ${res.status}).`);
+      return computeHash(res.data);
+    });
+}
+
 export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
   return axios.default
     .get<Stream>(target, {
       responseType: 'stream',
-      headers: {
-        'user-agent': `piral-cli/http.node-${os}`,
-      },
+      headers: standardHeaders,
       httpsAgent,
     })
     .then((res) => {
@@ -80,7 +94,7 @@ export function postFile(
 
   const headers: Record<string, string> = {
     ...form.getHeaders(),
-    'user-agent': `piral-cli/http.node-${os}`,
+    ...standardHeaders,
   };
 
   if (key) {

package/src/common/io.ts

@@ -182,6 +182,7 @@ function matchPattern(baseDir: string, pattern: string) {
       {
         cwd: baseDir,
         nodir: true,
+        absolute: true,
       },
       (err, files) => {
         if (err) {
@@ -235,6 +236,9 @@ export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
         if (!results.length) {
           log('generalDebug_0003', `Found no potential entry points using "${pattern}".`);
         } else {
+          //TODO -> shouldn't take the first one,
+          // should be the first one, yes, but, PER pilet
+          // so that multiple pilets can be considered, too
           log('generalDebug_0003', `Found ${results.length} potential entry points in "${pattern}".`);
 
           for (const result of results) {

package/src/common/npm.test.ts

@@ -409,30 +409,30 @@ describe('NPM Module', () => {
   it('makeExternals without externals returns coreExternals', () => {
     const externals = makeExternals();
     expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
     const externals = makeExternals([]);
     expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -446,15 +446,15 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'foo',
       'bar',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -463,14 +463,14 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'react',
       'foo',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -479,13 +479,13 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'react',
       'react-calendar',
-      '@dbeining/react-atom',
-      '@libre/atom',
       'react-dom',
       'react-router',
       'react-router-dom',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 

package/src/common/npm.ts

@@ -2,8 +2,8 @@ import { resolve, relative } from 'path';
 import { createReadStream, existsSync, access, constants } from 'fs';
 import { log, fail } from './log';
 import { config } from './config';
+import { legacyCoreExternals } from './constants';
 import { inspectPackage } from './inspect';
-import { coreExternals } from './constants';
 import { readJson, checkExists, findFile } from './io';
 import { clientTypeKeys } from '../helpers';
 import { PackageType, NpmClientType } from '../types';
@@ -388,7 +388,26 @@ export function getPackageVersion(
   }
 }
 
-export function makeExternals(externals?: Array<string>) {
+export function getCoreExternals(): Array<string> {
+  try {
+    return require('piral-core/package.json').sharedDependencies || [];
+  } catch {
+    return [];
+  }
+}
+
+export function makePiletExternals(externals: Array<string>, fromEmulator: boolean, piralInfo: any) {
+  if (fromEmulator) {
+    const { sharedDependencies = makeExternals(externals, true) } = piralInfo;
+    return sharedDependencies;
+  } else {
+    return makeExternals(externals);
+  }
+}
+
+export function makeExternals(externals?: Array<string>, legacy = false) {
+  const coreExternals = legacy ? legacyCoreExternals : getCoreExternals();
+
   if (externals && Array.isArray(externals)) {
     const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {

package/src/common/package.ts

@@ -5,12 +5,13 @@ import { unpackTarball } from './archive';
 import { getDependencies, getDevDependencies } from './language';
 import { SourceLanguage, ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
+import { deepMerge } from './merge';
+import { getHashFromUrl } from './http';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions } from './constants';
-import { getHash, checkIsDirectory, matchFiles, getFileNames } from './io';
+import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makeExternals } from './npm';
-import { deepMerge } from './merge';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, SharedDependency } from '../types';
 
 function getDependencyVersion(
   name: string,
@@ -86,10 +87,15 @@ async function getMatchingFiles(
 }
 
 export function getPiralPath(root: string, name: string) {
-  const path = require.resolve(`${name}/package.json`, {
-    paths: [root],
-  });
-  return dirname(path);
+  try {
+    const path = require.resolve(`${name}/package.json`, {
+      paths: [root],
+    });
+    return dirname(path);
+  } catch (ex) {
+    log('generalDebug_0003', `Could not resolve the Piral path of "${name}" in "${root}": ${ex}.`);
+    fail('invalidPiralReference_0043');
+  }
 }
 
 export function findPackageRoot(pck: string, baseDir: string) {
@@ -431,6 +437,7 @@ export async function patchPiletPackage(
   name: string,
   version: string,
   piralInfo: any,
+  fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
   log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
@@ -444,7 +451,6 @@ export async function patchPiletPackage(
     ...piralInfo.dependencies,
   };
   const typeDependencies = newInfo ? getDevDependencies(newInfo.language) : {};
-  const allExternals = makeExternals(externals);
   const scripts = newInfo
     ? {
         start: 'pilet debug',
@@ -454,6 +460,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
+  const allExternals = makePiletExternals(externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);
@@ -528,6 +535,108 @@ export function checkAppShellPackage(appPackage: any) {
   return false;
 }
 
+function tryResolve(baseDir: string, name: string) {
+  try {
+    return require.resolve(name, {
+      paths: [baseDir],
+    });
+  } catch (ex) {
+    log('generalDebug_0003', `Could not resolve the package "${name}" in "${baseDir}": ${ex}`);
+    return undefined;
+  }
+}
+
+interface Importmap {
+  imports: Record<string, string>;
+}
+
+function normalizeDepName(s: string) {
+  return (s.startsWith('@') ? s.substr(1) : s).replace(/[\/\.]/g, '-').replace(/(\-)+/, '-');
+}
+
+async function resolveImportmap(dir: string, importmap: Importmap) {
+  const dependencies: Array<SharedDependency> = [];
+  const sharedImports = importmap?.imports;
+
+  if (typeof sharedImports === 'object' && sharedImports) {
+    for (const depName of Object.keys(sharedImports)) {
+      const url = sharedImports[depName];
+      const assetName = normalizeDepName(depName);
+
+      if (typeof url !== 'string') {
+      } else if (/^https?:\/\//.test(url)) {
+        const hash = await getHashFromUrl(url);
+
+        dependencies.push({
+          id: `${depName}@${hash}`,
+          entry: url,
+          name: depName,
+          ref: url,
+          type: 'remote',
+        });
+      } else if (url === depName) {
+        const entry = tryResolve(dir, depName);
+
+        if (entry) {
+          const packageJson = await findFile(dirname(entry), 'package.json');
+          const details = require(packageJson);
+
+          dependencies.push({
+            id: `${depName}@${details.version}`,
+            entry,
+            ref: `${assetName}.js`,
+            name: depName,
+            type: 'local',
+          });
+        }
+      } else {
+        const entry = resolve(dir, url);
+        const exists = await checkExists(entry);
+
+        if (exists) {
+          const packageJson = await findFile(dirname(entry), 'package.json');
+
+          if (packageJson) {
+            const details = require(packageJson);
+
+            dependencies.push({
+              id: `${depName}@${details.version}`,
+              entry,
+              name: depName,
+              ref: `${assetName}.js`,
+              type: 'local',
+            });
+          } else {
+            const hash = await getHash(entry);
+
+            dependencies.push({
+              id: `${depName}@${hash}`,
+              entry,
+              name: depName,
+              ref: `${assetName}.js`,
+              type: 'local',
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return dependencies;
+}
+
+export async function readImportmap(dir: string, packageDetails: any) {
+  const importmap = packageDetails.importmap;
+
+  if (typeof importmap === 'string') {
+    const content = await readJson(dir, importmap);
+    const baseDir = dirname(resolve(dir, importmap));
+    return resolveImportmap(baseDir, content);
+  }
+
+  return resolveImportmap(dir, importmap);
+}
+
 export async function retrievePiletData(target: string, app?: string) {
   const packageJson = await findFile(target, 'package.json');
 
@@ -548,6 +657,7 @@ export async function retrievePiletData(target: string, app?: string) {
   }
 
   const emulator = checkAppShellPackage(appPackage);
+  const importmap = await readImportmap(root, piletPackage);
 
   return {
     dependencies: piletPackage.dependencies || {},
@@ -555,6 +665,7 @@ export async function retrievePiletData(target: string, app?: string) {
     peerDependencies: piletPackage.peerDependencies || {},
     peerModules: piletPackage.peerModules || [],
     ignored: checkArrayOrUndefined(piletPackage, 'preservedDependencies'),
+    importmap,
     appFile,
     piletPackage,
     appPackage,

package/src/helpers.ts

@@ -1,11 +1,11 @@
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 import { Framework, NpmClientType, PiletSchemaVersion, PiletPublishSource, PiralBuildType } from './types';
 
-export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'none'];
+export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const buildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
-export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5'];
+export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5', 'esbuild'];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];
 export const frameworkKeys: Array<Framework> = ['piral', 'piral-core', 'piral-base'];

package/src/injectors/pilet.ts

@@ -1,15 +1,17 @@
+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 { computeHash, computeIntegrity } from '../common/hash';
+import { log } from '../common/log';
 import { axios, mime } from '../external';
 import { Bundler } from '../types';
-import { log } from '../common/log';
 
 interface Pilet {
   bundler: Bundler;
   root: string;
-  requireRef?: string;
+  meta: PiletMetadata;
 }
 
 export interface PiletInjectorConfig extends KrasInjectorConfig {
@@ -24,6 +26,80 @@ interface PiletMetadata {
   [key: string]: unknown;
 }
 
+const checkV1 = /^\/\/\s*@pilet\s+v:1\s*\(([A-Za-z0-9\_\:\-]+)\)/;
+const checkV2 = /^\/\/\s*@pilet\s+v:2\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
+
+function getDependencies(deps: string, basePath: string) {
+  try {
+    const depMap = JSON.parse(deps);
+
+    if (depMap && typeof depMap === 'object') {
+      return Object.keys(depMap).reduce((obj, depName) => {
+        const depUrl = depMap[depName];
+
+        if (typeof depUrl === 'string') {
+          const url = new URL(depUrl, basePath);
+          obj[depName] = url.href;
+        }
+
+        return obj;
+      }, {});
+    }
+  } catch {}
+
+  return {};
+}
+
+function getPiletSpecMeta(target: string, basePath: string) {
+  if (existsSync(target) && statSync(target).isFile()) {
+    const content = readFileSync(target, 'utf8');
+
+    if (checkV1.test(content)) {
+      // uses single argument; requireRef (required)
+      const [, requireRef] = checkV1.exec(content);
+      return {
+        spec: 'v1',
+        requireRef,
+        integrity: computeIntegrity(content),
+      };
+    } else if (checkV2.test(content)) {
+      // uses two arguments; requireRef and dependencies as JSON (required)
+      const [, requireRef, plainDependencies] = checkV2.exec(content);
+      return {
+        spec: 'v2',
+        requireRef,
+        dependencies: getDependencies(plainDependencies, basePath),
+      };
+    } else {
+      return {
+        spec: 'v0',
+        hash: computeHash(content),
+        noCache: true,
+      };
+    }
+  }
+
+  return {};
+}
+
+function fillPiletMeta(pilet: Pilet, basePath: string) {
+  const { root, bundler } = pilet;
+  const def = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+  const file = bundler.bundle.name.replace(/^[\/\\]/, '');
+  const target = join(bundler.bundle.dir, file);
+  const url = new URL(file, basePath);
+  const meta = {
+    name: def.name,
+    version: def.version,
+    link: `${url.href}?updated=${Date.now()}`,
+    custom: def.custom,
+    ...getPiletSpecMeta(target, basePath),
+  };
+
+  pilet.meta = meta;
+  return JSON.stringify(meta);
+}
+
 export default class PiletInjector implements KrasInjector {
   public config: PiletInjectorConfig;
   private piletApi: string;
@@ -49,9 +125,9 @@ export default class PiletInjector implements KrasInjector {
     });
 
     pilets.forEach((p, i) =>
-      p.bundler.on(({ requireRef, version }) => {
-        p.requireRef = version === 'v1' ? requireRef : undefined;
-        const meta = JSON.stringify(this.getMetaOf(i));
+      p.bundler.on(() => {
+        const basePath = `${this.piletApi}/${i}/`;
+        const meta = fillPiletMeta(p, basePath);
 
         for (const id of Object.keys(cbs)) {
           cbs[id](meta);
@@ -77,25 +153,9 @@ export default class PiletInjector implements KrasInjector {
 
   setOptions() {}
 
-  getMetaOf(index: number) {
-    const { api, pilets } = this.config;
-    const { bundler, root, requireRef } = pilets[index];
-    const def = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
-    const file = bundler.bundle.name.replace(/^\//, '');
-    return {
-      name: def.name,
-      version: def.version,
-      link: `${this.piletApi}/${index}/${file}`,
-      hash: bundler.bundle.hash,
-      requireRef,
-      noCache: true,
-      custom: def.custom,
-    };
-  }
-
   async getMeta() {
     const { pilets, feed } = this.config;
-    const localPilets = pilets.map((_, i) => this.getMetaOf(i));
+    const localPilets = pilets.map((pilet) => pilet.meta).filter(Boolean);
     const mergedPilets = this.mergePilets(localPilets, await this.loadRemoteFeed(feed));
 
     if (mergedPilets.length === 1) {

package/src/injectors/piral.test.ts

@@ -1,5 +1,6 @@
-import PiralInjector, { PiralInjectorConfig } from './piral';
+import PiralInjector from './piral';
 import { KrasRequest, KrasResult } from 'kras';
+import { EventEmitter } from 'events';
 
 const bundlerMock = {
   pending: true,
@@ -36,7 +37,7 @@ describe('Piral-CLI piral injector', () => {
       bundler,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
     expect(injector.active).toBeTruthy();
   });
 
@@ -46,7 +47,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
 
     // Act
     injector.active = false;
@@ -64,7 +65,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
 
     // Act
     const res = injector.sendResponse('some/nice/invalid/path', 'sometarget.file', 'someDir', 'localhost:1234');
@@ -79,7 +80,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
     const request: KrasRequest = {
       content: 'someFakeContent',
       headers: {},

package/src/injectors/piral.ts

@@ -1,6 +1,7 @@
 import { join } from 'path';
+import { EventEmitter } from 'events';
 import { readFileSync, existsSync, statSync } from 'fs';
-import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig } from 'kras';
+import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration } from 'kras';
 import { mime } from '../external';
 import { Bundler } from '../types';
 
@@ -16,8 +17,26 @@ export interface PiralInjectorConfig extends KrasInjectorConfig {
 export default class PiralInjector implements KrasInjector {
   public config: PiralInjectorConfig;
 
-  constructor(options: PiralInjectorConfig) {
+  constructor(options: PiralInjectorConfig, _config: KrasConfiguration, core: EventEmitter) {
     this.config = options;
+    const api = '/$events';
+    const cbs = {};
+
+    core.on('user-connected', (e) => {
+      if (e.target === '*' && e.url === api.substr(1)) {
+        cbs[e.id] = (msg: string) => e.ws.send(msg);
+      }
+    });
+
+    core.on('user-disconnected', (e) => {
+      delete cbs[e.id];
+    });
+
+    this.config.bundler.on((args) => {
+      for (const id of Object.keys(cbs)) {
+        cbs[id](JSON.stringify(args));
+      }
+    });
   }
 
   get active() {