@servicetitan/startup 31.3.2 → 31.5.0

package/src/cli/commands/build.ts

@@ -13,12 +13,13 @@ interface Args {
     'use-tsc'?: boolean;
 }
 
-export enum BuildProcesses {
-    'Compile',
-    'KendoUILicense',
-    'PreparePackage',
-    'TypeCheck',
-    'BundlePackage',
+enum BuildProcesses {
+    Compile,
+    KendoUILicense,
+    PreparePackage,
+    TypeCheck,
+    BundleExposedDependencies,
+    BundlePackage,
 }
 
 export class Build implements Command {
@@ -50,6 +51,9 @@ export class Build implements Command {
         }
 
         const scope = packages.map(({ name }) => name);
+        const webpackScope = packages
+            .filter(({ type }) => type === PackageType.Webpack)
+            .map(({ name }) => name);
 
         const processTree = new ProcessTree<typeof BuildProcesses>();
 
@@ -66,25 +70,17 @@ export class Build implements Command {
             dependsOn: [BuildProcesses.PreparePackage],
         });
         processTree.add(
-            BuildProcesses.BundlePackage,
+            BuildProcesses.BundleExposedDependencies,
             () => {
-                const webpackScope = packages
-                    .filter(({ type }) => type === PackageType.Webpack)
-                    .map(({ name }) => name);
-
                 if (webpackScope.length === 0) {
                     return Promise.resolve();
                 }
-
                 return lernaExec({
                     'cmd': 'startup bundle-package',
                     'scope': webpackScope,
+                    'parallel': true,
                     'stream': true,
-                    '--': [
-                        ...[this.args.config ? `--config "${this.args.config}"` : undefined],
-                        ...[this.args['code-coverage'] ? '--code-coverage' : undefined],
-                        ...[this.args.stat ? '--stat' : undefined],
-                    ].filter(item => !!item) as string[],
+                    '--': ['--exposed-dependencies'],
                 });
             },
             {
@@ -95,6 +91,26 @@ export class Build implements Command {
                 ],
             }
         );
+        processTree.add(
+            BuildProcesses.BundlePackage,
+            () => {
+                if (webpackScope.length === 0) {
+                    return Promise.resolve();
+                }
+
+                return lernaExec({
+                    'cmd': 'startup bundle-package',
+                    'scope': webpackScope,
+                    'stream': true,
+                    '--': [
+                        ...[this.args.config ? `--config "${this.args.config}"` : undefined],
+                        ...[this.args['code-coverage'] ? '--code-coverage' : undefined],
+                        ...[this.args.stat ? '--stat' : undefined],
+                    ].filter(item => !!item) as string[],
+                });
+            },
+            { dependsOn: [BuildProcesses.BundleExposedDependencies] }
+        );
 
         await processTree.run();
     }

package/src/cli/commands/bundle-package.ts

@@ -1,12 +1,11 @@
-import path from 'path';
-
-import { log, logErrors } from '../../utils';
-import { bundle, bundleWatch, getModuleType } from '../utils';
+import { getTsConfig, log, logErrors } from '../../utils';
+import { bundle, getModuleType } from '../utils';
 import { Command } from '.';
 
 interface Args {
     'config'?: string;
     'code-coverage'?: boolean;
+    'exposed-dependencies'?: boolean;
     'stat'?: boolean;
     'watch'?: boolean;
 }
@@ -14,31 +13,23 @@ interface Args {
 export class BundlePackage implements Command {
     constructor(private args: Args) {}
 
-    description() {
-        return undefined;
-    }
-
     @logErrors
     async execute() {
         const { config, stat = false, watch } = this.args;
 
-        if (getModuleType(path.join(process.cwd(), './tsconfig.json')) !== 'esnext') {
+        if (getModuleType(getTsConfig()) !== 'esnext') {
             log.warning(
-                '\x1b[31m',
-                'It\'s recommended to use the "esnext" option for the "compilerOptions.module" in the "tsconfig.json" for the Webpack packages!',
-                '\x1b[0m'
+                'webpack packages should set compilerOptions.module to "esnext" in tsconfig.json'
             );
         }
 
-        const options = {
-            config,
+        const emitExposedDependencies = this.args['exposed-dependencies'];
+        const options: Parameters<typeof bundle>[0] = {
+            ...(emitExposedDependencies ? {} : { config }),
             codeCoverage: this.args['code-coverage'],
+            emitExposedDependencies,
         };
 
-        if (!watch) {
-            await bundle({ buildStat: stat, ...options });
-        } else {
-            await bundleWatch(options);
-        }
+        await bundle({ buildStat: stat, ...options, watch });
     }
 }

package/src/cli/commands/clean.ts

@@ -4,7 +4,7 @@ import { Command } from './types';
 
 export class Clean implements Command {
     description() {
-        return 'resets project to fresh state';
+        return 'reset project to fresh state';
     }
 
     @logErrors

package/src/cli/commands/eslint.ts

@@ -11,10 +11,6 @@ interface Args {
 export class ESLintCommand implements Command {
     constructor(private args: Args) {}
 
-    description() {
-        return undefined;
-    }
-
     @logErrors
     async execute() {
         const { _: paths, fix } = this.args;

package/src/cli/commands/get-command.ts

@@ -19,6 +19,7 @@ import { Start } from './start';
 import { StylesCheck } from './styles-check';
 import { Tests } from './tests';
 import { Command, Newable } from './types';
+import { UploadSourcemaps } from './upload-sourcemaps';
 
 const commands: Record<CommandName, Newable<Command>> = {
     [CommandName.build]: Build,
@@ -39,6 +40,7 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName['styles-check']]: StylesCheck,
     [CommandName.test]: Tests,
     [CommandName.task]: RunTask,
+    [CommandName['upload-sourcemaps']]: UploadSourcemaps,
 };
 
 export function getCommand(name: CommandName): Newable<Command> | undefined {

package/src/cli/commands/get-user-commands.ts

@@ -13,7 +13,7 @@ export function getUserCommands() {
         .map(name => {
             const Command = getCommand(name)!;
             // eslint-disable-next-line @typescript-eslint/naming-convention
-            return { name, description: new Command({ _: [] }).description() };
+            return { name, description: new Command({ _: [] }).description?.() };
         })
         .filter(({ description }) => !!description) as UserCommand[];
 }

package/src/cli/commands/mfe-package-clean.ts

@@ -4,7 +4,7 @@ import { gitGetBranch } from '../utils/cli-git';
 import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../utils/cli-npm';
 import { Command } from './types';
 
-export interface ArgsPackageClean {
+export interface Args {
     all?: true;
     branch?: string;
     count?: number;
@@ -13,11 +13,7 @@ export interface ArgsPackageClean {
 }
 
 export class MFEPackageClean implements Command {
-    constructor(private args: ArgsPackageClean) {}
-
-    description() {
-        return undefined;
-    }
+    constructor(private readonly args: Args) {}
 
     @logErrors
     async execute() {

package/src/cli/commands/mfe-package-publish.ts

@@ -1,131 +1,165 @@
 import path from 'path';
 import fs from 'fs';
 import { getFolders, isWebComponent, log, logErrors, readJson } from '../../utils';
+import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
 import { gitGetBranch, gitGetCommitHash } from '../utils/cli-git';
 import { npmGetPackageVersions, npmPackageSet, npmPublish, npmTagVersion } from '../utils/cli-npm';
-import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { runCommand } from '../utils/cli-os';
 import { getDefaultBuildVersion } from '../utils/publish';
-import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
 import { Command } from './types';
 
-export interface ArgsPackagePublish {
+export interface Args {
     branch?: string;
     build?: string;
     dry?: boolean;
     force?: boolean;
     registry?: string;
     tag?: string;
+    uploadSourcemaps?: boolean;
 }
 
-export class MFEPackagePublish implements Command {
-    constructor(private args: ArgsPackagePublish) {}
+interface PublishData {
+    buildVersion: string;
+    dry: boolean;
+    fallbackTag: string;
+    force: boolean;
+    isBranchConfigured: boolean;
+    registry: string;
+    tag: string;
+    uploadSourcemaps: boolean;
+    version: string;
+}
 
-    description() {
-        return undefined;
-    }
+interface PackageJson {
+    name: string;
+    private?: boolean;
+    files?: string[];
+}
+
+export class MFEPackagePublish implements Command {
+    constructor(private readonly args: Args) {}
 
     @logErrors
     async execute() {
-        if (!isWebComponent()) {
-            throw new Error('only web-components can be published');
+        if (this.args.dry) {
+            log.warning('DRY-RUN MODE ENABLED, WILL NOT PUBLISH PACKAGES');
         }
 
-        const packageJson = readJson('package.json');
-
-        if (packageJson.private) {
-            log.info('package is private, skipping publish');
+        const packageJson = readJson<PackageJson>('package.json');
+        const data = this.getPublishData();
+        if (!this.checkPackage(packageJson, data)) {
             return;
         }
 
-        const data = this.getPublishData();
-        const packageName = packageJson.name;
+        if (!(await this.tryTagExistingVersion(packageJson, data))) {
+            await this.publishPackage(packageJson, data);
+        }
 
-        if (!data.version) {
-            log.info('no build version found, skipping publish');
-            return;
+        if (data.uploadSourcemaps) {
+            this.uploadSourcemaps(data);
+        }
+    }
+
+    private get dryRunPrefix() {
+        return this.args.dry ? '(dry-run) ' : '';
+    }
+
+    private checkPackage(packageJson: PackageJson, { force, isBranchConfigured }: PublishData) {
+        if (!isWebComponent()) {
+            throw new Error('only web-components can be published');
         }
 
-        if (!data.isBranchConfigured && !data.force) {
-            log.info(
+        if (packageJson.private) {
+            log.warning('package is private, skipping publish');
+            return false;
+        }
+
+        if (!isBranchConfigured && !force) {
+            log.warning(
                 'branch is not configured for publishing, use --force flag to publish if needed'
             );
-            return;
+            return false;
         }
 
-        this.validateMetadata(data.version);
+        return true;
+    }
 
-        const versions = npmGetPackageVersions(data.registry, packageName);
-        const dryRunPrefix = data.dry ? '(dry-run) ' : '';
+    private async tryTagExistingVersion(
+        { name }: PackageJson,
+        { dry, registry, tag, version }: PublishData
+    ) {
+        const versions = npmGetPackageVersions(registry, name);
+        if (!versions.includes(version)) {
+            return false;
+        }
 
-        if (versions.includes(data.version)) {
-            log.info(
-                `${dryRunPrefix}${packageName} version ${data.version} is already published, skipping publish`
-            );
+        log.warning(
+            `${this.dryRunPrefix}${name} version ${version} is already published, skipping publish`
+        );
 
-            if (data.tag) {
-                log.info(
-                    `${dryRunPrefix}adding tag "${data.tag}" to ${packageName} version ${data.version}`
-                );
-                if (!data.dry) {
-                    await npmTagVersion({
-                        packageName,
-                        packageVersion: data.version,
-                        registry: data.registry,
-                        tag: data.tag,
-                    });
-                }
+        if (tag) {
+            log.info(`${this.dryRunPrefix}adding tag "${tag}" to ${name} version ${version}`);
+            if (!dry) {
+                await npmTagVersion({
+                    packageName: name,
+                    packageVersion: version,
+                    registry,
+                    tag,
+                });
             }
-            return;
         }
+        return true;
+    }
+
+    private async publishPackage(
+        packageJson: PackageJson,
+        { dry, fallbackTag, registry, tag, version }: PublishData
+    ) {
+        this.validateMetadata(version);
 
-        await npmPackageSet('version', data.version);
-        await npmPackageSet('publishConfig.registry', data.registry);
+        await npmPackageSet('version', version);
+        await npmPackageSet('publishConfig.registry', registry);
         await this.setPackageFiles(packageJson);
 
-        await npmPublish({ dry: data.dry, tag: data.tag || data.fallbackTag });
+        await npmPublish({ dry, tag: tag || fallbackTag });
+        log.info(`${this.dryRunPrefix}published ${packageJson.name} version ${version}`);
+    }
 
-        log.info(`${dryRunPrefix}published ${packageName} version ${data.version}`);
+    private uploadSourcemaps({ dry, version }: PublishData) {
+        const options = [...[dry && '--dry'], `--releaseVersion=${version}`].filter(
+            option => !!option
+        ) as string[];
+
+        runCommand(`npx startup upload-sourcemaps ${options.join(' ')}`);
     }
 
-    private getPublishData(): {
-        version: string;
-        buildVersion: string;
-        tag: string;
-        registry: string;
-        dry: boolean;
-        force: boolean;
-        isBranchConfigured: boolean;
-        fallbackTag: string;
-    } {
+    private getPublishData(): PublishData {
         const cli = this.args;
         const branch = cli.branch ?? gitGetBranch();
         const branchConfig = getBranchesConfigs()[branch];
+
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         const buildVersion = cli.build || getDefaultBuildVersion(branch, gitGetCommitHash());
-
-        let tag: string;
-
-        if (cli.tag) {
-            tag = cli.tag;
-        } else {
-            tag = branchConfig?.publishTag ?? '';
-        }
-
         const registry = cli.registry ?? 'https://verdaccio.servicetitan.com';
+        const tag = cli.tag ?? branchConfig?.publishTag ?? '';
+        const uploadSourcemaps = cli.uploadSourcemaps ?? branchConfig?.uploadSourcemaps ?? true;
+        const version = '0.0.0-' + buildVersion;
 
         return {
-            tag,
-            version: '0.0.0-' + buildVersion,
             buildVersion,
-            registry,
             dry: !!cli.dry,
+            fallbackTag: 'latest',
             force: !!cli.force,
             isBranchConfigured: !!branchConfig,
-            fallbackTag: 'latest',
+            registry,
+            tag,
+            uploadSourcemaps,
+            version,
         };
     }
 
-    private async setPackageFiles({ files: inputFiles }: { files?: string[] }) {
+    private async setPackageFiles({ files: inputFiles }: PackageJson) {
         let outputFiles = ['dist/bundle', 'dist/metadata.json', 'package.json'];
 
         if (inputFiles?.length) {

package/src/cli/commands/mfe-publish.ts

@@ -1,10 +1,10 @@
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
-import { ArgsPackageClean } from './mfe-package-clean';
-import { ArgsPackagePublish } from './mfe-package-publish';
+import { Args as CleanArgs } from './mfe-package-clean';
+import { Args as PublishArgs } from './mfe-package-publish';
 import { Command } from './types';
 import { lernaExec } from '../utils';
 
-interface Args extends Omit<ArgsPackagePublish, 'branch'>, ArgsPackageClean {
+interface Args extends PublishArgs, CleanArgs {
     clean?: boolean;
     concurrency?: number;
     scope?: string | string[];
@@ -38,7 +38,8 @@ export class MFEPublish implements Command {
     }
 
     getPublishOptions() {
-        const { build, branch, dry, force, registry, tag } = this.args as ArgsPackagePublish;
+        const { build, branch, dry, force, registry, tag, uploadSourcemaps } = this
+            .args as PublishArgs;
         return [
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
@@ -46,11 +47,13 @@ export class MFEPublish implements Command {
             ...[force && '--force'],
             ...[registry && `--registry ${registry}`],
             ...[typeof tag === 'string' && `--tag ${tag}`],
+            ...[uploadSourcemaps === true && `--upload-sourcemaps`],
+            ...[uploadSourcemaps === false && `--no-upload-sourcemaps`],
         ].filter(item => !!item) as string[];
     }
 
     getCleanOptions() {
-        const { all, branch, count, dry, registry } = this.args as ArgsPackageClean;
+        const { all, branch, count, dry, registry } = this.args as CleanArgs;
         return [
             ...[all && '--all'],
             ...[typeof branch === 'string' && `--branch ${branch}`],

package/src/cli/commands/prepare-package.ts

@@ -9,10 +9,6 @@ interface Args {
 export class PreparePackage implements Command {
     constructor(private args: Args) {}
 
-    description() {
-        return undefined;
-    }
-
     @logErrors
     execute() {
         return copyFiles({ watch: this.args.watch });

package/src/cli/commands/run-task.ts

@@ -20,10 +20,6 @@ const tasks: Record<string, new (args: Args) => Task> = {
 export class RunTask implements Command {
     constructor(private readonly args: Args) {}
 
-    description() {
-        return undefined;
-    }
-
     @logErrors
     async execute() {
         const taskName = this.args._[0];

package/src/cli/commands/start.ts

@@ -18,12 +18,13 @@ interface Args {
     'use-tsc'?: boolean;
 }
 
-export enum StartProcesses {
+enum StartProcesses {
     Compile,
     KendoUILicense,
     PreparePackage,
     PreparePackageWatch,
     TypeCheck,
+    BundleExposedDependencies,
     BundlePackage,
 }
 
@@ -52,6 +53,9 @@ export class Start implements Command {
         }
 
         const scope = packages.map(({ name }) => name);
+        const webpackScope = packages
+            .filter(({ type }) => type === PackageType.Webpack)
+            .map(({ name }) => name);
 
         const processTree = new ProcessTree<typeof StartProcesses>();
 
@@ -122,12 +126,25 @@ export class Start implements Command {
             () => typeCheck({ packages: scope, watch: true }),
             { dependsOn: [StartProcesses.PreparePackage] }
         );
+        processTree.add(
+            StartProcesses.BundleExposedDependencies,
+            () => {
+                if (webpackScope.length === 0) {
+                    return Promise.resolve();
+                }
+                return lernaExec({
+                    'cmd': 'startup bundle-package',
+                    'scope': webpackScope,
+                    'parallel': true,
+                    'stream': true,
+                    '--': ['--exposed-dependencies', '--use-watch-config'],
+                });
+            },
+            { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
+        );
         processTree.add(
             StartProcesses.BundlePackage,
             () => {
-                const webpackScope = packages
-                    .filter(({ type }) => type === PackageType.Webpack)
-                    .map(({ name }) => name);
                 if (webpackScope.length === 0) {
                     return Promise.resolve();
                 }
@@ -143,7 +160,7 @@ export class Start implements Command {
                     ].filter(item => !!item) as string[],
                 });
             },
-            { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
+            { dependsOn: [StartProcesses.BundleExposedDependencies] }
         );
 
         await processTree.run();