piral-cli 1.5.0-beta.6658 → 1.5.0-beta.6685

package/src/apps/debug-piral.ts

@@ -1,6 +1,6 @@
 import { dirname, join, resolve } from 'path';
 import { callPiralDebug } from '../bundler';
-import { LogLevels } from '../types';
+import { LogLevels, NetworkSpec } from '../types';
 import {
   retrievePiletsInfo,
   retrievePiralRoot,
@@ -124,6 +124,10 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
+  const network: NetworkSpec = {
+    port: originalPort,
+    type: 'proposed',
+  };
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
@@ -187,7 +191,7 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
       fullBase,
       hooks,
       open,
-      originalPort,
+      network,
       publicUrl,
       root,
       targetDir,

package/src/apps/publish-pilet.ts

@@ -1,6 +1,5 @@
-import { relative, dirname, basename, resolve, isAbsolute } from 'path';
-import { callPiletBuild } from '../bundler';
-import { LogLevels, PiletSchemaVersion, PiletPublishSource, PiletPublishScheme } from '../types';
+import { relative, dirname, basename, resolve } from 'path';
+import { LogLevels, PiletSchemaVersion, PiletPublishSource, PublishScheme } from '../types';
 import {
   postFile,
   readBinary,
@@ -16,11 +15,7 @@ import {
   findNpmTarball,
   downloadFile,
   matchAnyPilet,
-  retrievePiletData,
-  removeDirectory,
-  logInfo,
-  combinePiletExternals,
-  defaultSchemaVersion,
+  triggerBuildPilet,
 } from '../common';
 
 export interface PublishPiletOptions {
@@ -92,12 +87,22 @@ export interface PublishPiletOptions {
   /**
    * Sets the authorization scheme to use.
    */
-  mode?: PiletPublishScheme;
+  mode?: PublishScheme;
 
   /**
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeDeclaration?(e: any): Promise<void>;
+    afterDeclaration?(e: any): Promise<void>;
+  };
 }
 
 export const publishPiletDefaults: PublishPiletOptions = {
@@ -114,11 +119,6 @@ export const publishPiletDefaults: PublishPiletOptions = {
   interactive: false,
 };
 
-function isSubDir(parent: string, dir: string) {
-  const rel = relative(parent, dir);
-  return rel && !rel.startsWith('..') && !isAbsolute(rel);
-}
-
 async function getFiles(
   baseDir: string,
   sources: Array<string>,
@@ -129,6 +129,7 @@ async function getFiles(
   bundlerName: string,
   _?: Record<string, any>,
   ca?: Buffer,
+  hooks?: PublishPiletOptions['hooks'],
 ): Promise<Array<string>> {
   if (fresh) {
     log('generalDebug_0003', 'Detected "--fresh". Trying to resolve the package.json.');
@@ -140,54 +141,25 @@ async function getFiles(
 
     return await Promise.all(
       allEntries.map(async (entryModule) => {
-        const targetDir = dirname(entryModule);
-
         progress('Triggering pilet build ...');
-        const { root, piletPackage, importmap, peerDependencies, peerModules, apps, schema } = await retrievePiletData(
-          targetDir,
-        );
-        const schemaVersion = originalSchemaVersion || schema || config.schemaVersion || defaultSchemaVersion;
-        const piralInstances = apps.map((m) => m.appPackage.name);
-        const defaultOutput = 'dist/index.js';
-        const { main = defaultOutput, name = 'pilet' } = piletPackage;
-        const propDest = resolve(root, main);
-        const propDestDir = dirname(propDest);
-        log('generalDebug_0003', `Pilet "${name}" is supposed to generate artifact in "${propDest}".`);
-        const usePropDest = propDestDir !== root && propDestDir !== targetDir && isSubDir(root, propDest);
-        const dest = usePropDest ? propDest : resolve(root, defaultOutput);
-        log('generalDebug_0003', `Pilet "${name}" is generating artifact in "${dest}".`);
-        const outDir = dirname(dest);
-        const outFile = basename(dest);
-        const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
-        log('generalDebug_0003', `Pilet "${name}" uses externals: ${externals.join(', ')}.`);
-
-        progress('Removing output directory ...');
-        await removeDirectory(outDir);
-
-        logInfo('Bundle pilet ...');
-        await callPiletBuild(
-          {
-            root,
-            piralInstances,
-            optimizeModules: false,
-            sourceMaps: true,
-            watch: false,
-            contentHash: true,
-            minify: true,
-            externals,
-            targetDir,
-            importmap,
-            outFile,
-            outDir,
-            entryModule: `./${relative(root, entryModule)}`,
-            logLevel,
-            version: schemaVersion,
-            ignored: [],
-            _,
-          },
-          bundlerName,
-        );
 
+        const { root, piletPackage } = await triggerBuildPilet({
+          _,
+          bundlerName,
+          entryModule,
+          fresh,
+          logLevel,
+          originalSchemaVersion,
+          watch: false,
+          optimizeModules: false,
+          sourceMaps: true,
+          declaration: true,
+          contentHash: true,
+          minify: true,
+          hooks,
+        });
+
+        const name = piletPackage.name;
         log('generalDebug_0003', `Pilet "${name}" built successfully!`);
         progress('Triggering pilet pack ...');
 
@@ -237,6 +209,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     mode = publishPiletDefaults.mode,
     interactive = publishPiletDefaults.interactive,
     _ = {},
+    hooks = {},
     bundlerName,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
@@ -259,7 +232,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
 
   log('generalDebug_0003', 'Getting the tgz files ...');
   const sources = Array.isArray(source) ? source : [source];
-  const files = await getFiles(fullBase, sources, from, fresh, schemaVersion, logLevel, bundlerName, _, ca);
+  const files = await getFiles(fullBase, sources, from, fresh, schemaVersion, logLevel, bundlerName, _, ca, hooks);
   const successfulUploads: Array<string> = [];
   log('generalDebug_0003', 'Received available tgz files.');
 
@@ -275,7 +248,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     const content = await readBinary(fullBase, fileName);
 
     if (content) {
-      progress(`Publishing "%s" ...`, file, url);
+      progress(`Publishing "%s" to "%s" ...`, file, url);
       const result = await postFile(url, mode, apiKey, content, fields, headers, ca, interactive);
 
       if (result.success) {

package/src/apps/publish-piral.ts

@@ -1,16 +1,26 @@
-import { resolve } from 'path';
-import { publishArtifacts } from '../release';
-import { LogLevels, PiralBuildType } from '../types';
+import { basename, dirname, resolve } from 'path';
+import { LogLevels, PublishScheme } from '../types';
 import {
   setLogLevel,
   progress,
   checkExists,
   fail,
   logDone,
-  logReset,
-  publishNpmPackage,
-  matchFiles,
   log,
+  config,
+  readBinary,
+  emulatorName,
+  emulatorJson,
+  publishWebsiteEmulator,
+  matchFiles,
+  readJson,
+  triggerBuildEmulator,
+  logReset,
+  emulatorWebsiteName,
+  retrievePiralRoot,
+  emulatorPackageName,
+  retrievePiletsInfo,
+  validateSharedDependencies,
 } from '../common';
 
 export interface PublishPiralOptions {
@@ -19,15 +29,36 @@ export interface PublishPiralOptions {
    */
   source?: string;
 
+  /**
+   * Sets the URL of the feed service to deploy to.
+   */
+  url?: string;
+
+  /**
+   * Sets the API key to use.
+   */
+  apiKey?: string;
+
   /**
    * Sets the log level to use (1-5).
    */
   logLevel?: LogLevels;
 
   /**
-   * The options to supply for the provider.
+   * Specifies if the Piral instance should be built before publishing.
+   * If yes, then the tarball is created from fresh build artifacts.
+   */
+  fresh?: boolean;
+
+  /**
+   * Defines a custom certificate for the feed service.
    */
-  opts?: Record<string, string>;
+  cert?: string;
+
+  /**
+   * Places additional headers that should be posted to the feed service.
+   */
+  headers?: Record<string, string>;
 
   /**
    * Defines if authorization tokens can be retrieved interactively.
@@ -35,104 +66,143 @@ export interface PublishPiralOptions {
   interactive?: boolean;
 
   /**
-   * The provider to use for publishing the release artifacts.
+   * Sets the bundler to use for building, if any specific.
    */
-  provider?: string;
+  bundlerName?: string;
 
   /**
-   * The type of publish.
+   * Sets the authorization scheme to use.
    */
-  type?: PiralBuildType;
+  mode?: PublishScheme;
+
+  /**
+   * Additional arguments for a specific bundler.
+   */
+  _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    beforeEmulator?(e: any): Promise<void>;
+    afterEmulator?(e: any): Promise<void>;
+    beforePackage?(e: any): Promise<void>;
+    afterPackage?(e: any): Promise<void>;
+  };
 }
 
 export const publishPiralDefaults: PublishPiralOptions = {
   source: './dist',
   logLevel: LogLevels.info,
-  type: 'all',
-  provider: 'none',
-  opts: {},
+  url: undefined,
   interactive: false,
+  apiKey: undefined,
+  fresh: false,
+  cert: undefined,
+  mode: 'basic',
+  headers: {},
 };
 
-async function publishEmulator(
-  baseDir: string,
-  source: string,
-  args: Record<string, string> = {},
-  interactive = false,
-) {
-  const type = 'emulator';
-  const directory = resolve(baseDir, source, type);
-  const exists = await checkExists(directory);
-
-  if (!exists) {
-    fail('publishDirectoryMissing_0110', directory);
-  }
-
-  const files = await matchFiles(directory, '*.tgz');
-  log('generalDebug_0003', `Found ${files.length} in "${directory}": ${files.join(', ')}`);
-
-  if (files.length !== 1) {
-    fail('publishEmulatorFilesUnexpected_0111', directory);
-  }
-
-  const [file] = files;
-  const flags = Object.keys(args).reduce((p, c) => {
-    p.push(`--${c}`, args[c]);
-    return p;
-  }, [] as Array<string>);
-
-  await publishNpmPackage(directory, file, flags, interactive);
-}
-
-async function publishRelease(
-  baseDir: string,
-  source: string,
-  providerName: string,
-  args: Record<string, string> = {},
-  interactive = false,
-) {
-  const type = 'release';
-  const directory = resolve(baseDir, source, type);
-  const exists = await checkExists(directory);
-
-  if (!exists) {
-    fail('publishDirectoryMissing_0110', directory);
-  }
-
-  const files = await matchFiles(directory, '**/*');
-  log('generalDebug_0003', `Found ${files.length} in "${directory}": ${files.join(', ')}`);
-  await publishArtifacts(providerName, directory, files, args, interactive);
-}
-
 export async function publishPiral(baseDir = process.cwd(), options: PublishPiralOptions = {}) {
   const {
     source = publishPiralDefaults.source,
-    type = publishPiralDefaults.type,
     logLevel = publishPiralDefaults.logLevel,
-    opts = publishPiralDefaults.opts,
-    provider = publishPiralDefaults.provider,
     interactive = publishPiralDefaults.interactive,
+    fresh = publishPiralDefaults.fresh,
+    url = config.url ?? publishPiralDefaults.url,
+    apiKey = config.apiKeys?.[url] ?? config.apiKey ?? publishPiralDefaults.apiKey,
+    cert = config.cert ?? publishPiralDefaults.cert,
+    headers = publishPiralDefaults.headers,
+    mode = publishPiralDefaults.mode,
+    _ = {},
+    hooks = {},
+    bundlerName,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
+  progress('Reading configuration ...');
 
-  if (type === 'emulator-sources') {
-    fail('publishEmulatorSourcesInvalid_0114');
+  if (!url) {
+    fail('missingPiletFeedUrl_0060');
   }
 
-  progress('Reading configuration ...');
+  log('generalDebug_0003', 'Checking if certificate exists.');
+  let ca: Buffer = undefined;
 
-  if (type !== 'release') {
-    progress('Publishing emulator package ...');
-    await publishEmulator(fullBase, source, opts, interactive);
-    logDone(`Successfully published emulator.`);
-    logReset();
+  if (await checkExists(cert)) {
+    const dir = dirname(cert);
+    const file = basename(cert);
+    log('generalDebug_0003', `Reading certificate file "${file}" from "${dir}".`);
+    ca = await readBinary(dir, file);
+  }
+
+  log('generalDebug_0003', 'Getting the files ...');
+  const entryFiles = await retrievePiralRoot(fullBase, './');
+  const {
+    name,
+    root,
+    ignored,
+    externals,
+    scripts,
+    emulator = emulatorPackageName,
+  } = await retrievePiletsInfo(entryFiles);
+
+  if (emulator !== emulatorWebsiteName) {
+    fail('generalError_0002', `Currently only the "${emulatorWebsiteName}" option is supported.`);
   }
+  
+  const emulatorDir = resolve(fullBase, source, emulatorName);
+
+  if (fresh) {
+    const piralInstances = [name];
+
+    validateSharedDependencies(externals);
+
+    await triggerBuildEmulator({
+      root,
+      logLevel,
+      bundlerName,
+      emulatorType: emulatorWebsiteName,
+      hooks,
+      targetDir: emulatorDir,
+      ignored,
+      externals,
+      entryFiles,
+      piralInstances,
+      optimizeModules: true,
+      sourceMaps: true,
+      watch: false,
+      scripts,
+      contentHash: true,
+      outFile: 'index.html',
+      _,
+    });
 
-  if (type !== 'emulator') {
-    progress('Publishing release files ...');
-    await publishRelease(fullBase, source, provider, opts, interactive);
-    logDone(`Successfully published release.`);
     logReset();
   }
+
+  const { version } = await readJson(emulatorDir, emulatorJson);
+
+  if (!version) {
+    fail('missingEmulatorWebsite_0130', emulatorDir);
+  }
+
+  log('generalInfo_0000', `Using feed service "${url}".`);
+
+  const files = await matchFiles(emulatorDir, '**/*');
+
+  progress(`Publishing emulator to "%s" ...`, url);
+  const result = await publishWebsiteEmulator(version, url, apiKey, mode, emulatorDir, files, interactive, headers, ca);
+
+  if (!result.success) {
+    fail('failedUploading_0064');
+  }
+
+  if (result.response) {
+    log('httpPostResponse_0067', result);
+  }
+
+  progress(`Published successfully!`);
+
+  logDone(`Emulator published successfully!`);
 }

package/src/build/bundler-calls.ts

@@ -38,7 +38,10 @@ function createBundler(cwd: string, ps: ChildProcess, args: any) {
       }
     },
     stop() {
-      ps.kill();
+      return new Promise<void>(resolve => {
+        ps.on('exit', resolve);
+        ps.kill();
+      });
     },
     on(cb: BundleListener) {
       listeners.push(cb);

package/src/commands.ts

@@ -24,7 +24,7 @@ import {
   PiletPublishSource,
   PiletSchemaVersion,
   PiletBuildType,
-  PiletPublishScheme,
+  PublishScheme,
   SourceLanguage,
 } from './types';
 
@@ -196,25 +196,39 @@ const allCommands: Array<ToolCommand<any>> = [
     alias: ['release-piral', 'release'],
     description: 'Publishes Piral instance build artifacts.',
     arguments: ['[source]'],
-    flags(argv) {
+    // "any" due to https://github.com/microsoft/TypeScript/issues/28663 [artifical N = 50]
+    flags(argv: any) {
       return argv
         .positional('source', {
           type: 'string',
           describe: 'Sets the previously used output directory to publish.',
           default: apps.publishPiralDefaults.source,
         })
+        .string('url')
+        .describe('url', 'Sets the explicit URL where to publish the emulator to.')
+        .default('url', apps.publishPiralDefaults.url)
+        .string('api-key')
+        .describe('api-key', 'Sets the potential API key to send to the service.')
+        .default('api-key', apps.publishPiralDefaults.apiKey)
+        .string('ca-cert')
+        .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
+        .default('ca-cert', apps.publishPiralDefaults.cert)
         .number('log-level')
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.publishPiralDefaults.logLevel)
-        .choices('type', piralBuildTypeKeys)
-        .describe('type', 'Selects the target type to publish. "all" publishes all target types.')
-        .default('type', apps.publishPiralDefaults.type)
-        .choices('provider', availableReleaseProviders)
-        .describe('provider', 'Sets the provider for publishing the release assets.')
-        .default('provider', apps.publishPiralDefaults.provider)
-        .option('opts', undefined)
-        .describe('opts', 'Sets the options to forward to the chosen provider.')
-        .default('opts', apps.publishPiralDefaults.opts)
+        .boolean('fresh')
+        .describe('fresh', 'Performs a fresh build of the emulator website.')
+        .default('fresh', apps.publishPiralDefaults.fresh)
+        .choices('mode', publishModeKeys)
+        .describe('mode', 'Sets the authorization mode to use.')
+        .default('mode', apps.publishPiralDefaults.mode)
+        .alias('mode', 'auth-mode')
+        .choices('bundler', availableBundlers)
+        .describe('bundler', 'Sets the bundler to use.')
+        .default('bundler', availableBundlers[0])
+        .option('headers', undefined)
+        .describe('headers', 'Sets additional headers to be included in the feed service request.')
+        .default('headers', apps.publishPiralDefaults.headers)
         .boolean('interactive')
         .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
         .default('interactive', apps.publishPiralDefaults.interactive)
@@ -226,10 +240,15 @@ const allCommands: Array<ToolCommand<any>> = [
       return apps.publishPiral(args.base as string, {
         source: args.source as string,
         logLevel: args['log-level'] as LogLevels,
-        type: args.type as PiralBuildType,
-        provider: args.provider as string,
-        opts: args.opts as Record<string, string>,
+        apiKey: args['api-key'] as string,
+        cert: args['ca-cert'] as string,
+        url: args.url as string,
         interactive: args.interactive as boolean,
+        mode: args.mode as PublishScheme,
+        bundlerName: args.bundler as string,
+        fresh: args.fresh as boolean,
+        headers: args.headers as Record<string, string>,
+        _: args,
       });
     },
   },
@@ -671,7 +690,7 @@ const allCommands: Array<ToolCommand<any>> = [
         schemaVersion: args.schema as PiletSchemaVersion,
         fields: args.fields as Record<string, string>,
         headers: args.headers as Record<string, string>,
-        mode: args.mode as PiletPublishScheme,
+        mode: args.mode as PublishScheme,
         interactive: args.interactive as boolean,
         _: args,
       });

package/src/common/constants.ts

@@ -6,6 +6,13 @@ export const piletJson = 'pilet.json';
 export const filesOnceTar = 'files_once';
 export const piralBaseRoot = 'piral-base/package.json';
 export const defaultSchemaVersion = 'v2';
+export const allName = 'all';
+export const releaseName = 'release';
+export const emulatorJson = 'emulator.json';
+export const emulatorName = 'emulator';
+export const emulatorPackageName = 'package';
+export const emulatorSourcesName = 'sources';
+export const emulatorWebsiteName = 'website';
 export const frameworkLibs = ['piral' as const, 'piral-core' as const, 'piral-base' as const];
 export const piletJsonSchemaUrl = 'https://docs.piral.io/schemas/pilet-v0.json';
 export const piralJsonSchemaUrl = 'https://docs.piral.io/schemas/piral-v0.json';

package/src/common/emulator.ts

@@ -1,7 +1,7 @@
 import { join, resolve, relative, basename } from 'path';
 import { findDependencyVersion, copyScaffoldingFiles, isValidDependency, flattenExternals } from './package';
 import { createPiralStubIndexIfNotExists } from './template';
-import { filesTar, filesOnceTar, packageJson, piralJson } from './constants';
+import { filesTar, filesOnceTar, packageJson, piralJson, emulatorJson } from './constants';
 import { cliVersion } from './info';
 import { createNpmPackage } from './npm';
 import { createPiralDeclaration } from './declaration';
@@ -238,7 +238,7 @@ export async function createEmulatorWebsite(
     },
   };
 
-  await writeJson(targetDir, 'emulator.json', data, true);
+  await writeJson(targetDir, emulatorJson, data, true);
 
   // generate the associated index.d.ts
   await createPiralDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);

package/src/common/http.ts

@@ -7,7 +7,7 @@ import { log } from './log';
 import { standardHeaders } from './info';
 import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
-import { PiletPublishScheme } from '../types';
+import { PublishScheme } from '../types';
 
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
@@ -67,7 +67,7 @@ export type FormDataObj = Record<string, string | number | boolean | [Buffer, st
 
 export function postForm(
   target: string,
-  scheme: PiletPublishScheme,
+  scheme: PublishScheme,
   key: string,
   formData: FormDataObj,
   customHeaders: Record<string, string> = {},
@@ -192,7 +192,7 @@ export function postForm(
 
 export function postFile(
   target: string,
-  scheme: PiletPublishScheme,
+  scheme: PublishScheme,
   key: string,
   file: Buffer,
   customFields: Record<string, string> = {},

package/src/common/index.ts

@@ -25,8 +25,11 @@ export * from './package';
 export * from './parallel';
 export * from './patcher';
 export * from './patches';
+export * from './pilet';
+export * from './piral';
 export * from './platform';
 export * from './port';
+export * from './release';
 export * from './rules';
 export * from './scaffold';
 export * from './scripts';

package/src/common/interactive.ts

@@ -3,7 +3,7 @@ import { openBrowserAt } from './browser';
 import { standardHeaders } from './info';
 import { logSuspend, logInfo } from './log';
 import { axios, inquirer } from '../external';
-import { PiletPublishScheme } from '../types';
+import { PublishScheme } from '../types';
 
 export function promptSelect(message: string, values: Array<string>, defaultValue: string): Promise<string> {
   const questions = [
@@ -30,7 +30,7 @@ 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 }>;
+type TokenResult = Promise<{ mode: PublishScheme; token: string }>;
 
 const tokenRetrievers: Record<string, TokenResult> = {};