piral-cli 1.5.0-beta.6740 → 1.5.0-beta.6746

package/src/apps/build-pilet.ts

@@ -1,18 +1,15 @@
-import { dirname, basename, resolve, relative } from 'path';
+import { dirname, resolve } from 'path';
 import { LogLevels, PiletBuildType, PiletSchemaVersion } from '../types';
-import { callPiletBuild, callPiralBuild } from '../bundler';
+import { callPiralBuild } from '../bundler';
 import {
   removeDirectory,
-  retrievePiletData,
   setLogLevel,
   progress,
   logDone,
   logInfo,
-  createPiletDeclaration,
   ForceOverwrite,
   matchAnyPilet,
   fail,
-  config,
   log,
   writeJson,
   getPiletSpecMeta,
@@ -22,10 +19,7 @@ import {
   cpuCount,
   concurrentWorkers,
   normalizePublicUrl,
-  combinePiletExternals,
   retrievePiletsInfo,
-  validateSharedDependencies,
-  defaultSchemaVersion,
   flattenExternals,
   triggerBuildPilet,
 } from '../common';

package/src/apps/declaration-pilet.ts

@@ -52,6 +52,7 @@ export async function declarationPilet(baseDir = process.cwd(), options: Declara
   setLogLevel(logLevel);
 
   const allEntries = await matchAnyPilet(fullBase, entryList);
+  const results: Array<boolean> = [];
 
   for (const item of allEntries) {
     const targetDir = dirname(item);
@@ -59,18 +60,21 @@ export async function declarationPilet(baseDir = process.cwd(), options: Declara
     const piralInstances = apps.map((m) => m.appPackage.name);
     const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
     const dest = resolve(root, target);
-
-    await createPiletDeclaration(
-      piletPackage.name,
-      piralInstances,
-      root,
-      item,
-      externals,
-      dest,
-      forceOverwrite,
-      logLevel,
+    results.push(
+      await createPiletDeclaration(
+        piletPackage.name,
+        piralInstances,
+        root,
+        item,
+        externals,
+        dest,
+        forceOverwrite,
+        logLevel,
+      ),
     );
   }
 
-  logDone(`Declaration created successfully in "${target}"!`);
+  if (results.every(Boolean)) {
+    logDone(`Declaration created successfully in "${target}"!`);
+  }
 }

package/src/apps/declaration-piral.ts

@@ -40,6 +40,8 @@ export async function declarationPiral(baseDir = process.cwd(), options: Declara
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
-  await createPiralDeclaration(fullBase, entry, target, forceOverwrite, logLevel);
-  logDone(`Declaration created successfully in "${target}"!`);
+  
+  if (await createPiralDeclaration(fullBase, entry, target, forceOverwrite, logLevel)) {
+    logDone(`Declaration created successfully in "${target}"!`);
+  }
 }

package/src/apps/publish-pilet.ts

@@ -1,4 +1,4 @@
-import { relative, dirname, basename, resolve } from 'path';
+import { relative, resolve } from 'path';
 import { LogLevels, PiletSchemaVersion, PiletPublishSource, PublishScheme } from '../types';
 import {
   postFile,
@@ -11,11 +11,11 @@ import {
   progress,
   log,
   config,
-  checkExists,
   findNpmTarball,
   downloadFile,
   matchAnyPilet,
   triggerBuildPilet,
+  getCertificate,
 } from '../common';
 
 export interface PublishPiletOptions {
@@ -203,7 +203,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     logLevel = publishPiletDefaults.logLevel,
     from = publishPiletDefaults.from,
     schemaVersion = publishPiletDefaults.schemaVersion,
-    cert = config.cert ?? publishPiletDefaults.cert,
+    cert = publishPiletDefaults.cert,
     fields = publishPiletDefaults.fields,
     headers = publishPiletDefaults.headers,
     mode = publishPiletDefaults.mode,
@@ -220,15 +220,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     fail('missingPiletFeedUrl_0060');
   }
 
-  log('generalDebug_0003', 'Checking if certificate exists.');
-  let ca: Buffer = undefined;
-
-  if (await checkExists(cert)) {
-    const dir = dirname(cert);
-    const file = basename(cert);
-    log('generalDebug_0003', `Reading certificate file "${file}" from "${dir}".`);
-    ca = await readBinary(dir, file);
-  }
+  const ca = await getCertificate(cert);
 
   log('generalDebug_0003', 'Getting the tgz files ...');
   const sources = Array.isArray(source) ? source : [source];

package/src/apps/publish-piral.ts

@@ -1,14 +1,12 @@
-import { basename, dirname, resolve } from 'path';
+import { resolve } from 'path';
 import { LogLevels, PublishScheme } from '../types';
 import {
   setLogLevel,
   progress,
-  checkExists,
   fail,
   logDone,
   log,
   config,
-  readBinary,
   emulatorName,
   emulatorJson,
   publishWebsiteEmulator,
@@ -21,6 +19,7 @@ import {
   emulatorPackageName,
   retrievePiletsInfo,
   validateSharedDependencies,
+  getCertificate,
 } from '../common';
 
 export interface PublishPiralOptions {
@@ -111,7 +110,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     fresh = publishPiralDefaults.fresh,
     url = config.url ?? publishPiralDefaults.url,
     apiKey = config.apiKeys?.[url] ?? config.apiKey ?? publishPiralDefaults.apiKey,
-    cert = config.cert ?? publishPiralDefaults.cert,
+    cert = publishPiralDefaults.cert,
     headers = publishPiralDefaults.headers,
     mode = publishPiralDefaults.mode,
     _ = {},
@@ -126,15 +125,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     fail('missingPiletFeedUrl_0060');
   }
 
-  log('generalDebug_0003', 'Checking if certificate exists.');
-  let ca: Buffer = undefined;
-
-  if (await checkExists(cert)) {
-    const dir = dirname(cert);
-    const file = basename(cert);
-    log('generalDebug_0003', `Reading certificate file "${file}" from "${dir}".`);
-    ca = await readBinary(dir, file);
-  }
+  const ca = await getCertificate(cert);
 
   log('generalDebug_0003', 'Getting the files ...');
   const entryFiles = await retrievePiralRoot(fullBase, './');
@@ -150,7 +141,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
   if (emulator !== emulatorWebsiteName) {
     fail('generalError_0002', `Currently only the "${emulatorWebsiteName}" option is supported.`);
   }
-  
+
   const emulatorDir = resolve(fullBase, source, emulatorName);
 
   if (fresh) {

package/src/apps/upgrade-pilet.ts

@@ -1,5 +1,6 @@
 import { resolve } from 'path';
 import { LogLevels, NpmClientType } from '../types';
+import { isInteractive } from '../external';
 import {
   installNpmPackage,
   checkExistingDirectory,
@@ -99,7 +100,10 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
   }
 
   const npmClient = await determineNpmClient(root, defaultNpmClient);
-  const { apps, piletPackage } = await retrievePiletData(root);
+
+  // in case we run from a user's CLI we want to allow updating
+  const interactive = isInteractive();
+  const { apps, piletPackage } = await retrievePiletData(root, undefined, interactive);
   const { devDependencies = {}, dependencies = {}, source } = piletPackage;
 
   if (apps.length === 0) {

package/src/common/config.ts

@@ -1,4 +1,7 @@
-import { defaultRegistry } from './constants';
+import { homedir } from 'os';
+import { resolve } from 'path';
+import { readFile, writeFile } from 'fs/promises';
+import { appName, defaultRegistry } from './constants';
 import { rc } from '../external';
 import { AuthConfig, SourceLanguage, NpmClientType, PiletSchemaVersion } from '../types';
 
@@ -69,7 +72,7 @@ export interface PiralCliConfig {
 }
 
 export const config: PiralCliConfig = rc(
-  'piral',
+  appName,
   {
     apiKey: undefined,
     apiKeys: {},
@@ -89,3 +92,34 @@ export const config: PiralCliConfig = rc(
   },
   {},
 );
+
+function mergeConfig<T extends keyof PiralCliConfig>(
+  existing: PiralCliConfig,
+  area: T,
+  value: Partial<PiralCliConfig[T]>,
+) {
+  const current = existing[area];
+
+  // update already existing config
+  Object.assign(existing, {
+    [area]:
+      typeof current === 'object'
+        ? {
+            ...current,
+            ...value,
+          }
+        : value,
+  });
+}
+
+export async function updateConfig<T extends keyof PiralCliConfig>(area: T, value: Partial<PiralCliConfig[T]>) {
+  // update already existing config
+  mergeConfig(config, area, value);
+
+  // update user-global config
+  const path = resolve(homedir(), `.${appName}rc`);
+  const content = await readFile(path, 'utf8').catch(() => '{}');
+  const configFile = JSON.parse(content);
+  mergeConfig(configFile, area, value);
+  await writeFile(path, JSON.stringify(configFile, undefined, 2), 'utf8');
+}

package/src/common/constants.ts

@@ -1,5 +1,6 @@
 export const defaultRegistry = 'https://registry.npmjs.org/';
 export const filesTar = 'files';
+export const appName = 'piral';
 export const packageJson = 'package.json';
 export const piralJson = 'piral.json';
 export const piletJson = 'pilet.json';

package/src/common/declaration.ts

@@ -130,20 +130,14 @@ function createLogger(): Logger {
 
 async function createDeclarationFile(
   options: DeclOptions,
-  source: string,
   target: string,
   forceOverwrite: ForceOverwrite,
 ) {
   progress('Bundling declaration file ...');
+  const result = await generateDeclaration(options);
 
-  try {
-    const result = await generateDeclaration(options);
-
-    progress('Writing declaration file ...');
-    await createFileIfNotExists(target, 'index.d.ts', result, forceOverwrite);
-  } catch (ex) {
-    log('declarationCouldNotBeGenerated_0076', source, ex);
-  }
+  progress('Writing declaration file ...');
+  await createFileIfNotExists(target, 'index.d.ts', result, forceOverwrite);
 }
 
 export async function createPiletDeclaration(
@@ -175,7 +169,15 @@ export async function createPiletDeclaration(
       logLevel,
       logger: createLogger(),
     };
-    return await createDeclarationFile(options, root, target, forceOverwrite);
+
+    try {
+      await createDeclarationFile(options, target, forceOverwrite);
+      return true;
+    } catch (ex) {
+      log('declarationCouldNotBeGenerated_0076', root, ex);
+    }
+
+    return false;
   }
 }
 
@@ -206,8 +208,15 @@ export async function createPiralDeclaration(
   validateSharedDependencies(externals);
 
   if (options.apis.length) {
-    return await createDeclarationFile(options, baseDir, target, forceOverwrite);
+    try {
+      await createDeclarationFile(options, target, forceOverwrite);
+      return true;
+    } catch (ex) {
+      log('declarationCouldNotBeGenerated_0076', baseDir, ex);
+    }
+  } else {
+    log('declarationCouldNotBeGenerated_0076', baseDir, 'The main Pilet API interface could not be found.');
   }
 
-  log('declarationCouldNotBeGenerated_0076', baseDir, 'The main Pilet API interface could not be found.');
+  return false;
 }

package/src/common/http.ts

@@ -1,4 +1,4 @@
-import { join } from 'path';
+import { basename, dirname, join } from 'path';
 import { Agent } from 'https';
 import { Stream } from 'stream';
 import { tmpdir } from 'os';
@@ -6,6 +6,7 @@ import { createWriteStream } from 'fs';
 import { log } from './log';
 import { config } from './config';
 import { standardHeaders } from './info';
+import { checkExists, readBinary } from './io';
 import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
 import { PublishScheme } from '../types';
@@ -60,6 +61,45 @@ export function getAxiosOptions(url: string) {
   }
 }
 
+export async function getCertificate(cert = config.cert): Promise<Buffer> {
+  log('generalDebug_0003', 'Checking if certificate exists.');
+
+  if (await checkExists(cert)) {
+    const dir = dirname(cert);
+    const file = basename(cert);
+    log('generalDebug_0003', `Reading certificate file "${file}" from "${dir}".`);
+    return await readBinary(dir, file);
+  }
+
+  return undefined;
+}
+
+export function getAuthorizationHeaders(scheme: PublishScheme, key: string) {
+  if (key) {
+    switch (scheme) {
+      case 'basic':
+        return {
+          authorization: `Basic ${key}`,
+        };
+      case 'bearer':
+        return {
+          authorization: `Bearer ${key}`,
+        };
+      case 'digest':
+        return {
+          authorization: `Digest ${key}`,
+        };
+      case 'none':
+      default:
+        return {
+          authorization: key,
+        };
+    }
+  }
+
+  return {};
+}
+
 export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
   return axios.default
@@ -80,24 +120,9 @@ export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>
     });
 }
 
-export interface PostFormResult {
-  status: number;
-  success: boolean;
-  response?: object;
-}
-
 export type FormDataObj = Record<string, string | number | boolean | [Buffer, string]>;
 
-export function postForm(
-  target: string,
-  scheme: PublishScheme,
-  key: string,
-  formData: FormDataObj,
-  customHeaders: Record<string, string> = {},
-  ca?: Buffer,
-  interactive = false,
-): Promise<PostFormResult> {
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+export function createAxiosForm(formData: FormDataObj) {
   const form = new FormData();
 
   Object.keys(formData).forEach((key) => {
@@ -112,105 +137,126 @@ export function postForm(
     }
   });
 
+  return form;
+}
+
+export function handleAxiosError(
+  error: any,
+  interactive: boolean,
+  httpsAgent: Agent,
+  refetch: (mode: PublishScheme, key: string) => Promise<any>,
+  onfail?: (status: number, statusText: string, response: string) => any,
+) {
+  if (!onfail) {
+    onfail = () => {
+      throw error;
+    };
+  }
+
+  if (error.response) {
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx
+    const { data, statusText, status } = error.response;
+
+    if (interactive && 'interactiveAuth' in data) {
+      const { interactiveAuth } = data;
+
+      if (typeof interactiveAuth === 'string') {
+        log(
+          'generalDebug_0003',
+          `Received status "${status}" from HTTP - trying interactive log in to "${interactiveAuth}".`,
+        );
+
+        return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) => refetch(mode, token));
+      }
+    }
+
+    const message = getMessage(data) || '';
+    return onfail(status, statusText, message);
+  } else if (error.isAxiosError) {
+    // axios initiated error: try to parse message from error object
+    let errorMessage: string = error.errno || 'Unknown Axios Error';
+
+    if (typeof error.toJSON === 'function') {
+      const errorObj: { message?: string } = error.toJSON();
+      errorMessage = errorObj?.message ?? errorMessage;
+    }
+
+    return onfail(500, undefined, errorMessage);
+  } else if (error.request) {
+    // The request was made but no response was received
+    // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+    // http.ClientRequest in node.js
+    return onfail(500, undefined, error.request);
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    return onfail(500, undefined, error.message);
+  }
+}
+
+export interface PostFormResult {
+  status: number;
+  success: boolean;
+  response?: object;
+}
+
+export async function postForm(
+  target: string,
+  scheme: PublishScheme,
+  key: string,
+  formData: FormDataObj,
+  customHeaders: Record<string, string> = {},
+  ca?: Buffer,
+  interactive = false,
+): Promise<PostFormResult> {
+  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+  const form = createAxiosForm(formData);
+
   const headers: Record<string, string> = {
     ...form.getHeaders(),
     ...standardHeaders,
     ...customHeaders,
+    ...getAuthorizationHeaders(scheme, key),
   };
 
-  if (key) {
-    switch (scheme) {
-      case 'basic':
-        headers.authorization = `Basic ${key}`;
-        break;
-      case 'bearer':
-        headers.authorization = `Bearer ${key}`;
-        break;
-      case 'digest':
-        headers.authorization = `Digest ${key}`;
-        break;
-      case 'none':
-      default:
-        headers.authorization = key;
-        break;
-    }
-  }
-
-  return axios.default
-    .post(target, form, {
+  try {
+    const res = await axios.default.post(target, form, {
       headers,
       httpsAgent,
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
-    })
-    .then(
-      (res) => {
-        return {
-          status: res.status,
-          success: true,
-          response: res.data,
-        };
-      },
-      (error) => {
-        if (error.response) {
-          // The request was made and the server responded with a status code
-          // that falls out of the range of 2xx
-          const { data, statusText, status } = error.response;
-
-          if (interactive && 'interactiveAuth' in data) {
-            const { interactiveAuth } = data;
-
-            if (typeof interactiveAuth === 'string') {
-              log(
-                'generalDebug_0003',
-                `Received status "${status}" from HTTP - trying interactive log in to "${interactiveAuth}".`,
-              );
-
-              return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) =>
-                postForm(target, mode, token, formData, customHeaders, ca, false),
-              );
-            }
-          }
-
-          const message = getMessage(data) || '';
-          log('unsuccessfulHttpPost_0066', statusText, status, message);
-          return {
-            status,
-            success: false,
-            response: message,
-          };
-        } else if (error.isAxiosError) {
-          // axios initiated error: try to parse message from error object
-          let errorMessage: string = error.errno || 'Unknown Axios Error';
-
-          if (typeof error.toJSON === 'function') {
-            const errorObj: { message?: string } = error.toJSON();
-            errorMessage = errorObj?.message ?? errorMessage;
-          }
+    });
 
-          log('failedHttpPost_0065', errorMessage);
+    return {
+      status: res.status,
+      success: true,
+      response: res.data,
+    };
+  } catch (error) {
+    return await handleAxiosError(
+      error,
+      interactive,
+      httpsAgent,
+      (mode, token) => postForm(target, mode, token, formData, customHeaders, ca, false),
+      (status, statusText, response) => {
+        if (status === 500) {
+          log('failedHttpPost_0065', response);
           return {
             status: 500,
             success: false,
-            response: errorMessage,
+            response: undefined,
           };
-        } else if (error.request) {
-          // The request was made but no response was received
-          // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
-          // http.ClientRequest in node.js
-          log('failedHttpPost_0065', error.request);
         } else {
-          // Something happened in setting up the request that triggered an Error
-          log('failedHttpPost_0065', error.message);
+          log('unsuccessfulHttpPost_0066', statusText, status, response);
+          return {
+            status,
+            success: false,
+            response,
+          };
         }
-
-        return {
-          status: 500,
-          success: false,
-          response: undefined,
-        };
       },
     );
+  }
 }
 
 export function postFile(

package/src/common/interactive.ts

@@ -69,10 +69,10 @@ export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResu
 
         try {
           while (true) {
-            const { data, status } = await axios.default.get(callbackUrl);
+            const { data, status } = await axios.default.get(callbackUrl, { httpsAgent, headers: standardHeaders });
 
             if (status === 202) {
-              await new Promise(resolve => setTimeout(resolve, 5000));
+              await new Promise((resolve) => setTimeout(resolve, 5000));
               continue;
             }
 

package/src/common/package.ts

@@ -158,7 +158,12 @@ async function loadPiralInstance(root: string, details?: PiralInstanceDetails):
   return appPackage;
 }
 
-export async function findPiralInstance(proposedApp: string, rootDir: string, details?: PiralInstanceDetails) {
+export async function findPiralInstance(
+  proposedApp: string,
+  rootDir: string,
+  details?: PiralInstanceDetails,
+  interactive = false,
+) {
   const path = findPackageRoot(proposedApp, rootDir);
   const url = details?.url;
 
@@ -167,7 +172,7 @@ export async function findPiralInstance(proposedApp: string, rootDir: string, de
 
     if (url) {
       log('generalDebug_0003', `Updating the emulator from remote "${url}" ...`);
-      await updateFromEmulatorWebsite(root, url);
+      await updateFromEmulatorWebsite(root, url, interactive);
     }
 
     return await loadPiralInstance(root, details);
@@ -185,6 +190,7 @@ export async function findPiralInstances(
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
   rootDir: string,
+  interactive?: boolean,
 ) {
   if (proposedApps) {
     // do nothing
@@ -202,7 +208,7 @@ export async function findPiralInstances(
   if (proposedApps.length > 0) {
     return Promise.all(
       proposedApps.map((proposedApp) =>
-        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp]),
+        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp], interactive),
       ),
     );
   }
@@ -776,13 +782,13 @@ export async function findPiletRoot(proposedRoot: string) {
   return dirname(packageJsonPath);
 }
 
-export async function retrievePiletData(target: string, app?: string) {
+export async function retrievePiletData(target: string, app?: string, 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);
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root, interactive);
   const apps: Array<AppDefinition> = [];
 
   for (const appPackage of appPackages) {