@servicetitan/startup 31.4.0 → 31.5.0

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();

package/src/cli/commands/styles-check.ts

@@ -1,151 +1,48 @@
 import fs from 'fs';
+import { glob } from 'glob';
 import path from 'path';
-import process from 'process';
-import {
-    getFolders,
-    getPackageData,
-    isBundle,
-    isLegacy,
-    isStyleCheckDisabled,
-    isWebComponent,
-    loadSharedDependencies,
-    log,
-} from '../../utils';
+import { getFolders, isBundle, isLegacy, isStyleCheckDisabled, log, logErrors } from '../../utils';
 import { Command } from './index';
 
-interface FileInfo {
-    path: string;
-    relativePath: string;
-}
-
-const styleCheckError = [
-    '!!!!!!!!!!!!! STYLE CHECK ERROR !!!!!!!!!!!!!',
-    'Style check failed with following errors:',
+const patterns = [
+    "@import '~@servicetitan/tokens/core/tokens.css';",
+    "@import '~@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';",
+    "@import '~@servicetitan/design-system/dist/system.min.css';",
 ];
-const designSystem = 'design-system.css';
-
-enum PackageType {
-    App = 'app',
-    WebComponent = 'web_component',
-}
-
-function readDir(startPath: string, filter: string[]): string[] {
-    let out: string[] = [];
-
-    if (!fs.existsSync(startPath)) {
-        return out;
-    }
-
-    const files = fs.readdirSync(startPath);
-    for (const file of files) {
-        const filename = path.join(startPath, file);
-        const stat = fs.lstatSync(filename);
-
-        if (stat.isDirectory()) {
-            out = [...out, ...readDir(filename, filter)];
-        } else if (filter.some(f => filename.endsWith(f))) {
-            out.push(filename);
-        }
-    }
-
-    return out;
-}
-
-const findStyleFiles = (basePath: string, sourceFolder: string): FileInfo[] => {
-    const sourcePath = path.join(basePath, sourceFolder);
-    const files = readDir(sourcePath, ['.css', '.less']);
-
-    return files.map(f => ({
-        path: f,
-        relativePath: f.replace(sourcePath, '').substring(1),
-    }));
-};
-
-const checkStyleFiles = (files: FileInfo[], packageType: PackageType): string[] | undefined => {
-    const errors = [];
-    const patterns = [
-        "@import '~@servicetitan/tokens/core/tokens.css';",
-        "@import '~@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';",
-        "@import '~@servicetitan/design-system/dist/system.min.css';",
-    ];
-
-    for (const file of files) {
-        if (
-            [PackageType.App, PackageType.WebComponent].includes(packageType) &&
-            file.relativePath === designSystem
-        ) {
-            continue;
-        }
-
-        const content = fs.readFileSync(file.path);
-
-        for (const pattern of patterns) {
-            if (content.includes(pattern)) {
-                errors.push(`file ${file.relativePath} contains link to "${pattern}"`);
-            }
-        }
-    }
-
-    return errors.length ? errors : undefined;
-};
-
-const checkErrors = (errors: string[] | undefined) => {
-    if (!errors) {
-        log.info('style check: OK');
-    } else {
-        log.error([...styleCheckError, ...errors].join('\n'));
-        throw new Error('style check error, please check logs above');
-    }
-};
-
-function checkStylesLib(_files: FileInfo[]) {
-    /* ToDo: add checks for libraries */
-}
-
-function checkStylesApp(files: FileInfo[]) {
-    const { dependencies, sharedDependencies } = getPackageData();
-    if (
-        loadSharedDependencies(dependencies, sharedDependencies)['@servicetitan/design-system'] &&
-        !files.some(f => f.relativePath === designSystem)
-    ) {
-        log.warning(
-            "application doesn't have design-system.css. Please check https://docs.st.dev/docs/frontend/micro-frontends#host-configuration"
-        );
-    }
-
-    checkErrors(checkStyleFiles(files, PackageType.App));
-}
-
-function checkStylesWebComponent(files: FileInfo[]) {
-    checkErrors(checkStyleFiles(files, PackageType.WebComponent));
-}
 
 export class StylesCheck implements Command {
-    description() {
-        return undefined;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/require-await
+    @logErrors
     async execute() {
-        if (isLegacy()) {
+        if (isLegacy() || !isBundle()) {
             return;
         }
 
         if (isStyleCheckDisabled()) {
             log.info('style check is disabled');
-
             return;
         }
 
-        const projectFolders = getFolders();
-        const files = findStyleFiles(process.cwd(), projectFolders.source);
+        let ok = true;
+        const { source } = getFolders();
+        const files = await glob(`${source}/**/*.{css,less}`);
+
+        for (const file of files) {
+            const relativePath = path.relative(source, file);
+            if (relativePath === 'design-system.css') {
+                continue;
+            }
+
+            const content = fs.readFileSync(file, { encoding: 'utf-8' });
+            patterns.forEach(pattern => {
+                if (content.includes(pattern)) {
+                    log.error(`Error: file ${relativePath} contains "${pattern}"`);
+                    ok = false;
+                }
+            });
+        }
 
-        if (!isBundle()) {
-            checkStylesLib(files);
-        } else if (isWebComponent()) {
-            checkStylesWebComponent(files);
-        } else {
-            checkStylesApp(files);
+        if (!ok) {
+            throw new Error('style check failed, see errors above');
         }
     }
 }

package/src/cli/commands/types.ts

@@ -1,7 +1,7 @@
 export interface Command {
     greedy?: boolean;
     execute(): Promise<void>;
-    description(): string | undefined;
+    description?(): string;
 }
 
 export type Newable<T> = new (...args: any[]) => T;