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

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,16 +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 install package result: ${ms.value}`);
+  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 {
+    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/config.ts

@@ -72,11 +72,11 @@ export const config: PiralCliConfig = rc(
     apiKeys: {},
     url: undefined,
     cert: undefined,
-    npmClient: 'npm',
-    bundler: 'webpack5',
+    npmClient: 'npm' as const,
+    bundler: 'webpack5' as const,
     piletApi: '/$pilet-api',
     validators: {},
-    schemaVersion: 'v2',
+    schemaVersion: 'v2' as const,
     openBrowser: false,
     port: 1234,
     language: SourceLanguage.ts,

package/src/common/constants.ts

@@ -2,7 +2,7 @@ export const defaultRegistry = 'https://registry.npmjs.org/';
 export const filesTar = 'files';
 export const filesOnceTar = 'files_once';
 export const piralBaseRoot = 'piral-base/package.json';
-export const frameworkLibs = ['piral' as const, 'piral-core' as const, 'piral-base' as const];
+export const frameworkLibs = ['piral-native' as const, 'piral' as const, 'piral-core' as const, 'piral-base' as const];
 export const entryModuleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
 export const bundlerNames = [
   'esbuild' as const,

package/src/common/declaration.ts

@@ -16,9 +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);
-  } catch {
-    return undefined;
+
+    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 [];
   }
 }
 
@@ -141,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 {
@@ -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/importmap.ts

@@ -3,6 +3,7 @@ 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 } from '../types';
 
 interface Importmap {
@@ -10,16 +11,7 @@ interface Importmap {
   inherit: Array<string>;
 }
 
-function tryResolve(baseDir: string, name: string) {
-  try {
-    return require.resolve(name, {
-      paths: [baseDir],
-    });
-  } catch (ex) {
-    log('generalDebug_0003', `Could not resolve the package "${name}" in "${baseDir}": ${ex}`);
-    return undefined;
-  }
-}
+const shorthandsUrls = ['', '.', '...'];
 
 function getDependencyDetails(depName: string): [assetName: string, identifier: string, versionSpec: string] {
   const sep = depName.indexOf('@', 1);
@@ -74,8 +66,8 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
           ref: url,
           type: 'remote',
         });
-      } else if (url === identifier) {
-        const entry = tryResolve(dir, identifier);
+      } else if (url === identifier || shorthandsUrls.includes(url)) {
+        const entry = tryResolvePackage(identifier, dir);
 
         if (entry) {
           const packageJson = await findFile(dirname(entry), 'package.json');
@@ -90,7 +82,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
             type: 'local',
           });
         } else {
-          fail('importMapReferenceNotFound_0027', dir, url);
+          fail('importMapReferenceNotFound_0027', dir, identifier);
         }
       } else {
         const entry = resolve(dir, url);
@@ -109,7 +101,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
             dependencies.push({
               id: `${identifier}@${version}`,
               requireId: `${identifier}@${requireVersion}`,
-              entry: isDirectory ? tryResolve(dir, entry) : entry,
+              entry: isDirectory ? tryResolvePackage(entry, dir) : entry,
               name: identifier,
               ref: `${assetName}.js`,
               type: 'local',
@@ -137,7 +129,7 @@ async function resolveImportmap(dir: string, importmap: Importmap) {
 
   if (Array.isArray(inheritedImports)) {
     for (const inheritedImport of inheritedImports) {
-      const packageJson = tryResolve(dir, `${inheritedImport}/package.json`);
+      const packageJson = tryResolvePackage(`${inheritedImport}/package.json`, dir);
 
       if (packageJson) {
         const packageDir = dirname(packageJson);

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}`);