piral-cli 1.5.0-beta.6684 → 1.5.0-beta.6690

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/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> = {};
 

package/src/common/pilet.ts

@@ -0,0 +1,140 @@
+import { basename, dirname, isAbsolute, relative, resolve } from 'path';
+import { config } from './config';
+import { removeDirectory } from './io';
+import { ForceOverwrite } from './enums';
+import { logInfo, progress } from './log';
+import { callPiletBuild } from '../bundler';
+import { defaultSchemaVersion } from './constants';
+import { createPiletDeclaration } from './declaration';
+import { combinePiletExternals, retrievePiletData, validateSharedDependencies } from './package';
+import { LogLevels, PiletSchemaVersion } from '../types';
+
+const defaultOutput = 'dist/index.js';
+
+function isSubDir(parent: string, dir: string) {
+  const rel = relative(parent, dir);
+  return rel && !rel.startsWith('..') && !isAbsolute(rel);
+}
+
+function getTarget(root: string, main: string, source: string, target?: string) {
+  if (typeof target === 'undefined') {
+    const propDest = resolve(root, main);
+    const propDestDir = dirname(propDest);
+    const usePropDest = propDestDir !== root && propDestDir !== source && isSubDir(root, propDest);
+    return usePropDest ? propDest : resolve(root, defaultOutput);
+  }
+
+  return resolve(root, target);
+}
+
+export interface BuildPiletOptions {
+  entryModule: string;
+  app?: string;
+  originalSchemaVersion: PiletSchemaVersion;
+  target?: string;
+  fresh: boolean;
+  logLevel: LogLevels;
+  bundlerName: string;
+  optimizeModules: boolean;
+  sourceMaps: boolean;
+  watch: boolean;
+  contentHash: boolean;
+  minify: boolean;
+  declaration: boolean;
+  hooks?: {
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeDeclaration?(e: any): Promise<void>;
+    afterDeclaration?(e: any): Promise<void>;
+  };
+  _: Record<string, any>;
+}
+
+export async function triggerBuildPilet({
+  target,
+  app,
+  originalSchemaVersion,
+  fresh,
+  entryModule,
+  logLevel,
+  optimizeModules,
+  sourceMaps,
+  watch,
+  contentHash,
+  declaration,
+  minify,
+  hooks,
+  bundlerName,
+  _,
+}: BuildPiletOptions) {
+  const targetDir = dirname(entryModule);
+  const { peerDependencies, peerModules, root, apps, piletPackage, ignored, importmap, schema } =
+    await retrievePiletData(targetDir, app);
+  const schemaVersion = originalSchemaVersion || schema || config.schemaVersion || defaultSchemaVersion;
+  const piralInstances = apps.map((m) => m.appPackage.name);
+  const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
+  const { main = defaultOutput, name = 'pilet' } = piletPackage;
+  const dest = getTarget(root, main, targetDir, target);
+  const outDir = dirname(dest);
+  const outFile = basename(dest);
+
+  validateSharedDependencies(importmap);
+
+  if (fresh) {
+    progress('Removing output directory ...');
+    await removeDirectory(outDir);
+  }
+
+  logInfo('Bundle pilet ...');
+
+  await hooks.beforeBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+
+  await callPiletBuild(
+    {
+      root,
+      piralInstances,
+      optimizeModules,
+      sourceMaps,
+      watch,
+      contentHash,
+      minify,
+      externals,
+      targetDir,
+      importmap,
+      outFile,
+      outDir,
+      entryModule: `./${relative(root, entryModule)}`,
+      logLevel,
+      version: schemaVersion,
+      ignored,
+      _,
+    },
+    bundlerName,
+  );
+
+  await hooks.afterBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+
+  if (declaration) {
+    await hooks.beforeDeclaration?.({ root, outDir, entryModule, piletPackage });
+    await createPiletDeclaration(
+      name,
+      piralInstances,
+      root,
+      entryModule,
+      externals,
+      outDir,
+      ForceOverwrite.yes,
+      logLevel,
+    );
+    await hooks.afterDeclaration?.({ root, outDir, entryModule, piletPackage });
+  }
+
+  return {
+    piletPackage,
+    root,
+    outDir,
+    apps,
+    outFile,
+    dest,
+  };
+}