Support RLC Changelog Generation Based on Inline Usage

tools/js-sdk-release-tools/package.json

@@ -3,7 +3,7 @@
   "version": "2.7.11",
   "description": "",
   "scripts": {
-    "dev": "nodemon src/changelogToolCli.ts",
+    "dev": "tsx watch src/changelogToolCli.ts",
     "start": "node dist/changelogToolCli.js",
     "debug": "node --inspect-brk dist/changelogToolCli.js",
     "build": "rimraf dist && tsc -p .",
@@ -32,16 +32,15 @@
     "semver": "^7.3.5",
     "shelljs": "^0.8.4",
     "simple-git": "^3.5.0",
-    "ts-morph": "^12.0.0",
-    "tslib": "^1.9.3",
+    "ts-morph": "^23.0.0",
+    "typescript-codegen-breaking-change-detector": "^0.4.4",
     "yaml": "^1.10.2"
   },
   "devDependencies": {
     "@types/node": "^20.12.12",
     "@types/shelljs": "^0.8.15",
-    "nodemon": "^3.1.0",
     "rimraf": "^3.0.2",
-    "ts-node": "^10.9.2",
+    "tsx": "^4.16.3",
     "typescript": "^5.4.5",
     "vitest": "^1.6.0"
   }

tools/js-sdk-release-tools/src/changelog/RestLevelClientChangelogPostProcessor.ts

@@ -0,0 +1,122 @@
+import { InlineDeclarationNameSetMessage, NodeContext } from 'typescript-codegen-breaking-change-detector';
+import { Changelog, ChangelogItem } from './changelogGenerator';
+
+export class RestLevelClientChangelogPostProcessor {
+  private changelog: Changelog;
+  private message: InlineDeclarationNameSetMessage;
+  constructor(changelog: Changelog, message: InlineDeclarationNameSetMessage) {
+    this.changelog = changelog;
+    this.message = message;
+  }
+
+  public run() {
+    this.handleChangelogItems(this.changelog.addedOperationGroup);
+    this.handleChangelogItems(this.changelog.removedOperationGroup);
+    this.handleChangelogItems(this.changelog.addedOperation);
+    this.handleChangelogItems(this.changelog.addedInterface);
+    this.handleChangelogItems(this.changelog.addedClass);
+    this.handleChangelogItems(this.changelog.addedTypeAlias);
+    this.handleChangelogItems(this.changelog.interfaceAddOptionalParam);
+    this.handleChangelogItems(this.changelog.interfaceParamTypeExtended);
+    this.handleChangelogItems(this.changelog.typeAliasAddInherit);
+    this.handleChangelogItems(this.changelog.typeAliasAddParam);
+    this.handleChangelogItems(this.changelog.addedEnum);
+    this.handleChangelogItems(this.changelog.addedEnumValue);
+    this.handleChangelogItems(this.changelog.addedFunction);
+    this.handleChangelogItems(this.changelog.removedOperation);
+    this.handleChangelogItems(this.changelog.operationSignatureChange);
+    this.handleChangelogItems(this.changelog.deletedClass);
+    this.handleChangelogItems(this.changelog.classSignatureChange);
+    this.handleChangelogItems(this.changelog.interfaceParamDelete);
+    this.handleChangelogItems(this.changelog.interfaceParamAddRequired);
+    this.handleChangelogItems(this.changelog.interfaceParamTypeChanged);
+    this.handleChangelogItems(this.changelog.interfaceParamChangeRequired);
+    this.handleChangelogItems(this.changelog.classParamDelete);
+    this.handleChangelogItems(this.changelog.classParamChangeRequired);
+    this.handleChangelogItems(this.changelog.typeAliasDeleteInherit);
+    this.handleChangelogItems(this.changelog.typeAliasParamDelete);
+    this.handleChangelogItems(this.changelog.typeAliasAddRequiredParam);
+    this.handleChangelogItems(this.changelog.typeAliasParamChangeRequired);
+    this.handleChangelogItems(this.changelog.removedEnum);
+    this.handleChangelogItems(this.changelog.removedEnumValue);
+    this.handleChangelogItems(this.changelog.removedFunction);
+  }
+
+  private getCurrentNodeContext(name: string | undefined): NodeContext | undefined {
+    if (!name) return undefined;
+    return this.message.current.get(name);
+  }
+
+  private getBaselineNodeContext(name: string | undefined): NodeContext | undefined {
+    if (!name) return undefined;
+    return this.message.baseline.get(name);
+  }
+
+  private findCompatibleNodeContext(
+    inputContext: NodeContext,
+    contextMapToFind: Map<string, NodeContext>,
+    checkAssignableFromInputToFound: boolean
+  ): NodeContext | undefined {
+    for (const [_, foundContext] of contextMapToFind) {
+      const isCompatible = checkAssignableFromInputToFound
+        ? inputContext.node.getType().isAssignableTo(foundContext.node.getType())
+        : foundContext.node.getType().isAssignableTo(inputContext.node.getType());
+      if (isCompatible) return foundContext;
+    }
+    return undefined;
+  }
+
+  private tryIgnoreInlineTypeInChangelogItem(
+    inputContext: NodeContext,
+    nodeContextMapToFind: Map<string, NodeContext>,
+    checkAssignableFromInputToFound: boolean,
+    item: ChangelogItem
+  ) {
+    if (!inputContext) return;
+    const foundContext = this.findCompatibleNodeContext(
+      inputContext,
+      nodeContextMapToFind,
+      checkAssignableFromInputToFound
+    );
+    if (foundContext) {
+      inputContext.used = true;
+      foundContext.used = true;
+      item.toDelete = true;
+    }
+    return;
+  }
+
+  private handleChangelogItems(items: ChangelogItem[]) {
+    items.forEach((item) => {
+      if (!item.oldName && !item.newName) return;
+
+      if (item.newName && item.oldName) {
+        const currentContext = this.getCurrentNodeContext(item.newName);
+        if (!currentContext) return;
+        const baselineContext = this.getBaselineNodeContext(item.oldName);
+        if (!baselineContext) return;
+        const currentType = currentContext.node.getType();
+        const baselineType = baselineContext.node.getType();
+        if (currentType.isAssignableTo(baselineType)) {
+          item.toDelete = true;
+          currentContext.used = true;
+          baselineContext.used = true;
+        }
+        return;
+      }
+
+      if (item.newName) {
+        const inputContext = this.getCurrentNodeContext(item.newName);
+        if (!inputContext) return;
+        this.tryIgnoreInlineTypeInChangelogItem(inputContext, this.message.baseline, true, item);
+        return;
+      }
+
+      // item.baselineName exists
+      const inputContext = this.getBaselineNodeContext(item.oldName);
+      if (!inputContext) return;
+      this.tryIgnoreInlineTypeInChangelogItem(inputContext, this.message.current, false, item);
+      return;
+    });
+  }
+}