piral-cli 0.15.0-alpha.4041 → 0.15.0-alpha.4231

package/src/common/package.ts

@@ -8,11 +8,12 @@ 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 { Framework, FileInfo, PiletsInfo, TemplateFileLocation } from '../types';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath } from './npm';
+import { makePiletExternals, makeExternals, findPackageRoot } from './npm';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -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) {
@@ -161,7 +149,7 @@ function findPackage(pck: string | Array<string>, baseDir: string) {
   return undefined;
 }
 
-export function readPiralPackage(root: string, name: string) {
+export function readPiralPackage(root: string, name: string): Promise<PackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
   return readJson(path, 'package.json');
@@ -196,7 +184,12 @@ export function getPiralPackage(
     },
     importmap: {
       imports: {},
-      inherit: ['piral-base', framework !== 'piral-base' && 'piral-core'].filter(Boolean),
+      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,
@@ -325,10 +318,19 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
   return typeof item === 'object';
 }
 
+function tryFindPackageVersion(packageName: string): string {
+  try {
+    const { version } = require(`${packageName}/package.json`);
+    return version;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
@@ -348,7 +350,7 @@ export async function copyPiralFiles(
   await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
-export function getPiletsInfo(piralInfo: any): PiletsInfo {
+export function getPiletsInfo(piralInfo: Partial<PackageData>): PiletsInfo {
   const {
     files = [],
     scripts = {},
@@ -457,7 +459,7 @@ export async function retrieveExternals(root: string, packageInfo: any) {
       ...packageInfo.dependencies,
     };
     const deps = packageInfo.pilets?.externals;
-    return makeExternals(allDeps, deps);
+    return makeExternals(root, allDeps, deps);
   }
 
   return sharedDependencies.map((m) => m.name);
@@ -476,9 +478,9 @@ export async function retrievePiletsInfo(entryFile: string) {
     fail('packageJsonMissing_0074');
   }
 
+  const root = dirname(packageJson);
   const packageInfo = require(packageJson);
   const info = getPiletsInfo(packageInfo);
-  const root = dirname(packageJson);
   const externals = await retrieveExternals(root, packageInfo);
 
   return {
@@ -507,7 +509,7 @@ export async function patchPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -531,7 +533,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
-  const allExternals = makePiletExternals(piralDependencies, externals, fromEmulator, piralInfo);
+  const allExternals = makePiletExternals(root, piralDependencies, externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);
@@ -555,7 +557,7 @@ export async function patchPiletPackage(
       return deps;
     }, {}),
     ...allExternals.filter(isValidDependency).reduce((deps, name) => {
-      const version = piralDependencies[name];
+      const version = piralDependencies[name] || tryFindPackageVersion(name);
 
       if (version || newInfo) {
         // set only if we have an explicit version or we are in the scaffolding case
@@ -592,7 +594,7 @@ export async function patchPiletPackage(
 /**
  * Returns true if its an emulator package, otherwise it has to be a "raw" app shell.
  */
-export function checkAppShellPackage(appPackage: any) {
+export function checkAppShellPackage(appPackage: PackageData) {
   const { piralCLI = { generated: false, version: cliVersion } } = appPackage;
 
   if (piralCLI.generated) {

package/src/common/scaffold.ts

@@ -1,5 +1,5 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
-import { installPackage } from './clients/npm';
+import { installNpmPackage } from './npm';
 import { ForceOverwrite, SourceLanguage } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { cliVersion, isWindows } from './info';
@@ -37,8 +37,13 @@ async function getTemplateFiles(
   if (templatePackageName.startsWith('.')) {
     templatePackageName = resolve(process.cwd(), templatePackageName);
   } else {
-    await installPackage(templatePackageName, __dirname, '--registry', registry);
+    if (templatePackageName.indexOf('@', 1) === -1) {
+      templatePackageName = `${templatePackageName}@latest`;
+    }
+
+    await installNpmPackage('npm', templatePackageName, __dirname, '--registry', registry);
   }
+
   const templateRunner = getTemplatePackage(templatePackageName);
   const logLevel = getLogLevel();
   const details = {

package/src/common/version.ts

@@ -16,15 +16,15 @@ function indexOrEnd(str: string, q: string) {
 }
 
 function splitVersion(v: string) {
-  var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-  var patchIndex = indexOrEnd(c, '-');
-  var arr = c.substring(0, patchIndex).split('.');
+  const c = v.replace(/^v/, '').replace(/\+.*$/, '');
+  const patchIndex = indexOrEnd(c, '-');
+  const arr = c.substring(0, patchIndex).split('.');
   arr.push(c.substring(patchIndex + 1));
   return arr;
 }
 
 function parseSegment(v: string) {
-  var n = parseInt(v, 10);
+  const n = parseInt(v, 10);
   return isNaN(n) ? v : n;
 }
 

package/src/external/index.ts

@@ -1,6 +1,7 @@
 import logger = require('@parcel/logger');
 import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
+import jju = require('jju');
 import glob = require('glob');
 import tar = require('tar');
 import FormData = require('form-data');
@@ -10,4 +11,4 @@ import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open };
+export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open, jju };

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,
@@ -15,7 +15,7 @@ export const publishModeKeys: Array<PiletPublishScheme> = ['none', 'basic', 'bea
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone', 'manifest'];
-export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
+export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn', 'lerna', 'rush'];
 export const bundlerKeys: Array<string> = ['none', ...bundlerNames];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];

package/src/injectors/pilet.ts

@@ -6,11 +6,10 @@ import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfig
 import { log } from '../common/log';
 import { getPiletSpecMeta } from '../common/spec';
 import { config } from '../common/config';
-import { axios, mime } from '../external';
+import { axios, mime, jju } from '../external';
 import { Bundler } from '../types';
 
 const { host } = config;
-const indexPath = '/index.html';
 
 interface Pilet {
   bundler: Bundler;
@@ -36,8 +35,8 @@ function fillPiletMeta(pilet: Pilet, basePath: string, metaFile: string) {
   const { root, bundler } = pilet;
   const metaPath = join(root, metaFile);
   const packagePath = join(root, 'package.json');
-  const def = JSON.parse(readFileSync(packagePath, 'utf8'));
-  const metaOverride = existsSync(metaPath) ? JSON.parse(readFileSync(metaPath, 'utf8')) : undefined;
+  const def = jju.parse(readFileSync(packagePath, 'utf8'));
+  const metaOverride = existsSync(metaPath) ? jju.parse(readFileSync(metaPath, 'utf8')) : undefined;
   const file = bundler.bundle.name.replace(/^[\/\\]/, '');
   const target = join(bundler.bundle.dir, file);
   const url = new URL(file, basePath);
@@ -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?`,
+  ];
 }
 
 /**
@@ -1842,7 +1846,7 @@ export function packageJsonMissing_0075(): QuickMessage {
  * The TypeScript declaration generator will take all files as input to
  * gather all required information for constructing the API declaration.
  */
-export function declarationCouldNotBeGenerated_0076(rootDir: string, error: Error): QuickMessage {
+export function declarationCouldNotBeGenerated_0076(rootDir: string, error: Error | string): QuickMessage {
   return [LogLevels.error, '0076', `Could not create the declaration in "${rootDir}". Error: ${error}`];
 }
 

package/src/plugin.ts

@@ -1,10 +1,39 @@
 import { readdir, stat } from 'fs';
-import { join, resolve } from 'path';
-import { log } from './common';
+import { join, resolve, sep, posix } from 'path';
+import { cliName, cliVersion, log } from './common';
 import { inject } from './inject';
 
-function getLocalPackageDir() {
-  return resolve(__dirname, '..', '..');
+function getContainerDir() {
+  const currentDir = __dirname.split(sep).join(posix.sep);
+
+  if (!currentDir.includes(`/.pnpm/${cliName}@${cliVersion}/node_modules/${cliName}/`)) {
+    return resolve(__dirname, '..', '..');
+  }
+
+  return undefined;
+}
+
+async function getLocalPackageDir() {
+  const proposedDirs = [
+    getContainerDir(),
+    resolve(process.cwd(), 'node_modules'),
+    resolve(process.cwd(), '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', 'node_modules'),
+    resolve(process.cwd(), '..', '..', '..', 'node_modules'),
+  ];
+
+  // Right now we always take the first one, but in the future this may be different
+  // once we come up with more / better criteria to identify if its a good/valid
+  // plugin root directory
+  for (const dir of proposedDirs.filter(Boolean)) {
+    log('generalDebug_0003', `Checking for potential plugin directory "${dir}" ...`);
+
+    if (await isDirectory(dir)) {
+      return dir;
+    }
+  }
+
+  return undefined;
 }
 
 function isDirectory(dir: string) {
@@ -83,7 +112,7 @@ async function getAllPlugins(rootDir: string): Promise<Array<string>> {
 }
 
 export async function loadPlugins() {
-  const localDir = getLocalPackageDir();
+  const localDir = await getLocalPackageDir();
   const allPlugins = await getAllPlugins(localDir);
 
   for (const pluginPath of allPlugins) {

package/src/release.ts

@@ -21,6 +21,9 @@ const providers: Record<string, ReleaseProvider> = {
 
     await Promise.all(files.map(async (file) => copy(file, resolve(target, basename(file)))));
   },
+  async feed(files, args, interactive) {
+    //TODO post files to Piral Feed Service
+  },
 };
 
 function findReleaseProvider(providerName: string) {
@@ -43,7 +46,12 @@ export function setReleaseProvider(provider: QualifiedReleaseProvider) {
   }
 }
 
-export function publishArtifacts(providerName: string, files: Array<string>, args: Record<string, string>) {
+export function publishArtifacts(
+  providerName: string,
+  files: Array<string>,
+  args: Record<string, string>,
+  interactive: boolean,
+) {
   const runRelease = findReleaseProvider(providerName);
-  return runRelease(files, args);
+  return runRelease(files, args, interactive);
 }

package/src/types/common.ts

@@ -42,7 +42,7 @@ export interface Bundler {
 }
 
 export interface ReleaseProvider {
-  (files: Array<string>, args: Record<string, string>): Promise<void>;
+  (files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;
 }
 
 export interface TemplateFileLocation {

package/src/types/internal.ts

@@ -1,4 +1,4 @@
-import { LogLevels } from './common';
+import type { LogLevels, PiletsInfo } from './common';
 
 export interface PackageData {
   name: string;
@@ -13,6 +13,11 @@ export interface PackageData {
         email?: string;
       };
   custom?: any;
+  pilets?: PiletsInfo;
+  piralCLI?: { generated: boolean; version: string };
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
 }
 
 export interface PackageFiles {

package/src/types/public.ts

@@ -229,9 +229,9 @@ export type PiletBuildType = 'default' | 'standalone' | 'manifest';
 
 export type PackageType = 'registry' | 'file' | 'git';
 
-export type NpmClientType = 'npm' | 'yarn' | 'pnpm';
+export type NpmClientType = 'npm' | 'yarn' | 'pnpm' | 'lerna' | 'rush';
 
-export type Framework = 'piral' | 'piral-core' | 'piral-base';
+export type Framework = 'piral-native' | 'piral' | 'piral-core' | 'piral-base';
 
 export interface StandardEnvProps {
   production?: boolean;