piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/common/emulator.ts

@@ -1,13 +1,13 @@
 import { join, resolve, relative } from 'path';
-import { findDependencyVersion, copyScaffoldingFiles, isValidDependency } from './package';
-import { createFileFromTemplateIfNotExists } from './template';
-import { filesTar, filesOnceTar } from './constants';
+import { findDependencyVersion, copyScaffoldingFiles, isValidDependency, flattenExternals } from './package';
+import { createPiralStubIndexIfNotExists } from './template';
+import { filesTar, filesOnceTar, packageJson, piralJson } from './constants';
 import { cliVersion } from './info';
-import { createPackage, makeExternals } from './npm';
-import { createDeclaration } from './declaration';
+import { createNpmPackage } from './npm';
+import { createPiralDeclaration } from './declaration';
 import { ForceOverwrite } from './enums';
 import { createTarball } from './archive';
-import { LogLevels, TemplateFileLocation } from '../types';
+import { LogLevels, SharedDependency, PiletsInfo, TemplateFileLocation } from '../types';
 import {
   createDirectory,
   removeDirectory,
@@ -15,42 +15,59 @@ import {
   updateExistingJson,
   getFileNames,
   removeAny,
+  readJson,
 } from './io';
 
-const packageJson = 'package.json';
-
 export async function createEmulatorSources(
   sourceDir: string,
+  externals: Array<SharedDependency>,
   targetDir: string,
   targetFile: string,
   logLevel: LogLevels,
 ) {
-  const piralPkg = require(resolve(sourceDir, packageJson));
-  const files: Array<string | TemplateFileLocation> = piralPkg.pilets?.files ?? [];
-  const allExternals = makeExternals(piralPkg.pilets?.externals);
+  const piralPkg = await readJson(sourceDir, packageJson);
+  const piralJsonPkg = await readJson(sourceDir, piralJson);
+  const pilets: PiletsInfo = {
+    ...piralPkg.pilets,
+    ...piralJsonPkg.pilets,
+  };
+  const files: Array<string | TemplateFileLocation> = pilets.files ?? [];
+  const allDeps = {
+    ...piralPkg.devDependencies,
+    ...piralPkg.dependencies,
+  };
 
   const externalPackages = await Promise.all(
-    allExternals.filter(isValidDependency).map(async (name) => ({
-      name,
-      version: await findDependencyVersion(piralPkg, sourceDir, name),
-    })),
+    externals
+      .filter((ext) => ext.type === 'local' && isValidDependency(ext.name))
+      .map(async (external) => ({
+        name: external.name,
+        version: await findDependencyVersion(piralPkg, sourceDir, external),
+      })),
   );
   const externalDependencies = externalPackages.reduce((deps, dep) => {
     deps[dep.name] = dep.version;
     return deps;
   }, {} as Record<string, string>);
 
+  const importmapEntries = externalPackages.reduce((deps, dep) => {
+    deps[dep.name] = dep.name;
+    return deps;
+  }, {} as Record<string, string>);
+
   const rootDir = resolve(targetDir, '..');
   const appDir = relative(rootDir, targetDir);
   const filesDir = resolve(rootDir, filesTar);
   const filesOnceDir = resolve(rootDir, filesOnceTar);
 
   const filesMap = files
+    .filter((file) => file && (typeof file === 'string' || typeof file === 'object'))
     .map((file) => (typeof file === 'string' ? { from: file, to: file } : file))
+    .filter((file) => typeof file.to === 'string' && typeof file.from === 'string')
     .map((file) => ({
       ...file,
       to: file.to.replace(/\\/g, '/'),
-      from: join('files', file.from).replace(/\\/g, '/'),
+      from: join('files', file.to).replace(/\\/g, '/'),
     }));
 
   // do not modify an existing JSON
@@ -64,8 +81,11 @@ export async function createEmulatorSources(
     license: piralPkg.license,
     homepage: piralPkg.homepage,
     keywords: piralPkg.keywords,
+    importmap: {
+      imports: importmapEntries,
+    },
     pilets: {
-      ...piralPkg.pilets,
+      ...pilets,
       files: filesMap,
     },
     piralCLI: {
@@ -77,10 +97,10 @@ export async function createEmulatorSources(
     app: `./${appDir}/index.html`,
     peerDependencies: {},
     devDependencies: {
-      ...piralPkg.devDependencies,
-      ...piralPkg.dependencies,
+      ...allDeps,
       ...externalDependencies,
     },
+    sharedDependencies: flattenExternals(externals),
     repository: piralPkg.repository,
     bugs: piralPkg.bugs,
     author: piralPkg.author,
@@ -110,15 +130,15 @@ export async function createEmulatorSources(
   await copyScaffoldingFiles(sourceDir, rootDir, piralPkg.files ?? []);
 
   // actually including this one hints that the app shell should have been included - which is forbidden
-  await createFileFromTemplateIfNotExists('piral', targetDir, 'index.js', ForceOverwrite.yes, {
+  await createPiralStubIndexIfNotExists(targetDir, 'index.js', ForceOverwrite.yes, {
     name: piralPkg.name,
     outFile: targetFile,
   });
 
   // generate the associated index.d.ts
-  await createDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);
+  await createPiralDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);
 
-  // since things like .gitignore are not properly treated by NPM we pack the files (for standard and once only)
+  // since things like .gitignore are not properly treated by npm we pack the files (for standard and once only)
   await Promise.all([
     createTarball(filesDir, rootDir, `${filesTar}.tar`),
     createTarball(filesOnceDir, rootDir, `${filesOnceTar}.tar`),
@@ -132,7 +152,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/enums.ts

@@ -3,8 +3,3 @@ export enum ForceOverwrite {
   prompt,
   yes,
 }
-
-export enum SourceLanguage {
-  ts,
-  js,
-}

package/src/common/envs.ts

@@ -1,5 +1,7 @@
 import { join } from 'path';
+import { readFileSync } from 'fs';
 import { log } from './log';
+import { frameworkLibs } from './constants';
 import { pathSeparator, cliVersion, compatVersion } from './info';
 import { StandardEnvProps } from '../types';
 
@@ -10,7 +12,7 @@ function hasPath(path: string) {
 
 export function setStandardEnvs(options: StandardEnvProps) {
   log('generalDebug_0003', `Setting environment variables in "${options.root}" ...`);
-  const packageJson = require(join(options.root, 'package.json'));
+  const packageJson = JSON.parse(readFileSync(join(options.root, 'package.json'), 'utf8'));
   const binDir = join(options.root, 'node_modules', '.bin');
 
   process.env.BUILD_TIME = new Date().toDateString();
@@ -36,14 +38,24 @@ export function setStandardEnvs(options: StandardEnvProps) {
     delete process.env.DEBUG_PILET;
   }
 
+  if (options.publicPath) {
+    process.env.PIRAL_PUBLIC_PATH = options.publicPath;
+  }
+
   if (options.production) {
     process.env.NODE_ENV = 'production';
   } else if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = 'development';
   }
 
-  if (options.dependencies && options.dependencies.length) {
-    const excludedDependencies = ['piral', 'piral-core', 'piral-base', options.piral];
+  if (Array.isArray(options.piralInstances) && options.piralInstances.length) {
+    process.env.PIRAL_INSTANCE = options.piralInstances.join(',');
+  } else {
+    options.piralInstances = [];
+  }
+
+  if (Array.isArray(options.dependencies) && options.dependencies.length) {
+    const excludedDependencies = [...frameworkLibs, ...options.piralInstances];
     const dependencies = options.dependencies.filter((m) => !excludedDependencies.includes(m));
     process.env.SHARED_DEPENDENCIES = dependencies.join(',');
   } else {

package/src/common/hash.ts

@@ -7,3 +7,8 @@ export function computeHash(content: string | Buffer = '') {
 export function computeMd5(content: string | Buffer = '') {
   return createHash('md5').update(content).digest('hex');
 }
+
+export function computeIntegrity(content: string) {
+  const sum = createHash('sha256').update(content).digest('base64');
+  return `sha256-${sum}`;
+}

package/src/common/http.test.ts

@@ -7,71 +7,83 @@ let errorOther = false;
 let errorResponse = false;
 let errorResponse2 = false;
 
-jest.mock('axios', () => ({
-  default: {
-    post(url, _, options) {
-      const found = url === apiUrl;
-      const auth = options.headers.authorization === 'Basic 123';
+jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
+  ora() {
+    return {
+      warn() {},
+      fail() {},
+    };
+  },
+  axios: {
+    default: {
+      post(url, _, options) {
+        const found = url === apiUrl;
+        const auth = options.headers.authorization === 'Basic 123';
 
-      if (errorRequest) {
-        return Promise.reject({
-          request: {},
-        });
-      } else if (errorOther) {
-        return Promise.reject({
-          message: 'error',
-        });
-      } else if (errorResponse) {
-        return Promise.reject({
-          response: {
-            status: 410,
-            statusText: 'Not Gone',
-            data: '{ "message": "This component is not available anymore." }',
-          },
-        });
-      } else if (errorResponse2) {
-        return Promise.reject({
-          response: {
-            status: 410,
-            statusText: 'Not Gone',
-            data: { message: 'This component is not available anymore.' },
-          },
-        });
-      } else if (!found) {
-        return Promise.reject({
-          response: {
-            status: 404,
-            statusText: 'Not found',
-          },
-        });
-      } else if (!auth) {
-        return Promise.reject({
-          response: {
-            status: 401,
-            statusText: 'Not authorized',
-          },
-        });
-      } else {
-        return Promise.resolve({
-          status: 200,
-          statusText: 'OK',
-        });
-      }
-    },
-    get(url, options) {
-      if (errorOther) {
-        return Promise.reject({
-          message: 'error',
-        });
-      }
-      return Promise.resolve({ data: 'test' });
+        if (errorRequest) {
+          return Promise.reject({
+            request: {},
+          });
+        } else if (errorOther) {
+          return Promise.reject({
+            message: 'error',
+          });
+        } else if (errorResponse) {
+          return Promise.reject({
+            response: {
+              status: 410,
+              statusText: 'Not Gone',
+              data: '{ "message": "This component is not available anymore." }',
+            },
+          });
+        } else if (errorResponse2) {
+          return Promise.reject({
+            response: {
+              status: 410,
+              statusText: 'Not Gone',
+              data: { message: 'This component is not available anymore.' },
+            },
+          });
+        } else if (!found) {
+          return Promise.reject({
+            response: {
+              status: 404,
+              statusText: 'Not found',
+            },
+          });
+        } else if (!auth) {
+          return Promise.reject({
+            response: {
+              status: 401,
+              statusText: 'Not authorized',
+            },
+          });
+        } else {
+          return Promise.resolve({
+            status: 200,
+            statusText: 'OK',
+          });
+        }
+      },
+      get(url, options) {
+        if (errorOther) {
+          return Promise.reject({
+            message: 'error',
+          });
+        }
+        return Promise.resolve({ data: 'test' });
+      },
     },
   },
+  FormData: jest.requireActual('form-data'),
 }));
 
 describe('HTTP Module', () => {
   it('postFile form posts a file successfully should be ok', async () => {
-    const result = await postFile(apiUrl, '123', Buffer.from('example'));
+    const result = await postFile(apiUrl, 'basic', '123', Buffer.from('example'));
     expect(result).toEqual({
       response: undefined,
       status: 200,
@@ -80,7 +92,7 @@ describe('HTTP Module', () => {
   });
 
   it('postFile form fails to post file should be false', async () => {
-    const result = await postFile(apiUrl, '124', Buffer.from('example'));
+    const result = await postFile(apiUrl, 'basic', '124', Buffer.from('example'));
     expect(result).toEqual({
       response: '',
       status: 401,
@@ -89,7 +101,7 @@ describe('HTTP Module', () => {
   });
 
   it('postFile form not found to post file should be false', async () => {
-    const result = await postFile('http://sample.com/', '', Buffer.from('example'));
+    const result = await postFile('http://sample.com/', 'basic', '', Buffer.from('example'));
     expect(result).toEqual({
       response: '',
       status: 404,
@@ -99,7 +111,7 @@ describe('HTTP Module', () => {
 
   it('postFile call results in error request', async () => {
     errorRequest = true;
-    const result = await postFile('http://sample.com/', '', Buffer.from('example'));
+    const result = await postFile('http://sample.com/', 'basic', '', Buffer.from('example'));
     expect(result).toEqual({
       response: undefined,
       status: 500,
@@ -110,7 +122,7 @@ describe('HTTP Module', () => {
 
   it('postFile call results in error other', async () => {
     errorOther = true;
-    const result = await postFile('http://sample.com/', '', Buffer.from('example'));
+    const result = await postFile('http://sample.com/', 'basic', '', Buffer.from('example'));
     expect(result).toEqual({
       response: undefined,
       status: 500,
@@ -121,7 +133,7 @@ describe('HTTP Module', () => {
 
   it('postFile call results in error response', async () => {
     errorResponse = true;
-    let result = await postFile('http://sample.com/', '', Buffer.from('example'));
+    let result = await postFile('http://sample.com/', 'basic', '', Buffer.from('example'));
     expect(result).toEqual({
       response: 'This component is not available anymore.',
       status: 410,
@@ -129,7 +141,7 @@ describe('HTTP Module', () => {
     });
     errorResponse = false;
     errorResponse2 = true;
-    result = await postFile('http://sample.com/', '', Buffer.from('example'));
+    result = await postFile('http://sample.com/', 'basic', '', Buffer.from('example'));
     expect(result).toEqual({
       response: 'This component is not available anymore.',
       status: 410,

package/src/common/http.ts

@@ -1,12 +1,13 @@
 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';
-
-const os = platform();
+import { PiletPublishScheme } from '../types';
 
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
@@ -41,9 +42,7 @@ export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>
   return axios.default
     .get<Stream>(target, {
       responseType: 'stream',
-      headers: {
-        'user-agent': `piral-cli/http.node-${os}`,
-      },
+      headers: standardHeaders,
       httpsAgent,
     })
     .then((res) => {
@@ -58,47 +57,98 @@ 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 | number | boolean | [Buffer, string]>;
+
+export function postForm(
   target: string,
+  scheme: PiletPublishScheme,
   key: string,
-  file: Buffer,
-  fields: 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(fields).forEach((key) => form.append(key, fields[key]));
+  Object.keys(formData).forEach((key) => {
+    const value = formData[key];
 
-  form.append('file', file, 'pilet.tgz');
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+      form.append(key, value);
+    } else if (Array.isArray(value)) {
+      form.append(key, value[0], value[1]);
+    } else {
+      // unknown value - skip for now
+    }
+  });
+
+  const headers: Record<string, string> = {
+    ...form.getHeaders(),
+    ...standardHeaders,
+    ...customHeaders,
+  };
+
+  if (key) {
+    switch (scheme) {
+      case 'basic':
+        headers.authorization = `Basic ${key}`;
+        break;
+      case 'bearer':
+        headers.authorization = `Bearer ${key}`;
+        break;
+      case 'digest':
+        headers.authorization = `Digest ${key}`;
+        break;
+      case 'none':
+      default:
+        headers.authorization = key;
+        break;
+    }
+  }
 
   return axios.default
     .post(target, form, {
-      headers: {
-        ...form.getHeaders(),
-        authorization: `Basic ${key}`,
-        'user-agent': `piral-cli/http.node-${os}`,
-      },
+      headers,
       httpsAgent,
       maxContentLength: Infinity,
+      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 {
@@ -139,3 +189,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);
+}