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

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 {
@@ -74,6 +71,7 @@ export function postFile(
   customFields: Record<string, string> = {},
   customHeaders: Record<string, string> = {},
   ca?: Buffer,
+  interactive = false,
 ): Promise<PostFileResult> {
   const form = new FormData();
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
@@ -124,6 +122,22 @@ export function postFile(
           // 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 }) =>
+                postFile(target, mode, token, file, customFields, customHeaders, ca, false),
+              );
+            }
+          }
+
           const message = getMessage(data) || '';
           log('unsuccessfulHttpPost_0066', statusText, status, message);
           return {

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/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,8 @@
-import { inquirer } from '../external';
+import { Agent } from 'https';
+import { openBrowserAt } from './browser';
+import { standardHeaders } from './info';
+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 +28,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)) {
+    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 }) => {
+          console.log('Logged in successfully.');
+          return {
+            ...data,
+          };
+        });
+      });
+  }
+
+  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/npm.test.ts

@@ -1,16 +1,12 @@
 import { resolve } from 'path';
+import { clients } from './clients';
 import {
   dissectPackageName,
-  installPackage,
-  detectNpm,
-  detectPnpm,
-  detectYarn,
+  installNpmPackage,
   isMonorepoPackageRef,
-  detectMonorepo,
-  bootstrapMonorepo,
-  installDependencies,
-  createPackage,
-  findTarball,
+  installNpmDependencies,
+  createNpmPackage,
+  findNpmTarball,
   findSpecificVersion,
   findLatestVersion,
   isLocalPackage,
@@ -43,9 +39,10 @@ jest.mock('../external', () => ({
 }));
 
 let specialCase = false;
+let shouldFind = true;
 let wrongCase = false;
-const jsonValueString = JSON.stringify({ dependencies: { npm: { extraneous: true } } });
-const jsonValueStringWrong = JSON.stringify({ dependencies: {} });
+const jsonValueString = JSON.stringify([{ name: 'npm' }]);
+const jsonValueStringWrong = JSON.stringify([]);
 
 jest.mock('./scripts', () => ({
   runCommand: (exe: string, args: Array<string>, cwd: string, output?: NodeJS.WritableStream) => {
@@ -57,14 +54,15 @@ jest.mock('./scripts', () => ({
 }));
 
 jest.mock('fs', () => ({
-  constants: {
-    F_OK: 1,
-  },
   createReadStream() {
     return undefined;
   },
   exists: (file: string, cb: (status: boolean) => void) =>
-    cb(!file.endsWith('package.json') && !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock')))),
+    cb(
+      shouldFind &&
+        !file.endsWith('package.json') &&
+        !(specialCase && (file.endsWith('lerna.json') || file.endsWith('yarn.lock'))),
+    ),
   existsSync: (file: string) => {
     return true;
   },
@@ -73,13 +71,6 @@ jest.mock('fs', () => ({
   },
   realpathSync: () => ({}),
   readFileSync: () => '',
-  access: (path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void) => {
-    if (path.includes('test')) {
-      return callback(undefined);
-    } else {
-      return callback(new Error('bla'));
-    }
-  },
 }));
 
 describe('npm Module', () => {
@@ -187,55 +178,66 @@ describe('npm Module', () => {
 
   it('installs a package using the npm command line tool without a target', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Yarn command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Pnpm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool with some flag', async () => {
     wrongCase = false;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+      expect(result).toEqual(jsonValueString),
+    );
     wrongCase = true;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).not.toEqual(jsonValueString),
     );
   });
 
   it('detectNpm finds package-lock.json', async () => {
-    await detectNpm('test').then((result) => expect(result).toBeTruthy());
-    await detectNpm('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
+    await clients.npm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.npm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
-  it('detectPnpm finds nppm-lock.yaml', async () => {
-    await detectPnpm('test').then((result) => expect(result).toBeTruthy());
-    await detectPnpm('toast').then((result) => expect(result).toBeFalsy());
+  it('detectPnpm finds pnpm-lock.yaml', async () => {
+    shouldFind = true;
+    await clients.pnpm.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
+    await clients.pnpm.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
   });
 
   it('detectYarn finds yarn.lock', async () => {
-    await detectYarn('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = true;
+    await clients.yarn.detectClient('test').then((result) => expect(result).toBeTruthy());
+    shouldFind = false;
     specialCase = true;
-    await detectYarn('toast').then((result) => expect(result).toBeFalsy());
+    await clients.yarn.detectClient('toast').then((result) => expect(result).toBeFalsy());
+    shouldFind = true;
     specialCase = false;
   });
 
@@ -246,59 +248,46 @@ describe('npm Module', () => {
     await isMonorepoPackageRef('npm', './').then((result) => expect(result).toBeFalsy());
   });
 
-  it('verifies whether lerna config path is valid', async () => {
-    wrongCase = false;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('lerna');
-    });
-    wrongCase = true;
-    specialCase = true;
-    await detectMonorepo('./').then((result) => {
-      expect(result).toBe('none');
-    });
-    specialCase = false;
-  });
-
   it('verifies whether lerna bootstrap ran', async () => {
     wrongCase = false;
-    await bootstrapMonorepo().then((result) => expect(result).toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await bootstrapMonorepo().then((result) => expect(result).not.toEqual(jsonValueString));
+    await clients.lerna.installDependencies().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with npm client', async () => {
     wrongCase = false;
-    await installDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with pnpm client', async () => {
     wrongCase = false;
-    await installDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with yarn client', async () => {
     wrongCase = false;
-    await installDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('create npm package', async () => {
     wrongCase = false;
-    await createPackage().then((result) => expect(result).toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await createPackage().then((result) => expect(result).not.toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find npm tarball', async () => {
     wrongCase = false;
-    await findTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await findTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find latest version', async () => {
@@ -315,17 +304,61 @@ describe('npm Module', () => {
     await findSpecificVersion('foo', '1.0.0').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('check if package is local', () => {
-    let result = isLocalPackage('./', 'file://foo.tgz');
+  it('check if package from full file is local', () => {
+    const result = isLocalPackage('./', 'file://foo.tgz');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', './');
+  });
+
+  it('check if package from current dir is local', () => {
+    const result = isLocalPackage('./', './');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', 'foo.tgz');
+  });
+
+  it('check if package from file is local', () => {
+    const result = isLocalPackage('./', 'foo.tgz');
+    expect(result).toBeTruthy();
+  });
+
+  it('check if package from nothing is not local', () => {
+    const result = isLocalPackage('./', null);
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from tilde version is not local', () => {
+    const result = isLocalPackage('./', '~12.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from caret version is not local', () => {
+    const result = isLocalPackage('./', '^12.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from star version is not local', () => {
+    const result = isLocalPackage('./', '*');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from greater than is not local', () => {
+    const result = isLocalPackage('./', '>=1.0.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('check if package from home dir is local', () => {
+    const result = isLocalPackage('./', '~/foo/bar');
     expect(result).toBeTruthy();
-    result = isLocalPackage('./', null);
+  });
+
+  it('check if package from zero is not local', () => {
+    const result = isLocalPackage('./', '.0');
     expect(result).toBeFalsy();
   });
 
+  it('check if package from absolute dir is local', () => {
+    const result = isLocalPackage('./', '/0');
+    expect(result).toBeTruthy();
+  });
+
   it('check if package is coming from git', () => {
     let result = isGitPackage('https://.foo.git');
     expect(result).toBeTruthy();
@@ -420,7 +453,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals without externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' });
+    const externals = makeExternals(process.cwd(), { piral: '*' });
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -435,7 +468,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, []);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, []);
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -450,12 +483,12 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with exclude coreExternals returns empty set', () => {
-    const externals = makeExternals({ piral: '*' }, ['!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['!*']);
     expect(externals).toEqual([]);
   });
 
   it('makeExternals with externals concats coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['foo', 'bar']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
     expect(externals).toEqual([
       'foo',
       'bar',
@@ -472,7 +505,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'foo']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'foo']);
     expect(externals).toEqual([
       'react',
       'foo',
@@ -488,7 +521,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with explicit include and exclude', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-calendar', '!history']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-calendar', '!history']);
     expect(externals).toEqual([
       'react',
       'react-calendar',
@@ -503,7 +536,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with all exclude and explicit include', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-router-dom', '!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-router-dom', '!*']);
     expect(externals).toEqual(['react', 'react-router-dom']);
   });
 });