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

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,
+  };
+}

package/src/common/piral.ts

@@ -0,0 +1,227 @@
+import { join } from 'path';
+import { runScript } from './scripts';
+import { removeDirectory } from './io';
+import { flattenExternals } from './package';
+import { log, logDone, logInfo, progress } from './log';
+import { createEmulatorSources, createEmulatorWebsite, packageEmulator } from './emulator';
+import { emulatorName, emulatorPackageName, emulatorSourcesName, emulatorWebsiteName, releaseName } from './constants';
+import { callPiralBuild } from '../bundler';
+import { LogLevels, SharedDependency } from '../types';
+
+async function runLifecycle(root: string, scripts: Record<string, string>, type: string) {
+  const script = scripts?.[type];
+
+  if (script) {
+    log('generalDebug_0003', `Running "${type}" ("${script}") ...`);
+    await runScript(script, root);
+    log('generalDebug_0003', `Finished running "${type}".`);
+  } else {
+    log('generalDebug_0003', `No script for "${type}" found ...`);
+  }
+}
+
+export interface BaseBuildPiralOptions {
+  root: string;
+  targetDir: string;
+  logLevel: LogLevels;
+  bundlerName: string;
+  externals: Array<SharedDependency>;
+  ignored: Array<string>;
+  outFile: string;
+  entryFiles: string;
+  optimizeModules: boolean;
+  sourceMaps: boolean;
+  watch: boolean;
+  contentHash: boolean;
+  piralInstances: Array<string>;
+  scripts?: Record<string, string>;
+  hooks?: {
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeEmulator?(e: any): Promise<void>;
+    afterEmulator?(e: any): Promise<void>;
+    beforePackage?(e: any): Promise<void>;
+    afterPackage?(e: any): Promise<void>;
+  };
+  _: Record<string, any>;
+}
+
+export interface BuildEmulatorOptions extends BaseBuildPiralOptions {
+  emulatorType: string;
+}
+
+export async function triggerBuildEmulator({
+  root,
+  logLevel,
+  externals,
+  emulatorType,
+  bundlerName,
+  optimizeModules,
+  sourceMaps,
+  watch,
+  ignored,
+  contentHash,
+  targetDir,
+  outFile,
+  scripts,
+  entryFiles,
+  piralInstances,
+  hooks,
+  _,
+}: BuildEmulatorOptions) {
+  progress('Starting emulator build ...');
+
+  const emulatorPublicUrl = '/';
+  const appDir = emulatorType !== emulatorWebsiteName ? join(targetDir, 'app') : targetDir;
+
+  // since we create this anyway let's just pretend we want to have it clean!
+  await removeDirectory(targetDir);
+
+  await hooks.beforeBuild?.({ root, publicUrl: emulatorPublicUrl, externals, entryFiles, targetDir, piralInstances });
+
+  logInfo(`Bundle ${emulatorName} ...`);
+
+  const {
+    dir: outDir,
+    name,
+    hash,
+  } = await callPiralBuild(
+    {
+      root,
+      piralInstances,
+      emulator: true,
+      standalone: false,
+      optimizeModules,
+      sourceMaps,
+      watch,
+      contentHash,
+      minify: false,
+      externals: flattenExternals(externals),
+      publicUrl: emulatorPublicUrl,
+      entryFiles,
+      logLevel,
+      ignored,
+      outDir: appDir,
+      outFile,
+      _,
+    },
+    bundlerName,
+  );
+
+  await hooks.afterBuild?.({
+    root,
+    publicUrl: emulatorPublicUrl,
+    externals,
+    entryFiles,
+    targetDir,
+    piralInstances,
+    hash,
+    outDir,
+    outFile: name,
+  });
+
+  await runLifecycle(root, scripts, 'piral:postbuild');
+  await runLifecycle(root, scripts, `piral:postbuild-${emulatorName}`);
+
+  await hooks.beforeEmulator?.({ root, externals, targetDir, outDir });
+
+  let rootDir = root;
+
+  switch (emulatorType) {
+    case emulatorPackageName:
+      rootDir = await createEmulatorSources(root, externals, outDir, outFile, logLevel);
+      await hooks.beforePackage?.({ root, externals, targetDir, outDir, rootDir });
+      await packageEmulator(rootDir);
+      await hooks.afterPackage?.({ root, externals, targetDir, outDir, rootDir });
+      break;
+    case emulatorSourcesName:
+      rootDir = await createEmulatorSources(root, externals, outDir, outFile, logLevel);
+      logDone(`Emulator package sources available in "${rootDir}".`);
+      break;
+    case emulatorWebsiteName:
+      rootDir = await createEmulatorWebsite(root, externals, outDir, outFile, logLevel);
+      logDone(`Emulator website available in "${rootDir}".`);
+      break;
+  }
+
+  await hooks.afterEmulator?.({ root, externals, targetDir, outDir, rootDir });
+}
+
+export interface BuildShellOptions extends BaseBuildPiralOptions {
+  minify: boolean;
+  publicUrl: string;
+}
+
+export async function triggerBuildShell({
+  root,
+  targetDir,
+  bundlerName,
+  minify,
+  optimizeModules,
+  entryFiles,
+  piralInstances,
+  sourceMaps,
+  logLevel,
+  ignored,
+  watch,
+  outFile,
+  publicUrl,
+  contentHash,
+  externals,
+  hooks,
+  scripts,
+  _,
+}: BuildShellOptions) {
+  progress('Starting release build ...');
+
+  // since we create this anyway let's just pretend we want to have it clean!
+  await removeDirectory(targetDir);
+
+  logInfo(`Bundle ${releaseName} ...`);
+
+  await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, piralInstances });
+
+  const {
+    dir: outDir,
+    name,
+    hash,
+  } = await callPiralBuild(
+    {
+      root,
+      piralInstances,
+      emulator: false,
+      standalone: false,
+      optimizeModules,
+      sourceMaps,
+      watch,
+      contentHash,
+      minify,
+      externals: flattenExternals(externals),
+      publicUrl,
+      outFile,
+      outDir: targetDir,
+      entryFiles,
+      logLevel,
+      ignored,
+      _,
+    },
+    bundlerName,
+  );
+
+  await hooks.afterBuild?.({
+    root,
+    publicUrl,
+    externals,
+    entryFiles,
+    targetDir,
+    piralInstances,
+    outDir,
+    outFile: name,
+    hash,
+  });
+
+  await runLifecycle(root, scripts, 'piral:postbuild');
+  await runLifecycle(root, scripts, `piral:postbuild-${releaseName}`);
+
+  logDone(`Files for publication available in "${outDir}".`);
+}

package/src/common/release.ts

@@ -0,0 +1,62 @@
+import { basename, dirname, relative, resolve } from 'path';
+import { fail, log } from './log';
+import { publishNpmPackage } from './npm';
+import { FormDataObj, postForm } from './http';
+import { checkExists, matchFiles, readBinary } from './io';
+import { PublishScheme } from '../types';
+
+export async function publishPackageEmulator(
+  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);
+}
+
+export async function publishWebsiteEmulator(
+  version: string,
+  url: string,
+  apiKey: string,
+  mode: PublishScheme,
+  directory: string,
+  files: Array<string>,
+  interactive: boolean,
+  headers?: Record<string, string>,
+  ca?: Buffer,
+) {
+  const data: FormDataObj = {
+    version,
+    type: 'custom',
+  };
+
+  for (const file of files) {
+    const relPath = relative(directory, file);
+    const fileName = basename(file);
+    const content = await readBinary(dirname(file), fileName);
+    data[relPath] = [content, fileName];
+  }
+
+  return await postForm(url, mode, apiKey, data, headers, ca, interactive);
+}

package/src/helpers.ts

@@ -7,12 +7,12 @@ import type {
   PiletPublishSource,
   PiralBuildType,
   PiletBuildType,
-  PiletPublishScheme,
+  PublishScheme,
   SourceLanguage,
 } from './types';
 
 export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'v3', 'mf', 'none'];
-export const publishModeKeys: Array<PiletPublishScheme> = ['none', 'basic', 'bearer', 'digest'];
+export const publishModeKeys: Array<PublishScheme> = ['none', 'basic', 'bearer', 'digest'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const piralBuildTypeKeys: Array<PiralBuildType> = [
   'all',

package/src/messages.ts

@@ -2585,6 +2585,28 @@ export function requiredEmulatorAssetDownloadSkipped_0123(url: string): QuickMes
   return [LogLevels.warning, '0123', `Could not download asset file at "${url}".`];
 }
 
+/**
+ * @kind Error
+ *
+ * @summary
+ * The emulator.json and associated files could not be found in the source directory.
+ *
+ * @abstract
+ * Only an emulator website can be published using `piral publish`. Other artifacts such as
+ * standard release artifacts or the package emulator (tgz) need to be published using other
+ * mechanisms such as `npm publish`.
+ * 
+ * If no emulator website exists you can either build one using the `--fresh` flag with
+ * `piral publish` (i.e., `piral publish --fresh`) or preparing the build using `piral build`
+ * with the `--type emulator-website` flag.
+ *
+ * @see
+ * - [Emulator](https://docs.piral.io/concepts/T01-emulator)
+ */
+export function missingEmulatorWebsite_0130(path: string): QuickMessage {
+  return [LogLevels.error, '0130', `Could not find the files for an emulator website at "${path}".`];
+}
+
 /**
  * @kind Warning
  *

package/src/platforms/web.ts

@@ -6,7 +6,16 @@ import { config } from '../common/config';
 import { openBrowser } from '../common/browser';
 import { checkExistingDirectory, findFile } from '../common/io';
 import { getAvailablePort } from '../common/port';
-import { PlatformStartShellOptions, PlatformStartModuleOptions } from '../types';
+import { PlatformStartShellOptions, PlatformStartModuleOptions, NetworkSpec } from '../types';
+
+async function getPort(network: NetworkSpec) {
+  if (network.type === 'proposed') {
+    network.port = await getAvailablePort(network.port);
+    network.type = 'fixed';
+  }
+
+  return network.port;
+}
 
 async function startModule(options: PlatformStartModuleOptions) {
   const {
@@ -16,7 +25,7 @@ async function startModule(options: PlatformStartModuleOptions) {
     feed,
     publicUrl,
     customkrasrc,
-    originalPort,
+    network,
     hooks,
     registerWatcher,
     registerEnd,
@@ -60,7 +69,8 @@ async function startModule(options: PlatformStartModuleOptions) {
 
   configs.forEach(registerWatcher);
 
-  const port = await getAvailablePort(originalPort);
+  const shouldNotify = network.type === 'proposed';
+  const port = await getPort(network);
   const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
 
   log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
@@ -68,7 +78,10 @@ async function startModule(options: PlatformStartModuleOptions) {
   const krasServer = buildKrasWithCli(krasConfig);
   krasServer.setMaxListeners(maxListeners);
   krasServer.removeAllListeners('open');
-  krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
+
+  if (shouldNotify) {
+    krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
+  }
 
   await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
   await krasServer.start();
@@ -88,7 +101,7 @@ async function startShell(options: PlatformStartShellOptions) {
     publicUrl,
     bundler,
     customkrasrc,
-    originalPort,
+    network,
     hooks,
     registerWatcher,
     registerEnd,
@@ -123,21 +136,25 @@ async function startShell(options: PlatformStartShellOptions) {
 
   configs.forEach(registerWatcher);
 
-  const port = await getAvailablePort(originalPort);
+  const shouldNotify = network.type === 'proposed';
+  const port = await getPort(network);
   const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
   log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
 
   const krasServer = buildKrasWithCli(krasConfig);
   krasServer.setMaxListeners(16);
   krasServer.removeAllListeners('open');
-  krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
+
+  if (shouldNotify) {
+    krasServer.on('open', notifyServerOnline(publicUrl, krasConfig.api));
+  }
 
   await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
   await krasServer.start();
   openBrowser(open, port, publicUrl, !!krasConfig.ssl);
   await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
 
-  registerEnd(() => krasServer.stop());
+  registerEnd(async () => krasServer.stop());
 }
 
 export function setup() {

package/src/types/common.ts

@@ -112,12 +112,17 @@ export interface BundleDetails {
 export interface Bundler {
   readonly bundle: BundleDetails;
   start(): void;
-  stop(): void;
+  stop(): Promise<void>;
   on(cb: (args: any) => void): void;
   off(cb: (args: any) => void): void;
   ready(): Promise<void>;
 }
 
+export interface NetworkSpec {
+  port: number;
+  type: 'proposed' | 'fixed';
+}
+
 export interface PlatformStartModuleOptions {
   appDir?: string;
   open: boolean;
@@ -125,7 +130,7 @@ export interface PlatformStartModuleOptions {
   feed: string | Array<string>;
   publicUrl: string;
   customkrasrc: string;
-  originalPort: number;
+  network: NetworkSpec;
   hooks: Record<string, Function>;
   registerWatcher(file: string): void;
   registerEnd(cb: () => void): void;
@@ -143,10 +148,10 @@ export interface PlatformStartShellOptions {
   publicUrl: string;
   bundler: Bundler;
   customkrasrc: string;
-  originalPort: number;
+  network: NetworkSpec;
   hooks: Record<string, Function>;
   registerWatcher(file: string): void;
-  registerEnd(cb: () => void): void;
+  registerEnd(cb: () => void | Promise<void>): void;
 }
 
 export interface ReleaseProvider {

package/src/types/public.ts

@@ -1,5 +1,5 @@
 import { Argv, Arguments } from 'yargs';
-import { RuleRunner, PiletRuleContext, PiralRuleContext, LogLevels, SharedDependency, ReleaseProvider } from './common';
+import { RuleRunner, PiletRuleContext, PiralRuleContext, LogLevels, SharedDependency } from './common';
 
 export interface ToolCommandRunner<U = {}> {
   (args: Arguments<U>): void | Promise<void>;
@@ -44,7 +44,6 @@ export interface CliPluginApi {
   withPiletRule(ruleName: string, runner: RuleRunner<PiletRuleContext>): CliPluginApi;
   withPatcher(packageName: string, patch: PackagePatcher): CliPluginApi;
   withBundler(bundlerName: string, bundler: BundlerDefinition): CliPluginApi;
-  withReleaseProvider(providerName: string, provider: ReleaseProvider): CliPluginApi;
 }
 
 export interface CliPlugin {
@@ -242,7 +241,7 @@ export type AuthConfig = HeaderAuthConfig | HttpAuthConfig;
 
 export type SourceLanguage = 'js' | 'ts';
 
-export type PiletPublishScheme = 'none' | 'digest' | 'bearer' | 'basic';
+export type PublishScheme = 'none' | 'digest' | 'bearer' | 'basic';
 
 export type PiletPublishSource = 'local' | 'npm' | 'remote';
 

package/lib/release.d.ts

@@ -1,7 +0,0 @@
-import { ReleaseProvider } from './types';
-export interface QualifiedReleaseProvider {
-    name: string;
-    action: ReleaseProvider;
-}
-export declare function setReleaseProvider(provider: QualifiedReleaseProvider): void;
-export declare function publishArtifacts(providerName: string, directory: string, files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;

package/lib/release.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishArtifacts = exports.setReleaseProvider = void 0;
-const path_1 = require("path");
-const common_1 = require("./common");
-const helpers_1 = require("./helpers");
-async function getVersion(directory) {
-    const data = await (0, common_1.findFile)(directory, 'package.json');
-    if (!data) {
-        (0, common_1.fail)('packageJsonNotFound_0020');
-    }
-    const { version } = require(data);
-    return version;
-}
-const providers = {
-    none() {
-        return Promise.resolve();
-    },
-    async xcopy(_, files, args) {
-        const { target } = args;
-        if (!target) {
-            (0, common_1.fail)('publishXcopyMissingTarget_0112');
-        }
-        await Promise.all(files.map(async (file) => (0, common_1.copy)(file, (0, path_1.resolve)(target, (0, path_1.basename)(file)))));
-    },
-    async feed(directory, files, args, interactive) {
-        const { url, apiKey, scheme = 'basic', version = await getVersion(directory) } = args;
-        if (!url) {
-            (0, common_1.fail)('publishFeedMissingUrl_0115');
-        }
-        if (!version) {
-            (0, common_1.fail)('publishFeedMissingVersion_0116');
-        }
-        const data = {
-            version,
-            type: 'custom',
-        };
-        for (const file of files) {
-            const relPath = (0, path_1.relative)(directory, file);
-            const fileName = (0, path_1.basename)(file);
-            const content = await (0, common_1.readBinary)((0, path_1.dirname)(file), fileName);
-            data[relPath] = [content, fileName];
-        }
-        await (0, common_1.postForm)(url, scheme, apiKey, data, {}, undefined, interactive);
-    },
-};
-function findReleaseProvider(providerName) {
-    const provider = providers[providerName];
-    if (typeof provider !== 'function') {
-        (0, common_1.fail)('publishProviderMissing_0113', providerName, helpers_1.availableReleaseProviders);
-    }
-    return provider;
-}
-helpers_1.availableReleaseProviders.push(...Object.keys(providers));
-function setReleaseProvider(provider) {
-    providers[provider.name] = provider.action;
-    if (!helpers_1.availableReleaseProviders.includes(provider.name)) {
-        helpers_1.availableReleaseProviders.push(provider.name);
-    }
-}
-exports.setReleaseProvider = setReleaseProvider;
-function publishArtifacts(providerName, directory, files, args, interactive) {
-    const runRelease = findReleaseProvider(providerName);
-    return runRelease(directory, files, args, interactive);
-}
-exports.publishArtifacts = publishArtifacts;
-//# sourceMappingURL=release.js.map