piral-cli 1.8.0-beta.7544 → 1.8.0-beta.7653

package/src/common/npm.ts

@@ -5,10 +5,10 @@ import { config } from './config';
 import { legacyCoreExternals, frameworkLibs, defaultRegistry, packageJson } from './constants';
 import { inspectPackage } from './inspect';
 import { readJson, checkExists } from './io';
-import { clients, detectClients, isWrapperClient } from '../npm-clients';
+import { clients, detectDirectClients, detectWrapperClients, isDirectClient, isWrapperClient } from '../npm-clients';
 import { clientTypeKeys } from '../helpers';
 import { getModulePath } from '../external';
-import { PackageType, NpmClientType } from '../types';
+import { PackageType, NpmClientType, NpmClient, NpmDirectClientType, NpmWapperClientType } from '../types';
 
 const gitPrefix = 'git+';
 const filePrefix = 'file:';
@@ -63,56 +63,88 @@ async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClient
   return [];
 }
 
-/**
- * For details about how this works consult issue
- * https://github.com/smapiot/piral/issues/203
- * @param root The project's root directory.
- */
-export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClientType> {
-  if (!selected || !clientTypeKeys.includes(selected)) {
-    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+async function determineWrapperClient(root: string): Promise<NpmWapperClientType | undefined> {
+  const searchedClients = await detectWrapperClients(root);
+  const foundClients = searchedClients.filter((m) => m.result).map((m) => m.client);
 
-    const searchedClients = await detectClients(root);
-    const foundClients = searchedClients.filter((m) => m.result);
-
-    log(
-      'generalDebug_0003',
-      `Results of the lock file check: ${searchedClients.map((m) => `${m.client}=${m.result}`).join(', ')}`,
-    );
+  if (foundClients.length > 0) {
+    const [client] = foundClients;
 
     if (foundClients.length > 1) {
-      const wrapperClient = foundClients.find((m) => isWrapperClient(m.client));
-
-      if (wrapperClient) {
-        const { client } = wrapperClient;
-        log('generalDebug_0003', `Found valid wrapper client via lock or config file: "${client}".`);
-      }
+      log(
+        'generalWarning_0001',
+        `Found multiple clients via their lock or config files: "${foundClients.join('", "')}".`,
+      );
     }
 
-    if (foundClients.length > 0) {
-      const { client } = foundClients[0];
+    log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+    return client;
+  }
 
-      if (foundClients.length > 1) {
-        const clientStr = `"${foundClients.map((m) => m.client).join('", "')}"`;
-        log('generalWarning_0001', `Found multiple clients via their lock or config files: ${clientStr}.`);
-      }
+  const defaultClient = config.npmClient;
 
-      log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
-      return client;
-    }
+  if (isWrapperClient(defaultClient)) {
+    log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
+    return defaultClient;
+  }
+
+  return undefined;
+}
 
-    const defaultClient = config.npmClient;
+async function determineDirectClient(root: string): Promise<NpmDirectClientType> {
+  const searchedClients = await detectDirectClients(root);
+  const foundClients = searchedClients.filter((m) => m.result).map((m) => m.client);
 
-    if (clientTypeKeys.includes(defaultClient)) {
-      log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
-      return defaultClient;
+  if (foundClients.length > 0) {
+    const [client] = foundClients;
+
+    if (foundClients.length > 1) {
+      log(
+        'generalWarning_0001',
+        `Found multiple clients via their lock or config files: "${foundClients.join('", "')}".`,
+      );
     }
 
-    log('generalDebug_0003', 'Using the fallback "npm" client.');
-    return 'npm';
+    log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+    return client;
+  }
+
+  const defaultClient = config.npmClient;
+
+  if (isDirectClient(defaultClient)) {
+    log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
+    return defaultClient;
   }
 
-  return selected;
+  log('generalDebug_0003', 'Using the fallback "npm" client.');
+  return 'npm';
+}
+
+/**
+ * For details about how this works consult issue
+ * https://github.com/smapiot/piral/issues/203
+ * @param root The project's root directory.
+ */
+export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClient> {
+  if (!selected || !clientTypeKeys.includes(selected)) {
+    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+    const [direct, wrapper] = await Promise.all([determineDirectClient(root), determineWrapperClient(root)]);
+    return {
+      direct,
+      wrapper,
+    };
+  } else if (isDirectClient(selected)) {
+    return {
+      proposed: selected,
+      direct: selected,
+    };
+  } else {
+    return {
+      proposed: selected,
+      direct: await determineDirectClient(root),
+      wrapper: selected,
+    };
+  }
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
@@ -126,35 +158,37 @@ export async function isMonorepoPackageRef(refName: string, root: string): Promi
   return false;
 }
 
-export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
-  const { installDependencies } = clients[client];
+export function installNpmDependencies(client: NpmClient, target = '.'): Promise<string> {
+  const { installDependencies } = clients[client.direct];
   return installDependencies(target);
 }
 
 export async function installNpmPackageFromOptionalRegistry(
   packageRef: string,
-  target = '.',
+  target: string,
   registry: string,
 ): Promise<void> {
+  const client = await determineNpmClient(target, 'npm');
+
   try {
-    await installNpmPackage('npm', packageRef, target, '--registry', registry);
+    await installNpmPackage(client, packageRef, target, '--registry', registry);
   } catch (e) {
     if (registry === defaultRegistry) {
       throw e;
     }
 
-    await installNpmPackage('npm', packageRef, target, '--registry', defaultRegistry);
+    await installNpmPackage(client, packageRef, target, '--registry', defaultRegistry);
   }
 }
 
 export async function uninstallNpmPackage(
-  client: NpmClientType,
+  client: NpmClient,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
   try {
-    const { uninstallPackage } = clients[client];
+    const { uninstallPackage } = clients[client.direct];
     return await uninstallPackage(packageRef, target, ...flags);
   } catch (ex) {
     log(
@@ -166,13 +200,13 @@ export async function uninstallNpmPackage(
 }
 
 export async function installNpmPackage(
-  client: NpmClientType,
+  client: NpmClient,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
   try {
-    const { installPackage } = clients[client];
+    const { installPackage } = clients[client.direct];
     return await installPackage(packageRef, target, ...flags);
   } catch (ex) {
     log(
@@ -183,8 +217,8 @@ export async function installNpmPackage(
   }
 }
 
-export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
-  const { initProject } = clients[client];
+export function initNpmProject(client: NpmClient, projectName: string, target: string) {
+  const { initProject } = clients[client.wrapper || client.direct];
   return initProject(projectName, target);
 }
 

package/src/common/package.ts

@@ -1,3 +1,4 @@
+import { Agent } from 'https';
 import { resolve, join, extname, basename, dirname, relative } from 'path';
 import { log, fail } from './log';
 import { cliVersion } from './info';
@@ -161,7 +162,8 @@ async function loadPiralInstance(root: string, details?: PiralInstanceDetails):
 export async function findPiralInstance(
   proposedApp: string,
   rootDir: string,
-  details?: PiralInstanceDetails,
+  details: PiralInstanceDetails,
+  agent: Agent,
   interactive = false,
 ) {
   const path = findPackageRoot(proposedApp, rootDir);
@@ -172,13 +174,13 @@ export async function findPiralInstance(
 
     if (url) {
       log('generalDebug_0003', `Updating the emulator from remote "${url}" ...`);
-      await updateFromEmulatorWebsite(root, url, interactive);
+      await updateFromEmulatorWebsite(root, url, agent, interactive);
     }
 
     return await loadPiralInstance(root, details);
   } else if (url) {
     log('generalDebug_0003', `Piral instance not installed yet - trying from remote "${url}" ...`);
-    const emulator = await scaffoldFromEmulatorWebsite(rootDir, url);
+    const emulator = await scaffoldFromEmulatorWebsite(rootDir, url, agent);
     return await loadPiralInstance(emulator.path, details);
   }
 
@@ -190,6 +192,7 @@ export async function findPiralInstances(
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
   rootDir: string,
+  agent: Agent,
   interactive?: boolean,
 ) {
   if (proposedApps) {
@@ -208,7 +211,7 @@ export async function findPiralInstances(
   if (proposedApps.length > 0) {
     return Promise.all(
       proposedApps.map((proposedApp) =>
-        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp], interactive),
+        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp], agent, interactive),
       ),
     );
   }
@@ -280,11 +283,7 @@ export async function getPiralPackage(app: string, data: PiralInstanceData, vers
   };
 }
 
-async function getAvailableFiles(
-  root: string,
-  name: string,
-  dirName: string,
-): Promise<Array<FileDescriptor>> {
+async function getAvailableFiles(root: string, name: string, dirName: string): Promise<Array<FileDescriptor>> {
   const source = getPiralPath(root, name);
   const tgz = `${dirName}.tar`;
   log('generalDebug_0003', `Checking if "${tgz}" exists in "${source}" ...`);
@@ -780,13 +779,13 @@ export async function findPiletRoot(proposedRoot: string) {
   return dirname(packageJsonPath);
 }
 
-export async function retrievePiletData(target: string, app?: string, interactive?: boolean) {
+export async function retrievePiletData(target: string, app?: string, agent?: Agent, interactive?: boolean) {
   const piletJsonPath = await findFile(target, piletJson);
   const proposedRoot = piletJsonPath ? dirname(piletJsonPath) : target;
   const root = await findPiletRoot(proposedRoot);
   const piletPackage = await readJson(root, packageJson);
   const piletDefinition: PiletDefinition = piletJsonPath && (await readJson(proposedRoot, piletJson));
-  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root, interactive);
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root, agent, interactive);
   const apps: Array<AppDefinition> = [];
 
   for (const appPackage of appPackages) {

package/src/common/release.ts

@@ -1,3 +1,4 @@
+import { Agent } from 'https';
 import { basename, dirname, relative } from 'path';
 import { readBinary } from './io';
 import { publishNpmPackage } from './npm';
@@ -39,7 +40,7 @@ export async function publishWebsiteEmulator(
   files: Array<string>,
   interactive: boolean,
   headers?: Record<string, string>,
-  ca?: Buffer,
+  agent?: Agent,
 ) {
   const data: FormDataObj = {
     version,
@@ -53,5 +54,5 @@ export async function publishWebsiteEmulator(
     data[relPath] = [content, fileName];
   }
 
-  return await postForm(url, mode, apiKey, data, headers, ca, interactive);
+  return await postForm(url, mode, apiKey, data, headers, agent, interactive);
 }

package/src/common/shell.ts

@@ -1,10 +1,11 @@
+import { Agent } from 'https';
 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, PackageType, PiralInstanceDetails } from '../types';
+import { NpmClient, PackageType, PiralInstanceDetails } from '../types';
 
 async function updatePiletJson(target: string, appName: string, appDetails: PiralInstanceDetails) {
   const oldContent = await readJson(target, piletJson);
@@ -29,7 +30,7 @@ async function setupPiralInstance(
   hadVersion: boolean,
   rootDir: string,
   sourceVersion: string,
-  npmClient: NpmClientType,
+  npmClient: NpmClient,
 ) {
   if (!isLinkedPackage(sourceName, type, hadVersion, rootDir)) {
     const packageRef = combinePackageRef(sourceName, sourceVersion, type);
@@ -54,13 +55,14 @@ export async function installPiralInstance(
   usedSource: string,
   baseDir: string,
   rootDir: string,
-  npmClient: NpmClientType,
+  npmClient: NpmClient,
+  agent: Agent,
   selected?: boolean,
 ): Promise<string> {
   const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
 
   if (type === 'remote') {
-    const emulator = await scaffoldFromEmulatorWebsite(rootDir, sourceName);
+    const emulator = await scaffoldFromEmulatorWebsite(rootDir, sourceName, agent);
     const packageName = emulator.name;
     await updatePiletJson(rootDir, packageName, {
       selected,

package/src/common/website.ts

@@ -1,7 +1,7 @@
 import { Agent } from 'https';
 import { posix, relative, resolve } from 'path';
 import { createPiralStubIndexIfNotExists } from './template';
-import { getAuthorizationHeaders, getAxiosOptions, getCertificate, handleAxiosError } from './http';
+import { getAuthorizationHeaders, getAxiosOptions, handleAxiosError } from './http';
 import { packageJson } from './constants';
 import { updateConfig } from './config';
 import { ForceOverwrite } from './enums';
@@ -11,7 +11,7 @@ import { progress, log } from './log';
 import { axios, isInteractive } from '../external';
 import { EmulatorWebsiteManifestFiles, EmulatorWebsiteManifest } from '../types';
 
-async function requestManifest(url: string, interactive: boolean, httpsAgent?: Agent) {
+async function requestManifest(url: string, httpsAgent: Agent, interactive: boolean) {
   const opts = getAxiosOptions(url);
 
   try {
@@ -26,7 +26,7 @@ async function requestManifest(url: string, interactive: boolean, httpsAgent?: A
           value: headers.authorization,
         },
       });
-      return await requestManifest(url, false, httpsAgent);
+      return await requestManifest(url, httpsAgent, false);
     });
   }
 }
@@ -92,6 +92,7 @@ async function createEmulatorFiles(
       peerDependencies: {},
       optionalDependencies: emulatorJson.dependencies.optional,
       devDependencies: emulatorJson.dependencies.included,
+      sharedDependencies: [Object.keys(emulatorJson.importmap.imports)],
     },
     true,
   );
@@ -105,13 +106,11 @@ async function createEmulatorFiles(
   await downloadEmulatorFiles(manifestUrl, targetDir, appDir, emulatorJson.files, httpsAgent);
 }
 
-export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl: string, interactive: boolean) {
+export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl: string, httpsAgent: Agent, interactive: boolean) {
   progress(`Updating emulator from %s ...`, manifestUrl);
-  const ca = await getCertificate();
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
 
   try {
-    const response = await requestManifest(manifestUrl, interactive, httpsAgent);
+    const response = await requestManifest(manifestUrl, httpsAgent, interactive);
     const nextEmulator: EmulatorWebsiteManifest = response.data;
     const currentEmulator = await readJson(targetDir, packageJson);
 
@@ -130,12 +129,10 @@ export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl:
   }
 }
 
-export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string) {
+export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string, httpsAgent: Agent) {
   progress(`Downloading emulator from %s ...`, manifestUrl);
-  const ca = await getCertificate();
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
   const interactive = isInteractive();
-  const response = await requestManifest(manifestUrl, interactive, httpsAgent);
+  const response = await requestManifest(manifestUrl, httpsAgent, interactive);
   const emulatorJson: EmulatorWebsiteManifest = response.data;
   const targetDir = resolve(rootDir, 'node_modules', emulatorJson.name);
   const appDir = resolve(targetDir, 'app');

package/src/npm-clients/index.ts

@@ -1,5 +1,6 @@
 import { dirname, resolve } from 'path';
 import { findFile } from '../common/io';
+import type { NpmClientType, NpmDirectClientType, NpmWapperClientType } from '../types';
 
 import * as lerna from './lerna';
 import * as npm from './npm';
@@ -19,20 +20,26 @@ export const clients = {
   bun,
 };
 
-type ClientName = keyof typeof clients;
+const directClients: Array<NpmDirectClientType> = ['npm', 'pnp', 'yarn', 'pnpm', 'bun'];
+const wrapperClients: Array<NpmWapperClientType> = ['lerna', 'rush'];
 
-const directClients = ['npm', 'pnp', 'yarn', 'pnpm', 'bun'];
+export function isWrapperClient(client: NpmClientType): client is NpmWapperClientType {
+  return wrapperClients.includes(client as any);
+}
 
-export function isWrapperClient(client: ClientName) {
-  return !directClients.includes(client);
+export function isDirectClient(client: NpmClientType): client is NpmDirectClientType {
+  return directClients.includes(client as any);
 }
 
-export async function detectClients(root: string) {
+async function detectClients<T extends NpmClientType>(
+  root: string,
+  clientNames: Array<T>,
+): Promise<Array<{ client: T; result: boolean }>> {
   const packageJson = await findFile(resolve(root, '..'), 'package.json');
   const stopDir = packageJson ? dirname(packageJson) : undefined;
 
   return await Promise.all(
-    Object.keys(clients).map(async (client: ClientName) => {
+    clientNames.map(async (client) => {
       const result = await clients[client].detectClient(root, stopDir);
       return {
         client,
@@ -41,3 +48,11 @@ export async function detectClients(root: string) {
     }),
   );
 }
+
+export function detectDirectClients(root: string) {
+  return detectClients<NpmDirectClientType>(root, directClients);
+}
+
+export function detectWrapperClients(root: string) {
+  return detectClients<NpmWapperClientType>(root, wrapperClients);
+}

package/src/types/internal.ts

@@ -1,5 +1,11 @@
 import type { LogLevels } from './common';
-import type { ImportmapVersions, PiletSchemaVersion } from './public';
+import type {
+  ImportmapVersions,
+  NpmClientType,
+  NpmDirectClientType,
+  NpmWapperClientType,
+  PiletSchemaVersion,
+} from './public';
 
 export interface PiralInstanceDetails {
   selected?: boolean;
@@ -34,3 +40,21 @@ export interface FileInfo {
  * 2. The (short) error message
  */
 export type QuickMessage = [LogLevels, string, string];
+
+/**
+ * Result of identifying an npm client in a project.
+ */
+export interface NpmClient {
+  /**
+   * The proposed client - can be anything.
+   */
+  proposed?: NpmClientType;
+  /**
+   * The direct npm client.
+   */
+  direct: NpmDirectClientType;
+  /**
+   * The wrapper npm client, if any.
+   */
+  wrapper?: NpmWapperClientType;
+}

package/src/types/public.ts

@@ -261,7 +261,11 @@ export type PiletBuildType = 'default' | 'standalone' | 'manifest';
 
 export type PackageType = 'registry' | 'file' | 'git' | 'remote';
 
-export type NpmClientType = 'npm' | 'yarn' | 'pnp' | 'pnpm' | 'lerna' | 'rush' | 'bun';
+export type NpmDirectClientType = 'npm' | 'yarn' | 'pnp' | 'pnpm' | 'bun';
+
+export type NpmWapperClientType = 'lerna' | 'rush';
+
+export type NpmClientType = NpmDirectClientType | NpmWapperClientType;
 
 export type Framework = 'piral' | 'piral-core' | 'piral-base';