piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/apps/new-piral.ts

@@ -1,23 +1,25 @@
 import { resolve, basename } from 'path';
-import { LogLevels, Framework, NpmClientType } from '../types';
+import { frameworkKeys } from '../helpers';
+import { SourceLanguage, LogLevels, Framework, NpmClientType } from '../types';
 import {
   ForceOverwrite,
-  SourceLanguage,
-  installPackage,
-  updateExistingJson,
-  getPiralPackage,
+  installNpmPackage,
+  patchPiralPackage,
   scaffoldPiralSourceFiles,
   createDirectory,
   createFileIfNotExists,
   logDone,
-  installDependencies,
+  installNpmDependencies,
   combinePackageRef,
   setLogLevel,
   fail,
   progress,
   determineNpmClient,
-  defaultRegistry,
   cliVersion,
+  getPiralScaffoldData,
+  config,
+  initNpmProject,
+  piralJson,
 } from '../common';
 
 export interface NewPiralOptions {
@@ -72,7 +74,7 @@ export interface NewPiralOptions {
   logLevel?: LogLevels;
 
   /**
-   * Sets the NPM client to be used when scaffolding. (e.g. 'yarn')
+   * Sets the npm client to be used when scaffolding. (e.g. 'yarn')
    */
   npmClient?: NpmClientType;
 
@@ -85,22 +87,28 @@ export interface NewPiralOptions {
    * Places additional variables that should used when scaffolding.
    */
   variables?: Record<string, string>;
+
+  /**
+   * Sets new app name
+   */
+  name?: string;
 }
 
 export const newPiralDefaults: NewPiralOptions = {
   app: './src/index.html',
-  registry: defaultRegistry,
+  registry: config.registry,
   framework: 'piral',
   target: '.',
   version: cliVersion,
   forceOverwrite: ForceOverwrite.no,
-  language: SourceLanguage.ts,
+  language: config.language,
   install: true,
   template: 'default',
   logLevel: LogLevels.info,
   npmClient: undefined,
   bundlerName: 'none',
   variables: {},
+  name: undefined,
 };
 
 export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions = {}) {
@@ -117,15 +125,25 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
     logLevel = newPiralDefaults.logLevel,
     bundlerName = newPiralDefaults.bundlerName,
     variables = newPiralDefaults.variables,
+    name = newPiralDefaults.name,
+    npmClient: defaultNpmClient = newPiralDefaults.npmClient,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
+
+  if (!frameworkKeys.includes(framework)) {
+    fail('generalError_0002', `The "framework" value must be one of: ${frameworkKeys.join(', ')}`);
+  }
+
   setLogLevel(logLevel);
+
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
   const success = await createDirectory(root);
 
   if (success) {
-    const npmClient = await determineNpmClient(root, options.npmClient);
+    const npmClient = await determineNpmClient(root, defaultNpmClient);
     const packageRef = combinePackageRef(framework, version, 'registry');
+    const projectName = name || basename(root);
 
     progress(`Creating a new Piral instance in %s ...`, root);
 
@@ -134,7 +152,7 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
       'package.json',
       JSON.stringify(
         {
-          name: basename(root),
+          name: projectName,
           version: '1.0.0',
           description: '',
           keywords: ['piral'],
@@ -146,8 +164,10 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
       ),
     );
 
+    await initNpmProject(npmClient, projectName, root);
+
     if (registry !== newPiralDefaults.registry) {
-      progress(`Setting up NPM registry (%s) ...`, registry);
+      progress(`Setting up npm registry (%s) ...`, registry);
 
       await createFileIfNotExists(
         root,
@@ -158,19 +178,23 @@ always-auth=true`,
       );
     }
 
-    await updateExistingJson(root, 'package.json', getPiralPackage(app, language, version, framework, bundlerName));
+    await createFileIfNotExists(root, piralJson, JSON.stringify({}, undefined, 2));
 
-    progress(`Installing NPM package ${packageRef} ...`);
+    progress(`Installing npm package ${packageRef} ...`);
 
-    await installPackage(npmClient, packageRef, root);
+    await installNpmPackage(npmClient, packageRef, root, '--save-exact');
 
     progress(`Taking care of templating ...`);
 
-    await scaffoldPiralSourceFiles(template, registry, language, root, app, framework, forceOverwrite, variables);
+    const data = getPiralScaffoldData(language, root, app, framework, variables);
+
+    await patchPiralPackage(root, app, data, version, bundlerName);
+
+    await scaffoldPiralSourceFiles(template, registry, data, forceOverwrite);
 
     if (install) {
       progress(`Installing dependencies ...`);
-      await installDependencies(npmClient, root);
+      await installNpmDependencies(npmClient, root);
     }
 
     logDone(`Piral instance scaffolded successfully!`);

package/src/apps/pack-pilet.test.ts

@@ -8,7 +8,7 @@ function createTempDir() {
 }
 
 describe('Pack Pilet Command', () => {
-  it('can pack a standard NPM package to a specified target', async () => {
+  it('can pack a standard npm package to a specified target', async () => {
     const dir = createTempDir();
     const target = 'foo.tgz';
     const packageJson = resolve(dir, 'package.json');
@@ -28,7 +28,7 @@ describe('Pack Pilet Command', () => {
     expect(existsSync(resolve(dir, target))).toBeTruthy();
   });
 
-  it('can pack a standard NPM package to a the default target using the process directory', async () => {
+  it('can pack a standard npm package to a the default target using the process directory', async () => {
     const originalDir = process.cwd();
     const dir = createTempDir();
     const packageJson = resolve(dir, 'package.json');

package/src/apps/pack-pilet.ts

@@ -1,26 +1,27 @@
+import { resolve } from 'path';
 import { createPiletPackage, logDone, setLogLevel, progress } from '../common';
 import { LogLevels } from '../types';
 
 export interface PackPiletOptions {
-  source?: string;
-  target?: string;
-  logLevel?: LogLevels;
-}
-
-export const packPiletDefaults: PackPiletOptions = {
   /**
-   * Sets the source directory for creating the NPM package.
+   * Sets the source directory for creating the npm package.
    */
-  source: '.',
+  source?: string;
 
   /**
    * Sets the target directory for storing the tarball.
    */
-  target: '.',
+  target?: string;
 
   /**
    * Sets the log level to use (1-5).
    */
+  logLevel?: LogLevels;
+}
+
+export const packPiletDefaults: PackPiletOptions = {
+  source: '.',
+  target: '.',
   logLevel: LogLevels.info,
 };
 
@@ -30,8 +31,9 @@ export async function packPilet(baseDir = process.cwd(), options: PackPiletOptio
     target = packPiletDefaults.target,
     logLevel = packPiletDefaults.logLevel,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  await createPiletPackage(baseDir, source, target);
+  await createPiletPackage(fullBase, source, target);
   logDone(`Pilet packed successfully!`);
 }

package/src/apps/publish-pilet.ts

@@ -1,6 +1,6 @@
-import { relative, join, dirname, basename } from 'path';
-import { buildPilet } from './build-pilet';
-import { LogLevels, PiletSchemaVersion, PiletPublishSource } from '../types';
+import { relative, dirname, basename, resolve, isAbsolute } from 'path';
+import { callPiletBuild } from '../bundler';
+import { LogLevels, PiletSchemaVersion, PiletPublishSource, PiletPublishScheme } from '../types';
 import {
   postFile,
   readBinary,
@@ -13,8 +13,14 @@ import {
   log,
   config,
   checkExists,
-  findTarball,
+  findNpmTarball,
   downloadFile,
+  matchAnyPilet,
+  retrievePiletData,
+  removeDirectory,
+  logInfo,
+  combinePiletExternals,
+  defaultSchemaVersion,
 } from '../common';
 
 export interface PublishPiletOptions {
@@ -23,7 +29,7 @@ export interface PublishPiletOptions {
    * used with `--fresh`, otherwise expects source to be a path leading
    * to a `*.tgz` file.
    */
-  source?: string;
+  source?: string | Array<string>;
 
   /**
    * Sets the URL of the feed service to deploy to.
@@ -59,7 +65,7 @@ export interface PublishPiletOptions {
   /**
    * Changing the publish source makes it possible to publish pilets that have
    * been stored on non-local paths, e.g., when a pilet was already published to
-   * an NPM feed.
+   * an npm feed.
    */
   from?: PiletPublishSource;
 
@@ -67,73 +73,171 @@ export interface PublishPiletOptions {
    * Places additional fields that should be posted to the feed service.
    */
   fields?: Record<string, string>;
+
+  /**
+   * Places additional headers that should be posted to the feed service.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * Defines if authorization tokens can be retrieved interactively.
+   */
+  interactive?: boolean;
+
+  /**
+   * Sets the bundler to use for building, if any specific.
+   */
+  bundlerName?: string;
+
+  /**
+   * Sets the authorization scheme to use.
+   */
+  mode?: PiletPublishScheme;
+
+  /**
+   * Additional arguments for a specific bundler.
+   */
+  _?: Record<string, any>;
 }
 
 export const publishPiletDefaults: PublishPiletOptions = {
-  source: '*.tgz',
-  url: '',
-  apiKey: '',
+  url: undefined,
+  apiKey: undefined,
   fresh: false,
   cert: undefined,
   logLevel: LogLevels.info,
-  schemaVersion: 'v1',
+  schemaVersion: undefined,
+  mode: 'basic',
   from: 'local',
   fields: {},
+  headers: {},
+  interactive: false,
 };
 
+function isSubDir(parent: string, dir: string) {
+  const rel = relative(parent, dir);
+  return rel && !rel.startsWith('..') && !isAbsolute(rel);
+}
+
 async function getFiles(
   baseDir: string,
-  source: string,
+  sources: Array<string>,
   from: PiletPublishSource,
   fresh: boolean,
-  schemaVersion: PiletSchemaVersion,
+  originalSchemaVersion: PiletSchemaVersion,
+  logLevel: LogLevels,
+  bundlerName: string,
+  _?: Record<string, any>,
   ca?: Buffer,
 ): Promise<Array<string>> {
   if (fresh) {
     log('generalDebug_0003', 'Detected "--fresh". Trying to resolve the package.json.');
-    const details = require(join(baseDir, 'package.json'));
-    progress('Triggering pilet build ...');
-    await buildPilet(baseDir, {
-      target: details.main,
-      fresh,
-      schemaVersion,
-    });
-    log('generalDebug_0003', 'Successfully built.');
-    progress('Triggering pilet pack ...');
-    const file = await createPiletPackage(baseDir, '.', '.');
-    log('generalDebug_0003', 'Successfully packed.');
-    return [file];
+    const allEntries = await matchAnyPilet(baseDir, sources);
+
+    if (allEntries.length === 0) {
+      fail('entryFileMissing_0077');
+    }
+
+    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 { main = 'dist/index.js', name = 'pilet' } = piletPackage;
+        const propDest = resolve(root, main);
+        log('generalDebug_0003', `Pilet "${name}" is supposed to generate artifact in "${propDest}".`);
+        const usePropDest = dirname(propDest) !== root && isSubDir(root, propDest);
+        const dest = usePropDest ? propDest : resolve(root, 'dist');
+        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,
+        );
+
+        log('generalDebug_0003', `Pilet "${name}" built successfully!`);
+        progress('Triggering pilet pack ...');
+
+        const file = await createPiletPackage(root, '.', '.');
+        log('generalDebug_0003', `Pilet "${name}" packed successfully!`);
+
+        return file;
+      }),
+    );
   } else {
     log('generalDebug_0003', `Did not find fresh flag. Trying to match from "${from}".`);
 
     switch (from) {
-      case 'local':
-        log('generalDebug_0003', `Matching files using "${source}".`);
-        return await matchFiles(baseDir, source);
-      case 'remote':
-        log('generalDebug_0003', `Download file from "${source}".`);
-        return await downloadFile(source, ca);
-      case 'npm':
-        log('generalDebug_0003', `View NPM package "${source}".`);
-        const url = await findTarball(source);
-        log('generalDebug_0003', `Download file from "${url}".`);
-        return await downloadFile(url, ca);
+      case 'local': {
+        log('generalDebug_0003', `Matching files using "${sources.join('", "')}".`);
+        const allFiles = await Promise.all(sources.map((s) => matchFiles(baseDir, s)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
+      case 'remote': {
+        log('generalDebug_0003', `Download file from "${sources.join('", "')}".`);
+        const allFiles = await Promise.all(sources.map((s) => downloadFile(s, ca)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
+      case 'npm': {
+        log('generalDebug_0003', `View npm package "${sources.join('", "')}".`);
+        const allUrls = await Promise.all(sources.map((s) => findNpmTarball(s)));
+        log('generalDebug_0003', `Download file from "${allUrls.join('", "')}".`);
+        const allFiles = await Promise.all(allUrls.map((url) => downloadFile(url, ca)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
     }
   }
 }
 
 export async function publishPilet(baseDir = process.cwd(), options: PublishPiletOptions = {}) {
   const {
-    source = publishPiletDefaults.source,
-    url = config.url ?? publishPiletDefaults.url,
-    apiKey = config.apiKey ?? publishPiletDefaults.apiKey,
     fresh = publishPiletDefaults.fresh,
+    source = fresh ? './src/index' : '*.tgz',
+    url = config.url ?? publishPiletDefaults.url,
+    apiKey = config.apiKeys?.[url] ?? config.apiKey ?? publishPiletDefaults.apiKey,
     logLevel = publishPiletDefaults.logLevel,
     from = publishPiletDefaults.from,
     schemaVersion = publishPiletDefaults.schemaVersion,
     cert = config.cert ?? publishPiletDefaults.cert,
     fields = publishPiletDefaults.fields,
+    headers = publishPiletDefaults.headers,
+    mode = publishPiletDefaults.mode,
+    interactive = publishPiletDefaults.interactive,
+    _ = {},
+    bundlerName,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
@@ -152,24 +256,25 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
   }
 
   log('generalDebug_0003', 'Getting the tgz files ...');
-  const files = await getFiles(baseDir, source, from, fresh, schemaVersion, ca);
+  const sources = Array.isArray(source) ? source : [source];
+  const files = await getFiles(fullBase, sources, from, fresh, schemaVersion, logLevel, bundlerName, _, ca);
   const successfulUploads: Array<string> = [];
   log('generalDebug_0003', 'Received available tgz files.');
 
   if (files.length === 0) {
-    fail('missingPiletTarball_0061', source);
+    fail('missingPiletTarball_0061', sources);
   }
 
   log('generalInfo_0000', `Using feed service "${url}".`);
 
   for (const file of files) {
     log('generalDebug_0003', 'Reading the file for upload ...');
-    const fileName = relative(baseDir, file);
-    const content = await readBinary(baseDir, fileName);
+    const fileName = relative(fullBase, file);
+    const content = await readBinary(fullBase, fileName);
 
     if (content) {
       progress(`Publishing "%s" ...`, file, url);
-      const result = await postFile(url, apiKey, content, fields, ca);
+      const result = await postFile(url, mode, apiKey, content, fields, headers, ca, interactive);
 
       if (result.success) {
         successfulUploads.push(file);

package/src/apps/publish-piral.ts

@@ -1,7 +1,17 @@
 import { resolve } from 'path';
 import { publishArtifacts } from '../release';
 import { LogLevels, PiralBuildType } from '../types';
-import { setLogLevel, progress, checkExists, fail, logDone, logReset, publishPackage, matchFiles } from '../common';
+import {
+  setLogLevel,
+  progress,
+  checkExists,
+  fail,
+  logDone,
+  logReset,
+  publishNpmPackage,
+  matchFiles,
+  log,
+} from '../common';
 
 export interface PublishPiralOptions {
   /**
@@ -15,9 +25,14 @@ export interface PublishPiralOptions {
   logLevel?: LogLevels;
 
   /**
-   * The additional fields to supply for the provider.
+   * The options to supply for the provider.
    */
-  fields?: Record<string, string>;
+  opts?: Record<string, string>;
+
+  /**
+   * Defines if authorization tokens can be retrieved interactively.
+   */
+  interactive?: boolean;
 
   /**
    * The provider to use for publishing the release artifacts.
@@ -35,10 +50,16 @@ export const publishPiralDefaults: PublishPiralOptions = {
   logLevel: LogLevels.info,
   type: 'all',
   provider: 'none',
-  fields: {},
+  opts: {},
+  interactive: false,
 };
 
-async function publishEmulator(baseDir: string, source: string, args: Record<string, string> = {}) {
+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);
@@ -48,6 +69,7 @@ async function publishEmulator(baseDir: string, source: string, args: Record<str
   }
 
   const files = await matchFiles(directory, '*.tgz');
+  log('generalDebug_0003', `Found ${files.length} in "${directory}": ${files.join(', ')}`);
 
   if (files.length !== 1) {
     fail('publishEmulatorFilesUnexpected_0111', directory);
@@ -58,7 +80,8 @@ async function publishEmulator(baseDir: string, source: string, args: Record<str
     p.push(`--${c}`, args[c]);
     return p;
   }, [] as Array<string>);
-  await publishPackage(directory, file, flags);
+
+  await publishNpmPackage(directory, file, flags, interactive);
 }
 
 async function publishRelease(
@@ -66,6 +89,7 @@ async function publishRelease(
   source: string,
   providerName: string,
   args: Record<string, string> = {},
+  interactive = false,
 ) {
   const type = 'release';
   const directory = resolve(baseDir, source, type);
@@ -76,7 +100,8 @@ async function publishRelease(
   }
 
   const files = await matchFiles(directory, '**/*');
-  await publishArtifacts(providerName, files, args);
+  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 = {}) {
@@ -84,27 +109,29 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     source = publishPiralDefaults.source,
     type = publishPiralDefaults.type,
     logLevel = publishPiralDefaults.logLevel,
-    fields = publishPiralDefaults.fields,
+    opts = publishPiralDefaults.opts,
     provider = publishPiralDefaults.provider,
+    interactive = publishPiralDefaults.interactive,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
 
   if (type === 'emulator-sources') {
     fail('publishEmulatorSourcesInvalid_0114');
   }
-  
+
   progress('Reading configuration ...');
 
   if (type !== 'release') {
     progress('Publishing emulator package ...');
-    await publishEmulator(baseDir, source, fields);
+    await publishEmulator(fullBase, source, opts, interactive);
     logDone(`Successfully published emulator.`);
     logReset();
   }
 
   if (type !== 'emulator') {
     progress('Publishing release files ...');
-    await publishRelease(baseDir, source, provider, fields);
+    await publishRelease(fullBase, source, provider, opts, interactive);
     logDone(`Successfully published release.`);
     logReset();
   }