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

package/src/common/clients/yarn.ts

@@ -1,10 +1,13 @@
 import { resolve } from 'path';
 import { log } from '../log';
+import { findFile } from '../io';
 import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
+// Helpers:
+
 function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the Yarn process ...');
+  log('generalDebug_0003', 'Starting the Yarn@1 process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('yarn', args, cwd, output);
 }
@@ -25,24 +28,50 @@ function convert(flags: Array<string>) {
   });
 }
 
+// Client interface functions:
+
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['install', ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn@1 install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn@1 install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, 'yarn.lock'));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listProjects(root);
+
+  if (typeof details === 'object') {
+    return typeof details?.[packageRef]?.location === 'string';
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from yarn client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
   try {
-    const ms = new MemoryStream();
-    await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
-    log('generalDebug_0003', `Yarn install package result: ${ms.value}`);
-    return ms.value;
-  } catch (ex) {
-    log(
-      'generalError_0002',
-      `Could not install the package "${packageRef}" using Yarn. Make sure Yarn@1 is correctly installed and accessible: ${ex}`,
-    );
-    throw ex;
+    await runYarnProcess(['workspaces', 'info'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `yarn workspaces error: ${e}`);
+    return {};
   }
+
+  log('generalDebug_0003', `yarn workspaces result: ${ms.value}`);
+  return JSON.parse(ms.value);
 }

package/src/common/declaration.ts

@@ -16,10 +16,16 @@ function findPiralBaseApi(root: string) {
     const projectDir = dirname(packageJsonPath);
     // By default support for piral-base < 0.15
     const { piletApiTypings = 'lib/types.d.ts' } = project;
-    return resolve(projectDir, piletApiTypings);
+
+    return [
+      {
+        file: resolve(projectDir, piletApiTypings),
+        name: 'PiletApi',
+      },
+    ];
   } catch (err) {
     log('generalError_0002', `Could not find the root API of "piral-base" from "${root}": ${err}`);
-    return undefined;
+    return [];
   }
 }
 
@@ -142,15 +148,15 @@ export async function createPiralDeclaration(
     root,
     files,
     types: findDeclaredTypings(root),
-    apis: [
-      {
-        file: findPiralBaseApi(root),
-        name: 'PiletApi',
-      },
-    ],
+    apis: findPiralBaseApi(root),
     imports: externals,
     logLevel,
     logger: createLogger(),
   };
-  return await createDeclarationFile(options, baseDir, target, forceOverwrite);
+
+  if (options.apis.length) {
+    return await createDeclarationFile(options, baseDir, target, forceOverwrite);
+  }
+
+  log('declarationCouldNotBeGenerated_0076', baseDir, 'The main Pilet API interface could not be found.');
 }

package/src/common/emulator.ts

@@ -3,7 +3,7 @@ import { findDependencyVersion, copyScaffoldingFiles, isValidDependency } from '
 import { createFileFromTemplateIfNotExists } from './template';
 import { filesTar, filesOnceTar } from './constants';
 import { cliVersion } from './info';
-import { createPackage, makeExternals } from './npm';
+import { createNpmPackage, makeExternals } from './npm';
 import { createPiralDeclaration } from './declaration';
 import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
@@ -31,7 +31,7 @@ export async function createEmulatorSources(
     ...piralPkg.devDependencies,
     ...piralPkg.dependencies,
   };
-  const allExternals = makeExternals(allDeps, piralPkg.pilets?.externals);
+  const allExternals = makeExternals(sourceDir, allDeps, piralPkg.pilets?.externals);
 
   const externalPackages = await Promise.all(
     allExternals.filter(isValidDependency).map(async (name) => ({
@@ -138,7 +138,7 @@ export async function createEmulatorSources(
 
 export async function packageEmulator(rootDir: string) {
   // finally package everything up
-  await createPackage(rootDir);
+  await createNpmPackage(rootDir);
 
   // get all files
   const names = await getFileNames(rootDir);

package/src/common/http.ts

@@ -1,17 +1,14 @@
 import { join } from 'path';
 import { Agent } from 'https';
 import { Stream } from 'stream';
-import { platform, tmpdir } from 'os';
+import { tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { standardHeaders } from './info';
+import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
 import { PiletPublishScheme } from '../types';
 
-const os = platform();
-const standardHeaders = {
-  'user-agent': `piral-cli/http.node-${os}`,
-};
-
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
     try {
@@ -60,27 +57,35 @@ export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>
     });
 }
 
-export interface PostFileResult {
+export interface PostFormResult {
   status: number;
   success: boolean;
   response?: object;
 }
 
-export function postFile(
+export type FormDataObj = Record<string, string | [Buffer, string]>;
+
+export function postForm(
   target: string,
   scheme: PiletPublishScheme,
   key: string,
-  file: Buffer,
-  customFields: Record<string, string> = {},
+  formData: FormDataObj,
   customHeaders: Record<string, string> = {},
   ca?: Buffer,
-): Promise<PostFileResult> {
-  const form = new FormData();
+  interactive = false,
+): Promise<PostFormResult> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
+  const form = new FormData();
 
-  Object.keys(customFields).forEach((key) => form.append(key, customFields[key]));
+  Object.keys(formData).forEach((key) => {
+    const value = formData[key];
 
-  form.append('file', file, 'pilet.tgz');
+    if (typeof value === 'string') {
+      form.append(key, value);
+    } else {
+      form.append(key, value[0], value[1]);
+    }
+  });
 
   const headers: Record<string, string> = {
     ...form.getHeaders(),
@@ -114,16 +119,34 @@ export function postFile(
       maxBodyLength: Infinity,
     })
     .then(
-      (res) => ({
-        status: res.status,
-        success: true,
-        response: res.data,
-      }),
+      (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 {
@@ -164,3 +187,17 @@ export function postFile(
       },
     );
 }
+
+export function postFile(
+  target: string,
+  scheme: PiletPublishScheme,
+  key: string,
+  file: Buffer,
+  customFields: Record<string, string> = {},
+  customHeaders: Record<string, string> = {},
+  ca?: Buffer,
+  interactive = false,
+): Promise<PostFormResult> {
+  const data: FormDataObj = { ...customFields, file: [file, 'pilet.tgz'] };
+  return postForm(target, scheme, key, data, customHeaders, ca, interactive);
+}

package/src/common/info.ts

@@ -1,6 +1,7 @@
-import { cpus } from 'os';
+import { cpus, platform } from 'os';
 
 const info = require('../../package.json');
+const os = platform();
 
 export function findCompatVersion(version: string) {
   // we only care about major and minor
@@ -15,9 +16,13 @@ export function findCompatVersion(version: string) {
 }
 
 export const nodeVersion = process.version.substring(1);
+export const cliName = info.name;
 export const cliVersion = info.version;
 export const compatVersion = findCompatVersion(cliVersion);
 export const repositoryUrl = info.repository.url;
 export const isWindows = process.platform === 'win32';
 export const pathSeparator = isWindows ? ';' : ':';
 export const cpuCount = cpus().length;
+export const standardHeaders = {
+  'user-agent': `piral-cli/http.node-${os}`,
+};

package/src/common/injectors.ts

@@ -1,25 +1,9 @@
 import chalk from 'chalk';
-import { KrasConfigurationInjectors } from 'kras';
+import { resolve } from 'path';
 import { liveIcon, settingsIcon } from './emoji';
 import { logInfo, log, logReset } from './log';
 import { Bundler } from '../types';
 
-export function reorderInjectors(injectorName: string, injectorConfig: any, injectors: KrasConfigurationInjectors) {
-  return {
-    script: injectors.script || {
-      active: true,
-    },
-    har: injectors.har || {
-      active: true,
-    },
-    json: injectors.json || {
-      active: true,
-    },
-    [injectorName]: injectorConfig,
-    ...injectors,
-  };
-}
-
 export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api: string | false) {
   return (svc: any) => {
     log('generalDebug_0003', `The kras server for debugging is online!`);
@@ -30,3 +14,48 @@ export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api:
     bundlers.forEach((bundler) => bundler.start());
   };
 }
+
+export function createInitialKrasConfig(
+  directory: string,
+  map: Record<string, string> = {},
+  sources: Array<string> = [],
+  feed: string | Array<string> = [],
+) {
+  return {
+    api: '/manage-mock-server',
+    directory,
+    map: {
+      '/': '',
+      ...map,
+    },
+    ssl: undefined,
+    sources,
+    injectorDirs: [resolve(__dirname, '../injectors')],
+    injectors: {
+      script: {
+        active: true,
+      },
+      har: {
+        active: true,
+        delay: false,
+      },
+      json: {
+        active: true,
+        randomize: true,
+      },
+      piral: {
+        active: true,
+        headers: {},
+      },
+      pilet: {
+        active: true,
+        meta: 'debug-meta.json',
+        headers: {},
+        feed,
+      },
+      proxy: {
+        active: true,
+      },
+    },
+  };
+}

package/src/common/inspect.ts

@@ -1,5 +1,6 @@
 import { dirname, basename } from 'path';
 import { unpackGzTar } from './archive';
+import { jju } from '../external';
 import { PackageData, PackageFiles } from '../types';
 
 const packageRoot = 'package/';
@@ -8,7 +9,7 @@ function getPackageJson(files: PackageFiles): PackageData {
   const fileName = `${packageRoot}package.json`;
   const fileContent = files[fileName];
   const content = fileContent.toString('utf8');
-  return JSON.parse(content);
+  return jju.parse(content);
 }
 
 function getPiletMainPath(data: PackageData, files: PackageFiles) {

package/src/common/interactive.test.ts

@@ -3,6 +3,9 @@ import { promptConfirm, promptSelect } from './interactive';
 const answer = 'Yes, really';
 
 jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
   inquirer: {
     prompt: (...any) => {
       return Promise.resolve({ q: answer });

package/src/common/interactive.ts

@@ -1,4 +1,9 @@
-import { inquirer } from '../external';
+import { Agent } from 'https';
+import { openBrowserAt } from './browser';
+import { standardHeaders } from './info';
+import { logSuspend } from './log';
+import { axios, inquirer } from '../external';
+import { PiletPublishScheme } from '../types';
 
 export function promptSelect(message: string, values: Array<string>, defaultValue: string): Promise<string> {
   const questions = [
@@ -24,3 +29,46 @@ export function promptConfirm(message: string, defaultValue: boolean): Promise<b
   ];
   return inquirer.prompt(questions).then((answers: any) => answers.q);
 }
+
+type TokenResult = Promise<{ mode: PiletPublishScheme; token: string }>;
+
+const tokenRetrievers: Record<string, TokenResult> = {};
+
+export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResult {
+  if (!(url in tokenRetrievers)) {
+    const logResume = logSuspend();
+
+    tokenRetrievers[url] = axios.default
+      .post(
+        url,
+        {
+          clientId: 'piral-cli',
+          clientName: 'Piral CLI',
+          description: 'Authorize the Piral CLI temporarily to perform actions in your name.',
+        },
+        {
+          headers: {
+            ...standardHeaders,
+            'content-type': 'application/json',
+          },
+          httpsAgent,
+        },
+      )
+      .then((res) => {
+        const { loginUrl, callbackUrl, expires } = res.data;
+        console.log(`Use the URL below to complete the login. The link expires at ${new Date(expires)}.`);
+        console.log('===');
+        console.log(loginUrl);
+        console.log('===');
+
+        openBrowserAt(loginUrl);
+
+        return axios.default
+          .get(callbackUrl)
+          .then(({ data }) => ({ ...data }))
+          .finally(logResume);
+      });
+  }
+
+  return tokenRetrievers[url];
+}

package/src/common/io.ts

@@ -239,7 +239,7 @@ export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
   const allPatterns = patterns.reduce<Array<AnyPattern>>((agg, curr) => {
     const patterns = [];
 
-    if (/[a-zA-Z0-9\-\*]+$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
+    if (/[a-zA-Z0-9\-\*]$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
       patterns.push(curr, `${curr}.{${exts}}`, `${curr}/${nameOfPackageJson}`);
     } else if (curr.endsWith('/')) {
       patterns.push(`${curr}index.{${exts}}`, `${curr}${nameOfPackageJson}`);

package/src/common/log.ts

@@ -8,6 +8,7 @@ import { LogLevels, QuickMessage } from '../types';
 
 type Messages = typeof messages;
 type MessageTypes = keyof Messages;
+let currentProgress: string = undefined;
 
 const logger = (() => {
   try {
@@ -92,7 +93,8 @@ export function logFail(message: string, ...args: Array<string | number | boolea
 }
 
 export function progress(message: string, ...args: Array<string | number | boolean>) {
-  logger.progress(format(message, ...args));
+  currentProgress = format(message, ...args)
+  logger.progress(currentProgress);
 }
 
 export function logReset() {
@@ -100,6 +102,12 @@ export function logReset() {
   logger.stopSpinner();
 }
 
+export function logSuspend() {
+  logReset();
+
+  return () => logger.progress(currentProgress);
+}
+
 export function fail<T extends MessageTypes>(type: T, ...args: Parameters<Messages[T]>): never {
   const message = log(type, ...args);
   const error = new Error(message);