piral-cli 0.15.0-alpha.4036 → 0.15.0-alpha.4122

package/src/common/npm.ts

@@ -1,4 +1,4 @@
-import { resolve, relative, dirname } from 'path';
+import { resolve, relative, dirname, isAbsolute, sep } from 'path';
 import { createReadStream, existsSync, access, constants } from 'fs';
 import { log, fail } from './log';
 import { config } from './config';
@@ -354,12 +354,63 @@ export async function getCurrentPackageDetails(
   return [combinePackageRef(sourceName, desired, 'registry'), desired];
 }
 
+function tryResolve(...args: Parameters<typeof require.resolve>) {
+  try {
+    return require.resolve(...args);
+  } catch {
+    return undefined;
+  }
+}
+
+export function tryResolvePackage(name: string, baseDir: string = undefined) {
+  let path = baseDir ? tryResolve(name, { paths: [baseDir] }) : tryResolve(name);
+  const root = baseDir || process.cwd();
+
+  if (!path) {
+    if (name.startsWith('.')) {
+      path = resolve(root, name);
+    } else if (isAbsolute(name)) {
+      path = name;
+    } else if (name.includes('/', name.startsWith('@') ? name.indexOf('/') + 1 : 0)) {
+      const parts = name.split('/');
+      const mainPart = name.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+      const mainPath = baseDir ? tryResolve(mainPart, { paths: [baseDir] }) : tryResolve(mainPart);
+      const searchStr = `${sep}${mainPart.replace('/', sep)}${sep}`;
+
+      if (mainPath?.includes(searchStr)) {
+        const rest = name.startsWith('@') ? parts.slice(2) : parts.slice(1);
+        path = mainPath.substring(0, mainPath.indexOf(searchStr) + searchStr.length) + rest.join(sep);
+      }
+    } else {
+      path = resolve(root, 'node_modules', name);
+    }
+
+    if (!existsSync(path)) {
+      path = `${path}.js`;
+
+      if (!existsSync(path)) {
+        path = undefined;
+      }
+    }
+  }
+
+  if (!path) {
+    log('generalDebug_0003', `Could not resolve the package "${name}" in "${root}".`);
+  } else {
+    log('generalVerbose_0004', `Resolved the package "${name}" (from "${root}") to be "${path}".`);
+  }
+
+  return path;
+}
+
+export function findPackageRoot(pck: string, baseDir: string = undefined) {
+  return tryResolvePackage(`${pck}/package.json`, baseDir);
+}
+
 export function isLinkedPackage(name: string, type: PackageType, hadVersion: boolean) {
   if (type === 'registry' && !hadVersion) {
-    try {
-      require.resolve(`${name}/package.json`);
-      return true;
-    } catch {}
+    const root = findPackageRoot(name);
+    return typeof root === 'string';
   }
 
   return false;
@@ -424,7 +475,8 @@ export function getPackageVersion(
 function getExternalsFrom(packageName: string): Array<string> | undefined {
   try {
     return require(`${packageName}/package.json`).sharedDependencies;
-  } catch {
+  } catch (err) {
+    log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
     return undefined;
   }
 }

package/src/common/package.test.ts

@@ -1,5 +1,4 @@
-import { resolve } from 'path';
-import { findPackageVersion, findPackageRoot, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
+import { findPackageVersion, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
 import { cliVersion } from './info';
 import { SourceLanguage } from './enums';
 
@@ -14,22 +13,10 @@ describe('CLI package module', () => {
     expect(version).toBe('latest');
   });
 
-  it('findPackageRoot correctly resolves the package root of parcel-bundler', () => {
-    const dir = process.cwd();
-    const version = findPackageRoot('webpack', dir);
-    expect(version).toBe(resolve(dir, 'node_modules', 'webpack', 'package.json'));
-  });
-
-  it('findPackageRoot returns undefined for invalid package', () => {
-    const dir = process.cwd();
-    const version = findPackageRoot('foo-bar-not-exist', dir);
-    expect(version).toBeUndefined();
-  });
-
   it('getPiletsInfo returns pilets information about provided piralInfo', () => {
     const emptyPiletsInfo = {
       files: [],
-      externals: [],
+      template: 'default',
       scripts: {},
       validators: {},
       devDependencies: {},
@@ -45,7 +32,7 @@ describe('CLI package module', () => {
     const piralInfo = {
       pilets: {
         files: ['foo.tgz', 'foo2.tgz'],
-        externals: [],
+        template: 'default',
         scripts: {},
         validators: {},
         devDependencies: {},

package/src/common/package.ts

@@ -8,10 +8,11 @@ import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
 import { applyTemplate } from './template';
 import { readImportmap } from './importmap';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions, bundlerNames } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath } from './npm';
+import { makePiletExternals, makeExternals, findPackageRoot } from './npm';
 import { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
@@ -113,26 +114,13 @@ async function getMatchingFiles(
 }
 
 export function getPiralPath(root: string, name: string) {
-  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}.`);
+  const path = findPackageRoot(name, root);
+
+  if (!path) {
     fail('invalidPiralReference_0043');
   }
-}
 
-export function findPackageRoot(pck: string, baseDir: string) {
-  try {
-    return require.resolve(`${pck}/package.json`, {
-      paths: [baseDir],
-    });
-  } catch (ex) {
-    log('generalDebug_0003', `Could not find the package root in "${baseDir}": ${ex}.`);
-    return undefined;
-  }
+  return dirname(path);
 }
 
 function findPackage(pck: string | Array<string>, baseDir: string) {
@@ -150,8 +138,10 @@ function findPackage(pck: string | Array<string>, baseDir: string) {
     if (path) {
       log('generalDebug_0003', `Following the app package in "${path}" ...`);
       const appPackage = require(path);
+      const root = dirname(path);
       const relPath = appPackage && appPackage.app;
-      appPackage.app = relPath && resolve(dirname(path), relPath);
+      appPackage.app = relPath && resolve(root, relPath);
+      appPackage.root = root;
       return appPackage;
     }
   }
@@ -192,6 +182,15 @@ export function getPiralPackage(
       start: 'piral debug',
       build: 'piral build',
     },
+    importmap: {
+      imports: {},
+      inherit: [
+        'piral-base', // this we take in any case
+        framework !== 'piral-base' && 'piral-core', // this we take unless we selected piral-base, then obviously core is not invited to the party
+        framework === 'piral' && 'piral', // this we take only if we selected piral
+        framework === 'piral-native' && 'piral-native', // this we also only take if we selected piral-native
+      ].filter(Boolean),
+    },
     pilets: getPiletsInfo({}),
     dependencies,
     devDependencies,
@@ -345,8 +344,8 @@ export async function copyPiralFiles(
 export function getPiletsInfo(piralInfo: any): PiletsInfo {
   const {
     files = [],
-    externals = [],
     scripts = {},
+    template = 'default',
     validators = {},
     devDependencies = {},
     preScaffold = '',
@@ -358,8 +357,8 @@ export function getPiletsInfo(piralInfo: any): PiletsInfo {
 
   return {
     files,
-    externals,
     scripts,
+    template,
     validators,
     devDependencies,
     preScaffold,
@@ -442,6 +441,21 @@ export async function findPackageVersion(rootPath: string, packageName: string):
   }
 }
 
+export async function retrieveExternals(root: string, packageInfo: any) {
+  const sharedDependencies = await readImportmap(root, packageInfo);
+
+  if (sharedDependencies.length === 0) {
+    const allDeps = {
+      ...packageInfo.devDependencies,
+      ...packageInfo.dependencies,
+    };
+    const deps = packageInfo.pilets?.externals;
+    return makeExternals(allDeps, deps);
+  }
+
+  return sharedDependencies.map((m) => m.name);
+}
+
 export async function retrievePiletsInfo(entryFile: string) {
   const exists = await checkExists(entryFile);
 
@@ -456,15 +470,9 @@ export async function retrievePiletsInfo(entryFile: string) {
   }
 
   const packageInfo = require(packageJson);
-  const allDeps = {
-    ...packageInfo.devDependencies,
-    ...packageInfo.dependencies,
-  };
   const info = getPiletsInfo(packageInfo);
   const root = dirname(packageJson);
-  const sharedDependencies = await readImportmap(root, packageInfo);
-  const deps = sharedDependencies.length > 0 ? sharedDependencies.map((m) => m.name) : info.externals;
-  const externals = makeExternals(allDeps, deps);
+  const externals = await retrieveExternals(root, packageInfo);
 
   return {
     ...info,
@@ -602,9 +610,10 @@ export async function retrievePiletData(target: string, app?: string) {
     app || (piletPackage.piral && piletPackage.piral.name) || Object.keys(piletPackage.devDependencies),
     target,
   );
-  const appFile: string = appPackage && appPackage.app;
+  const appFile: string = appPackage?.app;
+  const appRoot: string = appPackage?.root;
 
-  if (!appFile) {
+  if (!appFile || !appRoot) {
     fail('appInstanceInvalid_0011');
   }
 
@@ -619,6 +628,7 @@ export async function retrievePiletData(target: string, app?: string) {
     ignored: checkArrayOrUndefined(piletPackage, 'preservedDependencies'),
     importmap,
     appFile,
+    appRoot,
     piletPackage,
     appPackage,
     emulator,

package/src/common/scaffold.ts

@@ -39,6 +39,7 @@ async function getTemplateFiles(
   } else {
     await installPackage(templatePackageName, __dirname, '--registry', registry);
   }
+
   const templateRunner = getTemplatePackage(templatePackageName);
   const logLevel = getLogLevel();
   const details = {

package/src/helpers.ts

@@ -1,6 +1,6 @@
 import { ForceOverwrite, SourceLanguage } from './common/enums';
 import { bundlerNames, frameworkLibs } from './common/constants';
-import {
+import type {
   Framework,
   NpmClientType,
   PiletSchemaVersion,

package/src/injectors/pilet.ts

@@ -10,7 +10,6 @@ import { axios, mime } from '../external';
 import { Bundler } from '../types';
 
 const { host } = config;
-const indexPath = '/index.html';
 
 interface Pilet {
   bundler: Bundler;
@@ -76,6 +75,7 @@ async function loadFeed(feed: string) {
 export default class PiletInjector implements KrasInjector {
   public config: PiletInjectorConfig;
   private piletApi: string;
+  private indexPath: string;
 
   constructor(options: PiletInjectorConfig, config: KrasConfiguration, core: EventEmitter) {
     this.config = options;
@@ -84,7 +84,8 @@ export default class PiletInjector implements KrasInjector {
       ? options.api
       : `${config.ssl ? 'https' : 'http'}://${host}:${config.port}${options.api}`;
 
-    const { pilets, api } = options;
+    const { pilets, api, publicUrl } = options;
+    this.indexPath = `${publicUrl}index.html`;
     const cbs = {};
 
     core.on('user-connected', (e) => {
@@ -220,15 +221,15 @@ export default class PiletInjector implements KrasInjector {
         const target = join(app, path);
 
         if (existsSync(target) && statSync(target).isFile()) {
-          if (req.url === indexPath) {
+          if (req.url === this.indexPath) {
             return this.sendIndexFile(target, req.url);
           } else {
             return this.sendFile(target, req.url);
           }
-        } else if (req.url !== indexPath) {
+        } else if (req.url !== this.indexPath) {
           return this.handle({
             ...req,
-            url: indexPath,
+            url: this.indexPath,
           });
         }
       }

package/src/messages.ts

@@ -549,7 +549,11 @@ export function importMapVersionSpecInvalid_0026(depName: string): QuickMessage
  * node modules are most likely not installed (correctly).
  */
 export function importMapReferenceNotFound_0027(dir: string, reference: string): QuickMessage {
-  return [LogLevels.error, '0027', `The reference to "${reference}" could not be resolved from "${dir}". Are you sure the file or package exists?`];
+  return [
+    LogLevels.error,
+    '0027',
+    `The reference to "${reference}" could not be resolved from "${dir}". Are you sure the file or package exists?`,
+  ];
 }
 
 /**

package/src/rules/pilet-has-externals-as-peers.ts

@@ -1,5 +1,5 @@
 import { PiletRuleContext } from '../types';
-import { getPiletsInfo, getSourceFiles, isValidDependency } from '../common';
+import { retrieveExternals, getSourceFiles, isValidDependency } from '../common';
 
 export type Options = 'ignore' | 'active' | 'only-used';
 
@@ -21,7 +21,7 @@ Received: Missing "${missingNames.join('", "')}".
  */
 export default async function (context: PiletRuleContext, options: Options = 'ignore') {
   if (options !== 'ignore') {
-    const { externals } = getPiletsInfo(context.data.appPackage);
+    const externals = await retrieveExternals(context.data.appRoot, context.data.appPackage);
     const markedPeerDependencies = Object.keys(context.peerDependencies);
     const markedPeerModules = context.peerModules;
     const missingExternals = externals

package/src/types/common.ts

@@ -55,7 +55,8 @@ export interface TemplateFileLocation {
 
 export interface PiletsInfo {
   files: Array<string | TemplateFileLocation>;
-  externals: Array<string>;
+  template: string;
+  externals?: Array<string>;
   devDependencies: Record<string, string | true>;
   scripts: Record<string, string>;
   validators: Record<string, any>;
@@ -106,6 +107,7 @@ export interface PiletRuleContext extends RuleContext {
 }
 
 export interface PiralData {
+  appRoot: string;
   appFile: string;
   appPackage: any;
   piletPackage: any;

package/src/types/public.ts

@@ -231,7 +231,7 @@ export type PackageType = 'registry' | 'file' | 'git';
 
 export type NpmClientType = 'npm' | 'yarn' | 'pnpm';
 
-export type Framework = 'piral' | 'piral-core' | 'piral-base';
+export type Framework = 'piral-native' | 'piral' | 'piral-core' | 'piral-base';
 
 export interface StandardEnvProps {
   production?: boolean;