@servicetitan/startup 22.1.0 → 22.2.1

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

@@ -0,0 +1,141 @@
+import fs from 'fs';
+import path from 'path';
+import process from 'process';
+import {
+    getFolders,
+    isBundle,
+    isLegacy,
+    isStyleCheckDisabled,
+    isWebComponent,
+    log,
+} from '../../utils';
+import { Command } from './index';
+
+interface FileInfo {
+    path: string;
+    relativePath: string;
+}
+
+const styleCheckError = [
+    '!!!!!!!!!!!!! STYLE CHECK ERROR !!!!!!!!!!!!!',
+    'Style check failed with following errors:',
+];
+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[]) {
+    if (!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 {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        if (isLegacy()) {
+            return;
+        }
+
+        if (isStyleCheckDisabled()) {
+            log.info('style check is disabled');
+
+            return;
+        }
+
+        const projectFolders = getFolders();
+        const files = findStyleFiles(process.cwd(), projectFolders.source);
+
+        if (!isBundle()) {
+            checkStylesLib(files);
+        } else if (isWebComponent()) {
+            checkStylesWebComponent(files);
+        } else {
+            checkStylesApp(files);
+        }
+    }
+}

package/src/cli/index.ts

@@ -10,6 +10,10 @@ import {
     BundlePackage,
     Lint,
     Tests,
+    StylesCheck,
+    MFEPackageClean,
+    MFEPackagePublish,
+    MFEPublish,
 } from './commands';
 
 interface Newable<T> {
@@ -39,6 +43,18 @@ function getCommand(name: string): Newable<Command> {
         case 'test':
             return Tests;
 
+        case 'styles-check':
+            return StylesCheck;
+
+        case 'mfe-publish':
+            return MFEPublish;
+
+        case 'mfe-package-publish':
+            return MFEPackagePublish;
+
+        case 'mfe-package-clean':
+            return MFEPackageClean;
+
         default:
             log.error(`${name}: command not found!`);
             process.exit(127);

package/src/cli/utils/cli-git.ts

@@ -0,0 +1,9 @@
+import { runCommandOutput } from './cli-os';
+
+export const gitGetBranch = (): string => {
+    return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
+};
+
+export const gitGetCommitHash = (): string => {
+    return runCommandOutput('git rev-parse --short HEAD').trim();
+};

package/src/cli/utils/cli-npm.ts

@@ -0,0 +1,55 @@
+import { runCommand, runCommandOutput } from './cli-os';
+
+export const npmGetPackageVersions = (registry: string, packageName: string): string[] => {
+    try {
+        const v = runCommandOutput(
+            `npm show ${packageName} versions --registry ${registry} --json`,
+            { timeout: 10000 }
+        );
+
+        return JSON.parse(v);
+    } catch {
+        return [];
+    }
+};
+
+export const npmGetPackageVersionDates = (
+    registry: string,
+    packageName: string
+): [string, Date][] => {
+    try {
+        const v = runCommandOutput(`npm view ${packageName} time --registry ${registry} --json`, {
+            timeout: 10000,
+        });
+        const map = JSON.parse(v);
+
+        return Object.keys(map).reduce(
+            (out, version) => [...out, [version, new Date(map[version])]],
+            []
+        );
+    } catch {
+        return [];
+    }
+};
+
+export const npmUnpublish = async (
+    registry: string,
+    packageName: string,
+    packageVersion: string
+) => {
+    await runCommand(`npm unpublish ${packageName}@${packageVersion} --registry ${registry}`, {
+        timeout: 10000,
+    });
+};
+
+export const npmPublishDry = async () => {
+    await runCommand('npm publish --dry-run');
+};
+
+export const npmPublish = async (tag?: string) => {
+    await runCommand(['npm publish', !!tag && `--tag ${tag}`]);
+};
+
+export const npmPackageSet = async (key: string, value: string) => {
+    await runCommand(`npm pkg set ${key}=${value}`);
+};

package/src/cli/utils/cli-os.ts

@@ -0,0 +1,76 @@
+import {
+    execSync,
+    ExecSyncOptionsWithBufferEncoding,
+    spawn,
+    SpawnOptionsWithoutStdio,
+} from 'child_process';
+import { log } from '../../utils';
+
+export const runCommand = (
+    command: string | (string | false)[],
+    opts?: SpawnOptionsWithoutStdio
+): Promise<void> => {
+    return new Promise((resolve, reject) => {
+        const commandArray: string[] = Array.isArray(command)
+            ? command
+                  .filter(c => !!c)
+                  .map(c => c.toString())
+                  .join(' ')
+                  .split(' ')
+            : command.split(' ');
+        const fullCommand = commandArray.join(' ');
+
+        const commandName = commandArray.shift();
+
+        if (!commandName) {
+            reject();
+
+            return;
+        }
+
+        log.info(`run command ${fullCommand}`);
+
+        const proc = spawn(commandName, commandArray, opts);
+
+        proc.stdout.pipe(process.stdout);
+        proc.stderr.pipe(process.stderr);
+
+        proc.on('exit', function (code: any) {
+            log.info(`command finished with code ${code}`, fullCommand);
+
+            if (code) {
+                reject();
+            } else {
+                resolve();
+            }
+        });
+    });
+};
+
+export const runCommandOutput = (
+    command: string | (string | false)[],
+    options?: ExecSyncOptionsWithBufferEncoding
+): string => {
+    const commandArray: string[] = Array.isArray(command)
+        ? command
+              .filter(c => !!c)
+              .map(c => c.toString())
+              .join(' ')
+              .split(' ')
+        : command.split(' ');
+    const fullCommand = commandArray.join(' ');
+
+    const commandName = commandArray.shift();
+
+    if (!commandName) {
+        throw new Error();
+    }
+
+    log.info(`run command ${fullCommand}`);
+
+    const result = execSync(fullCommand, options).toString();
+
+    log.info('command finished', result);
+
+    return result;
+};

package/src/utils/get-configuration.ts

@@ -19,6 +19,7 @@ export interface WebpackConfiguration
     > {
     'custom-style-rules'?: boolean;
     'expose-shared-dependencies'?: boolean;
+    'disable-style-check'?: boolean;
     'proxy'?: WebpackDevServerConfiguration['proxy'] | string;
 }
 
@@ -122,3 +123,13 @@ export function getStylelintConfiguration() {
 export function getJestConfiguration() {
     return getConfiguration().test ?? {};
 }
+
+export function isStyleCheckDisabled() {
+    const configuration = getConfiguration();
+
+    if (typeof configuration.webpack !== 'object') {
+        return false;
+    }
+
+    return configuration.webpack?.['disable-style-check'] === true;
+}