piral-cli 1.0.0-pre.2296 → 1.0.1-beta.5640

package/src/common/npm.ts

@@ -1,65 +1,66 @@
-import { resolve, relative } from 'path';
-import { createReadStream, existsSync, access, constants } from 'fs';
+import { resolve, relative, dirname } from 'path';
+import { createReadStream, existsSync } from 'fs';
 import { log, fail } from './log';
+import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
+import { legacyCoreExternals, frameworkLibs, defaultRegistry, packageJson } from './constants';
 import { inspectPackage } from './inspect';
-import { coreExternals } from './constants';
-import { readJson, checkExists, findFile } from './io';
+import { readJson, checkExists } from './io';
 import { clientTypeKeys } from '../helpers';
+import { getModulePath } from '../external';
 import { PackageType, NpmClientType } from '../types';
 
 const gitPrefix = 'git+';
 const filePrefix = 'file:';
+const npmPrefix = 'npm:';
+const pathPrefixes = ['/', './', '../', '.\\', '..\\', '~/', '~\\', filePrefix];
 
 function isProjectReference(name: string) {
-  const target = resolve(name, 'package.json');
+  const target = resolve(name, packageJson);
   return checkExists(target);
 }
 
-export function detectPnpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'pnpm-lock.yaml'), constants.F_OK, (noPnpmLock) => {
-      res(!noPnpmLock);
-    });
-  });
+function resolveAbsPath(basePath: string, fullName: string) {
+  const prefixed = fullName.startsWith(filePrefix);
+  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
+  return resolve(basePath, relPath);
 }
 
-export function detectNpm(root: string) {
-  return new Promise((res) => {
-    access(resolve(root, 'package-lock.json'), constants.F_OK, (noPackageLock) => {
-      res(!noPackageLock);
-    });
-  });
-}
+async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClientType]> {
+  let previous = root;
 
-export async function detectYarn(root: string) {
-  return !!(await findFile(root, 'yarn.lock'));
-}
+  do {
+    if (await checkExists(resolve(root, 'lerna.json'))) {
+      return [root, 'lerna'];
+    }
 
-export async function getLernaConfigPath(root: string) {
-  log('generalDebug_0003', 'Trying to get the configuration file for Lerna ...');
-  const file = await findFile(root, 'lerna.json');
+    if (await checkExists(resolve(root, 'rush.json'))) {
+      return [root, 'rush'];
+    }
 
-  if (file) {
-    log('generalDebug_0003', `Found Lerna config in "${file}".`);
-    return file;
-  }
+    if (await checkExists(resolve(root, 'pnpm-workspace.yaml'))) {
+      return [root, 'pnpm'];
+    }
 
-  return undefined;
-}
+    const pj = await readJson(root, packageJson);
 
-export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
-  const file = await getLernaConfigPath(root);
+    if (Array.isArray(pj?.workspaces)) {
+      if (await checkExists(resolve(root, '.pnp.cjs'))) {
+        return [root, 'pnp'];
+      }
 
-  if (file) {
-    try {
-      return require(file).npmClient;
-    } catch (err) {
-      log('generalError_0002', `Could not read lerna.json: ${err}.`);
+      if (await checkExists(resolve(root, 'yarn.lock'))) {
+        return [root, 'yarn'];
+      }
+
+      return [root, 'npm'];
     }
-  }
 
-  return undefined;
+    previous = root;
+    root = dirname(root);
+  } while (root !== previous);
+
+  return [];
 }
 
 /**
@@ -69,36 +70,45 @@ export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
  */
 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 files ...');
-    const [hasNpm, hasYarn, hasPnpm] = await Promise.all([detectNpm(root), detectYarn(root), detectPnpm(root)]);
-    const found = +hasNpm + +hasYarn + +hasPnpm;
-    log('generalDebug_0003', `Results of the lock file check: NPM = ${hasNpm}, Yarn = ${hasYarn}, Pnpm = ${hasPnpm}`);
-    const defaultClient = config.npmClient;
+    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+
+    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 > 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}".`);
+      }
+    }
 
-    if (found !== 1) {
-      const lernaClient = await getLernaNpmClient(root);
+    if (foundClients.length > 0) {
+      const { client } = foundClients[0];
 
-      if (clientTypeKeys.includes(lernaClient)) {
-        log('generalDebug_0003', `Found valid NPM client via Lerna: ${lernaClient}.`);
-        return lernaClient;
+      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}.`);
       }
-    } else if (hasNpm) {
-      log('generalDebug_0003', `Found valid NPM client via lockfile.`);
-      return 'npm';
-    } else if (hasYarn) {
-      log('generalDebug_0003', `Found valid Yarn client via lockfile.`);
-      return 'yarn';
-    } else if (hasPnpm) {
-      log('generalDebug_0003', `Found valid Pnpm client via lockfile.`);
-      return 'pnpm';
+
+      log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+      return client;
     }
 
+    const defaultClient = config.npmClient;
+
     if (clientTypeKeys.includes(defaultClient)) {
-      log('generalDebug_0003', `Found valid Pnpm client the default client: "${defaultClient}".`);
+      log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
       return defaultClient;
     }
 
-    log('generalDebug_0003', 'Using the default NPM client.');
+    log('generalDebug_0003', 'Using the fallback "npm" client.');
     return 'npm';
   }
 
@@ -106,70 +116,111 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
-  const c = require(`./clients/npm`);
-  const details = await c.listPackage(refName, root);
-  return details?.dependencies?.[refName]?.extraneous ?? false;
-}
-
-export type MonorepoKind = 'none' | 'lerna' | 'yarn';
+  const [monorepoRoot, client] = await detectMonorepoRoot(root);
 
-export async function detectMonorepo(root: string): Promise<MonorepoKind> {
-  const file = await getLernaConfigPath(root);
-
-  if (file !== undefined) {
-    return 'lerna';
+  if (monorepoRoot) {
+    const c = clients[client];
+    return await c.isProject(monorepoRoot, refName);
   }
 
-  const packageJson = await readJson(root, 'package.json');
-
-  if (Array.isArray(packageJson?.workspaces)) {
-    return 'yarn';
-  }
+  return false;
+}
 
-  return 'none';
+export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
+  const { installDependencies } = clients[client];
+  return installDependencies(target);
 }
 
-export function bootstrapMonorepo(target = '.') {
-  const c = require(`./clients/lerna`);
-  return c.bootstrap(target);
+export async function installNpmPackageFromOptionalRegistry(
+  packageRef: string,
+  target = '.',
+  registry: string,
+): Promise<void> {
+  try {
+    await installNpmPackage('npm', packageRef, target, '--registry', registry);
+  } catch (e) {
+    if (registry === defaultRegistry) {
+      throw e;
+    }
+
+    await installNpmPackage('npm', packageRef, target, '--registry', defaultRegistry);
+  }
 }
 
-export function installDependencies(client: NpmClientType, target = '.'): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installDependencies(target);
+export async function uninstallNpmPackage(
+  client: NpmClientType,
+  packageRef: string,
+  target = '.',
+  ...flags: Array<string>
+): Promise<string> {
+  try {
+    const { uninstallPackage } = clients[client];
+    return await uninstallPackage(packageRef, target, ...flags);
+  } catch (ex) {
+    log(
+      'generalError_0002',
+      `Could not uninstall the package "${packageRef}" using ${client}. Make sure ${client} is correctly installed and accessible: ${ex}`,
+    );
+    throw ex;
+  }
 }
 
-export function installPackage(
+export async function installNpmPackage(
   client: NpmClientType,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
-  const c = require(`./clients/${client}`);
-  return c.installPackage(packageRef, target, ...flags);
+  try {
+    const { installPackage } = clients[client];
+    return await installPackage(packageRef, target, ...flags);
+  } catch (ex) {
+    log(
+      'generalError_0002',
+      `Could not install the package "${packageRef}" using ${client}. Make sure ${client} is correctly installed and accessible: ${ex}`,
+    );
+    throw ex;
+  }
+}
+
+export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
+  const { initProject } = clients[client];
+  return initProject(projectName, target);
 }
 
-export function publishPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.publishPackage(target, file, ...flags);
+export function publishNpmPackage(
+  target = '.',
+  file = '*.tgz',
+  flags: Array<string> = [],
+  interactive = false,
+): Promise<string> {
+  const { publishPackage, loginUser } = clients.npm;
+  return publishPackage(target, file, ...flags).catch(err => {
+    if (!interactive) {
+      throw err;
+    }
+
+    return loginUser().then(() => publishNpmPackage(target, file, flags, false));
+  });
 }
 
-export function createPackage(target = '.'): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.createPackage(target);
+export function createNpmPackage(target = '.'): Promise<string> {
+  const { createPackage } = clients.npm;
+  return createPackage(target);
 }
 
-export function findTarball(packageRef: string) {
-  const c = require(`./clients/npm`);
-  return c.findTarball(packageRef);
+export function findNpmTarball(packageRef: string): Promise<string> {
+  const { findTarball } = clients.npm;
+  return findTarball(packageRef);
 }
 
 export function findSpecificVersion(packageName: string, version: string): Promise<string> {
-  const c = require(`./clients/npm`);
-  return c.findSpecificVersion(packageName, version);
+  const { findSpecificVersion } = clients.npm;
+  return findSpecificVersion(packageName, version);
 }
 
 export function findLatestVersion(packageName: string) {
+  const { findSpecificVersion } = clients.npm;
   return findSpecificVersion(packageName, 'latest');
 }
 
@@ -177,7 +228,7 @@ export function isLocalPackage(baseDir: string, fullName: string) {
   log('generalDebug_0003', 'Checking if its a local package ...');
 
   if (fullName) {
-    if (/^[\.\/\~]/.test(fullName)) {
+    if (pathPrefixes.some((prefix) => fullName.startsWith(prefix))) {
       log('generalDebug_0003', 'Found a local package by name.');
       return true;
     } else if (fullName.endsWith('.tgz')) {
@@ -195,6 +246,25 @@ export function isLocalPackage(baseDir: string, fullName: string) {
   return false;
 }
 
+export function isNpmPackage(fullName: string) {
+  log('generalDebug_0003', 'Checking if its an npm alias ...');
+
+  if (fullName) {
+    const npmed = fullName.startsWith(npmPrefix);
+
+    if (npmed && fullName.substring(npmPrefix.length + 1).indexOf('@') !== -1) {
+      log('generalDebug_0003', 'Found an npm package alias by name.');
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function makeNpmAlias(name: string, version: string) {
+  return `${npmPrefix}${name}@${version}`;
+}
+
 export function isGitPackage(fullName: string) {
   log('generalDebug_0003', 'Checking if its a Git package ...');
 
@@ -216,9 +286,7 @@ export function makeGitUrl(fullName: string) {
 }
 
 export function makeFilePath(basePath: string, fullName: string) {
-  const prefixed = fullName.startsWith(filePrefix);
-  const relPath = !prefixed ? fullName : fullName.replace(filePrefix, '');
-  const absPath = resolve(basePath, relPath);
+  const absPath = resolveAbsPath(basePath, fullName);
   return `${filePrefix}${absPath}`;
 }
 
@@ -242,7 +310,7 @@ export async function dissectPackageName(
     const gitUrl = makeGitUrl(fullName);
     return [gitUrl, 'latest', false, 'git'];
   } else if (isLocalPackage(baseDir, fullName)) {
-    const fullPath = resolve(baseDir, fullName);
+    const fullPath = resolveAbsPath(baseDir, fullName);
     const exists = await checkExists(fullPath);
 
     if (!exists) {
@@ -261,7 +329,7 @@ export async function dissectPackageName(
     const type = 'registry';
 
     if (index !== -1) {
-      return [fullName.substr(0, index), fullName.substr(index + 1), true, type];
+      return [fullName.substring(0, index), fullName.substring(index + 1), true, type];
     }
 
     return [fullName, 'latest', false, type];
@@ -321,12 +389,35 @@ export async function getCurrentPackageDetails(
   return [combinePackageRef(sourceName, desired, 'registry'), desired];
 }
 
-export function isLinkedPackage(name: string, type: PackageType, hadVersion: boolean) {
+function tryResolve(packageName: string, baseDir = process.cwd()) {
+  try {
+    return getModulePath(baseDir, packageName);
+  } catch {
+    return undefined;
+  }
+}
+
+export function tryResolvePackage(name: string, baseDir: string = undefined) {
+  const path = baseDir ? tryResolve(name, baseDir) : tryResolve(name);
+  const root = baseDir || process.cwd();
+
+  if (!path) {
+    log('generalDebug_0003', `Could not resolve the package "${name}" in "${root}".`);
+  } else {
+    log('generalVerbose_0004', `Resolved the package "${name}" (from "${root}") to be "${path}".`);
+  }
+
+  return path;
+}
+
+export function findPackageRoot(pck: string, baseDir: string) {
+  return tryResolvePackage(`${pck}/${packageJson}`, baseDir);
+}
+
+export function isLinkedPackage(name: string, type: PackageType, hadVersion: boolean, target: string) {
   if (type === 'registry' && !hadVersion) {
-    try {
-      require.resolve(`${name}/package.json`);
-      return true;
-    } catch {}
+    const root = findPackageRoot(name, target);
+    return typeof root === 'string';
   }
 
   return false;
@@ -334,27 +425,34 @@ export function isLinkedPackage(name: string, type: PackageType, hadVersion: boo
 
 export function combinePackageRef(name: string, version: string, type: PackageType) {
   if (type === 'registry') {
-    return `${name}@${version || 'latest'}`;
+    const tag = version || 'latest';
+    return `${name}@${tag}`;
   }
 
   return name;
 }
 
-export async function getPackageName(root: string, name: string, type: PackageType) {
+export async function getPackageName(root: string, name: string, type: PackageType): Promise<string> {
   switch (type) {
     case 'file':
-      const originalPackageJson = await readJson(name, 'package.json');
+      const originalPackageJson = await readJson(name, packageJson);
 
       if (!originalPackageJson.name) {
         const p = resolve(process.cwd(), name);
-        const s = createReadStream(p);
-        const i = await inspectPackage(s);
-        return i.name;
+
+        try {
+          const s = createReadStream(p);
+          const i = await inspectPackage(s);
+          return i.name;
+        } catch (err) {
+          log('generalError_0002', `Could not open package tarball at "${p}": "${err}`);
+          return undefined;
+        }
       }
 
       return originalPackageJson.name;
     case 'git':
-      const pj = await readJson(root, 'package.json');
+      const pj = await readJson(root, packageJson);
       const dd = pj.devDependencies || {};
       return Object.keys(dd).filter((dep) => dd[dep] === name)[0];
     case 'registry':
@@ -388,13 +486,54 @@ export function getPackageVersion(
   }
 }
 
-export function makeExternals(externals?: Array<string>) {
-  if (externals && Array.isArray(externals)) {
-    const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
+async function getExternalsFrom(root: string, packageName: string): Promise<Array<string> | undefined> {
+  try {
+    const target = getModulePath(root, `${packageName}/${packageJson}`);
+    const dir = dirname(target);
+    const { sharedDependencies } = await readJson(dir, packageJson);
+    return sharedDependencies;
+  } catch (err) {
+    log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
+    return undefined;
+  }
+}
+
+async function getCoreExternals(root: string, dependencies: Record<string, string>): Promise<Array<string>> {
+  for (const frameworkLib of frameworkLibs) {
+    if (dependencies[frameworkLib]) {
+      const deps = await getExternalsFrom(root, frameworkLib);
+
+      if (deps) {
+        return deps;
+      }
+    }
+  }
+
+  log('frameworkLibMissing_0078', frameworkLibs);
+  return [];
+}
+
+export async function makePiletExternals(
+  root: string,
+  dependencies: Record<string, string>,
+  fromEmulator: boolean,
+  piralInfo: any,
+): Promise<Array<string>> {
+  if (fromEmulator) {
+    const { sharedDependencies = legacyCoreExternals } = piralInfo;
+    return sharedDependencies;
+  } else {
+    return await getCoreExternals(root, dependencies);
+  }
+}
+
+export function mergeExternals(customExternals?: Array<string>, coreExternals: Array<string> = []) {
+  if (customExternals && Array.isArray(customExternals)) {
+    const [include, exclude] = customExternals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {
         if (typeof curr === 'string') {
           if (curr.startsWith('!')) {
-            prev[1].push(curr.substr(1));
+            prev[1].push(curr.substring(1));
           } else {
             prev[0].push(curr);
           }
@@ -410,3 +549,8 @@ export function makeExternals(externals?: Array<string>) {
 
   return coreExternals;
 }
+
+export async function makeExternals(root: string, dependencies: Record<string, string>, externals: Array<string>) {
+  const coreExternals = await getCoreExternals(root, dependencies);
+  return mergeExternals(externals, coreExternals);
+}

package/src/common/pack.test.ts

@@ -1,21 +1,19 @@
 import { createPiletPackage } from './pack';
 import { resolve } from 'path';
 
-let json = {};
+let json: any = {};
 
 jest.mock('./io', () => ({
-  readJson: (dir: string, source: string) => {
-    return json;
-  },
-  move: (source: string, target: string, forceOverwrite?: any) => {
-    return Promise.resolve('foo');
-  },
+  readJson: jest.fn(() => json),
+  removeDirectory: jest.fn(() => Promise.resolve()),
+  makeTempDir: jest.fn(() => Promise.resolve('')),
+  copy: jest.fn(() => Promise.resolve()),
+  checkExists: jest.fn(() => Promise.resolve(true)),
+  createDirectory: jest.fn(() => Promise.resolve()),
 }));
 
-jest.mock('./npm', () => ({
-  createPackage: (target?: string) => {
-    return Promise.resolve(target);
-  },
+jest.mock('./archive', () => ({
+  createTgz: jest.fn(() => Promise.resolve()),
 }));
 
 describe('Pack Module', () => {
@@ -51,7 +49,7 @@ describe('Pack Module', () => {
 
   it('createPilePackage source <> target', async () => {
     json = { name: 'foo', version: '1.0.0' };
-    const path = resolve('./', 'foo-1.0.0.tgz');
-    await expect(createPiletPackage('./', '', 'test')).resolves.toEqual('foo');
+    const path = resolve('./', 'test', 'foo-1.0.0.tgz');
+    await expect(createPiletPackage('./', '', 'test')).resolves.toEqual(path);
   });
 });

package/src/common/pack.ts

@@ -1,20 +1,23 @@
-import { resolve, join } from 'path';
+import { tmpdir } from 'os';
+import { resolve, relative, join, dirname, basename } from 'path';
+import { createTgz } from './archive';
+import { onlyUnique } from './utils';
 import { log, progress, fail } from './log';
-import { readJson, move } from './io';
-import { createPackage } from './npm';
-import { ForceOverwrite } from './enums';
-
-async function getFile(root: string, name: string, dest: string) {
-  const proposed = join(root, name);
-
-  if (dest !== root) {
-    log('generalDebug_0003', `Moving file from "${root}" to "${dest}" ...`);
-    const file = await move(proposed, dest, ForceOverwrite.yes);
-    log('generalDebug_0003', 'Successfully moved file.');
-    return file;
+import { readJson, copy, removeDirectory, checkExists, makeTempDir, createDirectory } from './io';
+import { getPossiblePiletMainPaths } from './inspect';
+
+async function getPiletContentDir(root: string, packageData: any) {
+  const paths = getPossiblePiletMainPaths(packageData);
+
+  for (const path of paths) {
+    const file = resolve(root, path);
+
+    if (await checkExists(file)) {
+      return dirname(file);
+    }
   }
 
-  return proposed;
+  return root;
 }
 
 export async function createPiletPackage(baseDir: string, source: string, target: string) {
@@ -36,13 +39,49 @@ export async function createPiletPackage(baseDir: string, source: string, target
     fail('packageJsonMissingVersion_0022');
   }
 
-  progress(`Packing pilet in ${dest} ...`);
-  log('generalDebug_0003', 'Creating package ...');
-  await createPackage(root);
-  log('generalDebug_0003', 'Successfully created package.');
-  const name = `${pckg.name}-${pckg.version}.tgz`.replace(/@/g, '').replace(/\//g, '-');
-  log('generalDebug_0003', `Assumed package name "${name}".`);
-  const file = await getFile(root, name, dest);
+  const isFileTarget = target.endsWith('.tgz');
+  progress(`Packing pilet in "${root}" ...`);
+
+  const pckgName = pckg.name.replace(/@/g, '').replace(/\//g, '-');
+  const id = `${pckgName}-${pckg.version}`;
+  const name = isFileTarget ? basename(target) : `${id}.tgz`;
+  const file = isFileTarget ? dest : resolve(dest, name);
+  log('generalDebug_0003', `Assume package name "${name}".`);
+
+  const content = await getPiletContentDir(root, pckg);
+  const files = [resolve(root, 'package.json'), content];
+  const readme = resolve(root, 'README.md');
+
+  if (Array.isArray(pckg.files)) {
+    files.push(...pckg.files.map((f) => resolve(root, f)));
+  }
+
+  if (await checkExists(readme)) {
+    files.push(readme);
+  }
+
+  const prefix = join(tmpdir(), `${id}-`);
+  const cwd = await makeTempDir(prefix);
+  log('generalDebug_0003', `Creating package with content from "${content}" ...`);
+
+  await Promise.all(files.filter(onlyUnique).map((file) => copy(file, resolve(cwd, relative(root, file)))));
+
+  log('generalDebug_0003', `Creating directory if not exist for "${file}" ...`);
+
+  await createDirectory(dirname(file));
+
+  log('generalDebug_0003', `Creating compressed archive at "${file}" relative to "${root}" ...`);
+
+  await createTgz(
+    file,
+    cwd,
+    files.map((f) => relative(root, f)),
+  );
+
+  log('generalDebug_0003', `Successfully created package from "${cwd}".`);
+
+  await removeDirectory(cwd);
+
   log('generalDebug_0003', `Packed file "${file}".`);
   return file;
 }