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

package/src/common/importmap.ts

@@ -0,0 +1,242 @@
+import { resolve, dirname, isAbsolute, basename } from 'path';
+import { log, fail } from './log';
+import { satisfies, validate } from './version';
+import { computeHash } from './hash';
+import { getHash, readJson, findFile, checkExists, checkIsDirectory } from './io';
+import { tryResolvePackage } from './npm';
+import { SharedDependency, Importmap } from '../types';
+
+const shorthandsUrls = ['', '.', '...'];
+
+function addLocalDependencies(
+  dependencies: Array<SharedDependency>,
+  realIdentifier: string,
+  identifier: string,
+  version: string,
+  requireVersion: string,
+  entry: string,
+  assetName: string,
+) {
+  const alias = realIdentifier !== identifier ? realIdentifier : undefined;
+
+  dependencies.push({
+    id: `${identifier}@${version}`,
+    requireId: `${identifier}@${requireVersion}`,
+    entry,
+    name: identifier,
+    ref: `${assetName}.js`,
+    type: 'local',
+    alias,
+  });
+}
+
+function getDependencyDetails(depName: string): [assetName: string, identifier: string, versionSpec: string] {
+  const sep = depName.indexOf('@', 1);
+  const version = sep > 0 ? depName.substring(sep + 1) : '';
+  const id = sep > 0 ? depName.substring(0, sep) : depName;
+  const assetName = (id.startsWith('@') ? id.substring(1) : id).replace(/[\/\.]/g, '-').replace(/(\-)+/, '-');
+  return [assetName, id, version];
+}
+
+async function getLocalDependencyVersion(
+  packageJson: string,
+  depName: string,
+  versionSpec: string,
+): Promise<[realIdentifier: string, offeredVersion: string, requiredVersion: string]> {
+  const packageDir = dirname(packageJson);
+  const packageFile = basename(packageJson);
+  const details = await readJson(packageDir, packageFile);
+
+  if (versionSpec) {
+    if (!validate(versionSpec)) {
+      fail('importMapVersionSpecInvalid_0026', depName);
+    }
+
+    if (!satisfies(details.version, versionSpec)) {
+      fail('importMapVersionSpecNotSatisfied_0025', depName, details.version);
+    }
+
+    return [details.name, details.version, versionSpec];
+  }
+
+  return [details.name, details.version, details.version];
+}
+
+async function getInheritedDependencies(inheritedImport: string, dir: string): Promise<Array<SharedDependency>> {
+  const packageJson = tryResolvePackage(`${inheritedImport}/package.json`, dir);
+
+  if (packageJson) {
+    const packageDir = dirname(packageJson);
+    const packageDetails = await readJson(packageDir, 'package.json');
+    return readImportmap(packageDir, packageDetails, true);
+  } else {
+    const directImportmap = tryResolvePackage(inheritedImport, dir);
+
+    if (directImportmap) {
+      const baseDir = dirname(directImportmap);
+      const content = await readJson(baseDir, basename(directImportmap));
+      return await resolveImportmap(baseDir, content);
+    }
+  }
+
+  return [];
+}
+
+async function resolveImportmap(dir: string, importmap: Importmap): Promise<Array<SharedDependency>> {
+  const dependencies: Array<SharedDependency> = [];
+  const sharedImports = importmap?.imports;
+  const inheritedImports = importmap?.inherit;
+
+  if (typeof sharedImports === 'object' && sharedImports) {
+    for (const depName of Object.keys(sharedImports)) {
+      const url = sharedImports[depName];
+      const [assetName, identifier, versionSpec] = getDependencyDetails(depName);
+
+      if (typeof url !== 'string') {
+        log('generalInfo_0000', `The value of "${depName}" in the importmap is not a string and will be ignored.`);
+      } else if (/^https?:\/\//.test(url)) {
+        const hash = computeHash(url).substring(0, 7);
+
+        dependencies.push({
+          id: `${identifier}@${hash}`,
+          requireId: `${identifier}@${hash}`,
+          entry: url,
+          name: identifier,
+          ref: url,
+          type: 'remote',
+        });
+      } else if (url === identifier || shorthandsUrls.includes(url)) {
+        const entry = tryResolvePackage(identifier, dir);
+
+        if (entry) {
+          const packageJson = await findFile(dirname(entry), 'package.json');
+          const [realIdentifier, version, requireVersion] = await getLocalDependencyVersion(
+            packageJson,
+            depName,
+            versionSpec,
+          );
+
+          addLocalDependencies(dependencies, realIdentifier, identifier, version, requireVersion, entry, assetName);
+        } else {
+          fail('importMapReferenceNotFound_0027', dir, identifier);
+        }
+      } else if (!url.startsWith('.') && !isAbsolute(url)) {
+        const entry = tryResolvePackage(url, dir);
+
+        if (entry) {
+          const packageJson = await findFile(dirname(entry), 'package.json');
+          const [realIdentifier, version, requireVersion] = await getLocalDependencyVersion(
+            packageJson,
+            depName,
+            versionSpec,
+          );
+
+          addLocalDependencies(dependencies, realIdentifier, identifier, version, requireVersion, entry, assetName);
+        } else {
+          fail('importMapReferenceNotFound_0027', dir, url);
+        }
+      } else {
+        const entry = resolve(dir, url);
+        const exists = await checkExists(entry);
+
+        if (exists) {
+          const isDirectory = await checkIsDirectory(entry);
+          const packageJson = isDirectory
+            ? resolve(entry, 'package.json')
+            : await findFile(dirname(entry), 'package.json');
+          const packageJsonExists = await checkExists(packageJson);
+
+          if (packageJsonExists) {
+            const [realIdentifier, version, requireVersion] = await getLocalDependencyVersion(
+              packageJson,
+              depName,
+              versionSpec,
+            );
+
+            addLocalDependencies(
+              dependencies,
+              realIdentifier,
+              identifier,
+              version,
+              requireVersion,
+              isDirectory ? tryResolvePackage(entry, dir) : entry,
+              assetName,
+            );
+          } else if (isDirectory) {
+            fail('importMapReferenceNotFound_0027', entry, 'package.json');
+          } else {
+            const hash = await getHash(entry);
+
+            dependencies.push({
+              id: `${identifier}@${hash}`,
+              requireId: `${identifier}@${hash}`,
+              entry,
+              name: identifier,
+              ref: `${assetName}.js`,
+              type: 'local',
+            });
+          }
+        } else {
+          fail('importMapReferenceNotFound_0027', dir, url);
+        }
+      }
+    }
+  }
+
+  if (Array.isArray(inheritedImports)) {
+    for (const inheritedImport of inheritedImports) {
+      const otherDependencies = await getInheritedDependencies(inheritedImport, dir);
+
+      for (const dependency of otherDependencies) {
+        const entry = dependencies.find((dep) => dep.name === dependency.name);
+
+        if (!entry) {
+          dependencies.push({
+            ...dependency,
+            parents: [inheritedImport],
+          });
+        } else if (Array.isArray(entry.parents)) {
+          entry.parents.push(inheritedImport);
+        }
+      }
+    }
+  }
+
+  return dependencies;
+}
+
+export async function readImportmap(
+  dir: string,
+  packageDetails: any,
+  inherited = false,
+): Promise<Array<SharedDependency>> {
+  const importmap = packageDetails.importmap;
+
+  if (typeof importmap === 'string') {
+    const notFound = {};
+    const content = await readJson(dir, importmap, notFound);
+
+    if (content === notFound) {
+      fail('importMapFileNotFound_0028', dir, importmap);
+    }
+
+    const baseDir = dirname(resolve(dir, importmap));
+    return await resolveImportmap(baseDir, content);
+  } else if (typeof importmap === 'undefined' && inherited) {
+    // Fall back to sharedDependencies or pilets.external if available
+    const shared: Array<string> = packageDetails.sharedDependencies ?? packageDetails.pilets?.externals;
+
+    if (Array.isArray(shared)) {
+      return shared.map((dep) => ({
+        id: dep,
+        name: dep,
+        entry: dep,
+        type: 'local',
+        ref: undefined,
+        requireId: dep,
+      }));
+    }
+  }
+
+  return await resolveImportmap(dir, importmap);
+}

package/src/common/index.ts

@@ -10,8 +10,11 @@ export * from './emoji';
 export * from './envs';
 export * from './hash';
 export * from './http';
+export * from './importmap';
 export * from './info';
 export * from './injectors';
+export * from './inspect';
+export * from './interactive';
 export * from './io';
 export * from './language';
 export * from './log';
@@ -19,10 +22,17 @@ export * from './merge';
 export * from './npm';
 export * from './pack';
 export * from './package';
+export * from './parallel';
 export * from './patcher';
 export * from './patches';
+export * from './platform';
 export * from './port';
 export * from './rules';
 export * from './scaffold';
 export * from './scripts';
+export * from './shell';
+export * from './spec';
 export * from './template';
+export * from './url';
+export * from './version';
+export * from './watcher';

package/src/common/info.ts

@@ -1,4 +1,7 @@
+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
@@ -12,9 +15,14 @@ export function findCompatVersion(version: string) {
   return major;
 }
 
-export const nodeVersion = process.version.substr(1);
+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,32 +1,59 @@
-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';
+import { chalk } from '../external';
 
-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>, api: string | false) {
+export function notifyServerOnline(path: string, api: string | false) {
   return (svc: any) => {
     log('generalDebug_0003', `The kras server for debugging is online!`);
     const address = `${svc.protocol}://localhost:${chalk.green(svc.port)}`;
-    logInfo(`${liveIcon} Running at ${chalk.bold(address)}`);
+    logInfo(`${liveIcon} Running at ${chalk.bold(address + path)}`);
     logInfo(`${settingsIcon} Manage via ${chalk.bold(address + api)}`);
     logReset();
-    bundlers.forEach((bundler) => bundler.start());
+  };
+}
+
+export function createInitialKrasConfig(
+  directory: string,
+  sources: Array<string> = [],
+  map: Record<string, 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,6 +1,7 @@
 import { dirname, basename } from 'path';
 import { unpackGzTar } from './archive';
-import { PackageData, PackageFiles } from '../types';
+import { jju } from '../external';
+import { PiletPackageData, PackageData, PackageFiles } from '../types';
 
 const packageRoot = 'package/';
 
@@ -8,22 +9,20 @@ 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) {
-  const paths = [
-    data.main,
-    `dist/${data.main}`,
-    `${data.main}/index.js`,
-    `dist/${data.main}/index.js`,
-    'index.js',
-    'dist/index.js',
-  ];
-  return paths.map((filePath) => `${packageRoot}${filePath}`).filter((filePath) => !!files[filePath])[0];
+export function getPossiblePiletMainPaths(data: PiletPackageData) {
+  const { main = 'index.js' } = data;
+  return [main, `dist/${main}`, `${main}/index.js`, `dist/${main}/index.js`, 'index.js', 'dist/index.js'];
 }
 
-export interface PiletPackageData extends PackageData {
+export function getPiletMainPath(data: PiletPackageData, files: PackageFiles) {
+  const paths = getPossiblePiletMainPaths(data);
+  return paths.map((filePath) => `${packageRoot}${filePath}`).find((filePath) => !!files[filePath]);
+}
+
+export interface InspectedPiletPackageData extends PiletPackageData {
   root: string;
 }
 
@@ -31,7 +30,7 @@ export function inspectPackage(stream: NodeJS.ReadableStream): Promise<PackageDa
   return unpackGzTar(stream).then((files) => getPackageJson(files));
 }
 
-export function inspectPilet(stream: NodeJS.ReadableStream): Promise<PiletPackageData> {
+export function inspectPilet(stream: NodeJS.ReadableStream): Promise<InspectedPiletPackageData> {
   return unpackGzTar(stream).then((files) => {
     const data = getPackageJson(files);
     const path = getPiletMainPath(data, files);

package/src/common/interactive.test.ts

@@ -3,6 +3,12 @@ import { promptConfirm, promptSelect } from './interactive';
 const answer = 'Yes, really';
 
 jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
+  ora() {
+    return {};
+  },
   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, logInfo } 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,66 @@ 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(async (res) => {
+        const { loginUrl, callbackUrl, expires } = res.data;
+        const now = new Date();
+        const then = new Date(expires);
+        const diff = ~~((then.valueOf() - now.valueOf()) / (60 * 1000));
+
+        logInfo(`Use the URL below to complete the login. The link expires in ${diff} minutes (${then}).`);
+        logInfo('===');
+        logInfo(loginUrl);
+        logInfo('===');
+
+        openBrowserAt(loginUrl);
+
+        try {
+          while (true) {
+            const { data, status } = await axios.default.get(callbackUrl);
+
+            if (status === 202) {
+              await new Promise(resolve => setTimeout(resolve, 5000));
+              continue;
+            }
+
+            if (status === 200) {
+              return { ...data };
+            }
+
+            throw new Error(`Could not get status from interactive login endpoint.`);
+          }
+        } catch (ex) {
+          throw ex;
+        } finally {
+          logResume();
+        }
+      });
+  }
+
+  return tokenRetrievers[url];
+}