chore: finish version and changelog scripts

Author: Illia Obukhau

packages/tools/release-utils-internal/bin/rui-bump-version.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env ts-node-script
+
+import { prompt } from "enquirer";
+import { selectPackage } from "../src";
+import { getNextVersion, writeVersion } from "../src/bump-version";
+
+import { oraPromise } from "../src/cli-utils";
+
+async function main(): Promise<void> {
+    const pkg = await selectPackage();
+    const nextVersion = await getNextVersion(pkg.version);
+
+    const { save } = await prompt<{ save: boolean }>({
+        type: "confirm",
+        name: "save",
+        message: "Save changes?"
+    });
+
+    if (save) {
+        await oraPromise(writeVersion(pkg, nextVersion), "Writing changes...");
+        console.log("Done.");
+    } else {
+        console.log("Exit without changes.");
+    }
+}
+
+main().catch(e => {
+    console.error(e);
+    process.exit(1);
+});

packages/tools/release-utils-internal/bin/rui-changelog-helper.ts

@@ -1,38 +1,16 @@
 #!/usr/bin/env ts-node-script
 
 import { prompt } from "enquirer";
-import ora from "ora";
-import { bumpPackageJson, bumpXml, getNextVersion } from "../src/bump-version";
-import { getWidgetChangelog } from "../src/changelog-parser";
+import { getModuleInfo, PackageListing, selectPackage } from "../src";
+import { getNextVersion, writeVersion } from "../src/bump-version";
+import {
+    getModuleChangelog,
+    getWidgetChangelog,
+    ModuleChangelogFileWrapper,
+    WidgetChangelogFileWrapper
+} from "../src/changelog-parser";
 import { LogSection } from "../src/changelog-parser/types";
-import { listPackages, PackageListing } from "../src/monorepo";
-
-async function oraPromise<T>(task: Promise<T>, msg: string): Promise<T> {
-    const spinner = ora(msg);
-    spinner.start();
-    const r = await task;
-    spinner.stop();
-    return r;
-}
-
-async function selectPackage(): Promise<PackageListing> {
-    const pkgs = await oraPromise(listPackages(["'*'", "!web-widgets"]), "Loading packages...");
-
-    const { packageName } = await prompt<{ packageName: string }>({
-        type: "autocomplete",
-        name: "packageName",
-        message: "Please select package",
-        choices: pkgs.map(pkg => pkg.name)
-    });
-
-    const pkg = pkgs.find(p => p.name === packageName);
-
-    if (!pkg) {
-        throw new Error(`Unable to find package meta for ${packageName}`);
-    }
-
-    return pkg;
-}
+import { oraPromise } from "../src/cli-utils";
 
 async function getChangelogSections(): Promise<LogSection[]> {
     const sections: LogSection[] = [];
@@ -78,36 +56,40 @@ async function getChangelogSections(): Promise<LogSection[]> {
     return sections;
 }
 
-async function updateVersion(currentVersion: string): Promise<string | undefined> {
+async function selectNextVersion(currentVersion: string): Promise<string | undefined> {
     const { bump } = await prompt<{ bump: boolean }>({
         type: "confirm",
         name: "bump",
         message: "Would you like to bump the package version?"
     });
 
     if (bump) {
-        const nextVersion = await getNextVersion(currentVersion);
-        console.log(`Version change: ${currentVersion} => ${nextVersion}`);
-        return nextVersion;
+        return getNextVersion(currentVersion);
     }
 
     return undefined;
 }
 
 async function writeChanges(pkg: PackageListing, sections: LogSection[], nextVersion?: string): Promise<void> {
-    const changelog = await getWidgetChangelog(pkg.path);
+    let changelog: WidgetChangelogFileWrapper | ModuleChangelogFileWrapper;
+    try {
+        changelog = await getWidgetChangelog(pkg.path);
+    } catch {
+        const module = await getModuleInfo(pkg.path);
+        changelog = await getModuleChangelog(pkg.path, module.mxpackage.name);
+    }
+
     changelog.addUnreleasedSections(sections).save();
 
     if (nextVersion) {
-        bumpPackageJson(pkg.path, nextVersion);
-        await bumpXml(pkg.path, nextVersion);
+        await writeVersion(pkg, nextVersion);
     }
 }
 
 async function main(): Promise<void> {
     const pkg = await selectPackage();
     const sections = await getChangelogSections();
-    const nextVersion = await updateVersion(pkg.version);
+    const nextVersion = await selectNextVersion(pkg.version);
 
     const { save } = await prompt<{ save: boolean }>({
         type: "confirm",

packages/tools/release-utils-internal/package.json

@@ -18,11 +18,13 @@
     "compile:parser:widget": "peggy -o ./src/changelog-parser/parser/module/module.js ./src/changelog-parser/parser/module/module.pegjs",
     "compile:parser:module": "peggy -o ./src/changelog-parser/parser/widget/widget.js ./src/changelog-parser/parser/widget/widget.pegjs",
     "prepare": "pnpm run compile:parser:widget && pnpm run compile:parser:module && tsc",
-    "changelog": "ts-node bin/rui-changelog-helper.ts"
+    "changelog": "ts-node bin/rui-changelog-helper.ts",
+    "version": "ts-node bin/rui-bump-version.ts"
   },
   "devDependencies": {
     "@types/cross-zip": "^4.0.0",
     "@types/node-fetch": "2.6.1",
+    "chalk": "^4.1.2",
     "cross-zip": "^4.0.0",
     "enquirer": "^2.3.6",
     "eslint": "^7.20.0",

packages/tools/release-utils-internal/src/bump-version.ts

@@ -1,33 +1,10 @@
-import { promises as fs } from "fs";
-import { join } from "path";
+import chalk from "chalk";
 import { spawnSync } from "child_process";
 import { prompt } from "enquirer";
-
-export async function selectBumpVersionType(): Promise<BumpVersionType> {
-    const { bumpType } = await prompt<{ bumpType: string }>({
-        type: "autocomplete",
-        name: "bumpType",
-        message: "Want to bump?",
-        choices: ["major", "minor", "patch", "set manually"]
-    });
-
-    if (bumpType === "set manually") {
-        const { nextVersion } = await prompt<{ nextVersion: string }>({
-            type: "input",
-            name: "nextVersion",
-            message: "Set package version to"
-        });
-
-        return nextVersion;
-    } else {
-        return bumpType;
-    }
-}
-
-export async function getNextVersion(currentVersion: string): Promise<string> {
-    const bumpVersionType = await selectBumpVersionType();
-    return getNewVersion(bumpVersionType, currentVersion);
-}
+import { promises as fs } from "fs";
+import { join } from "path";
+import { nextTick } from "process";
+import { PackageListing } from "./monorepo";
 
 export type BumpVersionType = "patch" | "minor" | "major" | string;
 
@@ -64,7 +41,42 @@ export async function bumpXml(path: string, version: string): Promise<boolean> {
     }
 }
 
-export async function updateVersion(path: string, version: string): Promise<void> {
-    bumpPackageJson(path, version);
-    await bumpXml(path, version);
+export async function writeVersion(pkg: PackageListing, version: string): Promise<void> {
+    bumpPackageJson(pkg.path, version);
+    try {
+        await bumpXml(pkg.path, version);
+    } catch {
+        nextTick(() => {
+            const msg = `[WARN] Update version: package ${pkg.name} is missing package.xml, skip`;
+            console.warn(chalk.yellow(msg));
+        });
+    }
+}
+
+export async function selectBumpVersionType(): Promise<BumpVersionType> {
+    const { bumpType } = await prompt<{ bumpType: string }>({
+        type: "autocomplete",
+        name: "bumpType",
+        message: "Want to bump?",
+        choices: ["major", "minor", "patch", "set manually"]
+    });
+
+    if (bumpType === "set manually") {
+        const { nextVersion } = await prompt<{ nextVersion: string }>({
+            type: "input",
+            name: "nextVersion",
+            message: "Set package version to"
+        });
+
+        return nextVersion;
+    } else {
+        return bumpType;
+    }
+}
+
+export async function getNextVersion(currentVersion: string): Promise<string> {
+    const bumpVersionType = await selectBumpVersionType();
+    const nextVersion = getNewVersion(bumpVersionType, currentVersion);
+    console.log(chalk.green(`Version change: ${currentVersion} => ${nextVersion}`));
+    return nextVersion;
 }

packages/tools/release-utils-internal/src/changelog-parser/index.ts

@@ -80,6 +80,28 @@ function formatDate(date: Date): string {
         .padStart(2, "0")}`;
 }
 
+function mergeUnreleased<T extends UnreleasedVersionEntry>(unreleased: T, sections: LogSection[]): T {
+    const currentTypes = unreleased.sections.map(s => s.type);
+    const incomingTypes = sections.map(s => s.type);
+    const uniqueTypes = new Set([...currentTypes, ...incomingTypes]);
+
+    const nextSections = Array.from(uniqueTypes).map(type => {
+        const section = unreleased.sections.find(s => s.type === type) ?? {
+            type,
+            logs: []
+        };
+
+        const incomingLogs = sections.flatMap(s => (s.type === type ? s.logs : []));
+
+        return { type: section.type, logs: [...section.logs, ...incomingLogs] };
+    });
+
+    return {
+        ...unreleased,
+        sections: nextSections
+    };
+}
+
 export class WidgetChangelogFileWrapper {
     changelog: WidgetChangelogFile;
 
@@ -141,31 +163,11 @@ export class WidgetChangelogFileWrapper {
 
     addUnreleasedSections(sections: LogSection[]): WidgetChangelogFileWrapper {
         const [unreleased, ...rest] = this.changelog.content;
-        const currentTypes = unreleased.sections.map(s => s.type);
-        const incomingTypes = sections.map(s => s.type);
-        const uniqueTypes = new Set([...currentTypes, ...incomingTypes]);
-
-        const nextSections = Array.from(uniqueTypes).map(type => {
-            const section = unreleased.sections.find(s => s.type === type) ?? {
-                type,
-                logs: []
-            };
-
-            const incomingLogs = sections.flatMap(s => (s.type === type ? s.logs : []));
-
-            return { type: section.type, logs: [...section.logs, ...incomingLogs] };
-        });
 
         return new WidgetChangelogFileWrapper(
             {
                 header: this.changelog.header,
-                content: [
-                    {
-                        type: "unreleased",
-                        sections: nextSections
-                    },
-                    ...rest
-                ]
+                content: [mergeUnreleased(unreleased, sections), ...rest]
             },
             this.changelogPath
         );
@@ -247,6 +249,19 @@ export class ModuleChangelogFileWrapper {
         );
     }
 
+    addUnreleasedSections(sections: LogSection[]): ModuleChangelogFileWrapper {
+        const [unreleased, ...rest] = this.changelog.content;
+
+        return new ModuleChangelogFileWrapper(
+            {
+                header: this.changelog.header,
+                content: [mergeUnreleased(unreleased, sections), ...rest],
+                moduleName: this.moduleName
+            },
+            this.changelogPath
+        );
+    }
+
     addUnreleasedSubcomponents(subcomponents: SubComponentEntry[]): ModuleChangelogFileWrapper {
         const [unreleased, ...releasedContent] = this.changelog.content;
 

packages/tools/release-utils-internal/src/cli-utils.ts

@@ -0,0 +1,9 @@
+import ora from "ora";
+
+export async function oraPromise<T>(task: Promise<T>, msg: string): Promise<T> {
+    const spinner = ora(msg);
+    spinner.start();
+    const r = await task;
+    spinner.stop();
+    return r;
+}

packages/tools/release-utils-internal/src/monorepo.ts

@@ -1,3 +1,5 @@
+import { prompt } from "enquirer";
+import { oraPromise } from "./cli-utils";
 import { exec, find, mkdir, cp } from "./shell";
 
 type DependencyName = string;
@@ -37,3 +39,22 @@ export async function copyMpkFiles(packageNames: string[], dest: string): Promis
     mkdir("-p", dest);
     cp(paths, dest);
 }
+
+export async function selectPackage(): Promise<PackageListing> {
+    const pkgs = await oraPromise(listPackages(["'*'", "!web-widgets"]), "Loading packages...");
+
+    const { packageName } = await prompt<{ packageName: string }>({
+        type: "autocomplete",
+        name: "packageName",
+        message: "Please select package",
+        choices: pkgs.map(pkg => pkg.name)
+    });
+
+    const pkg = pkgs.find(p => p.name === packageName);
+
+    if (!pkg) {
+        throw new Error(`Unable to find package meta for ${packageName}`);
+    }
+
+    return pkg;
+}