feat(promotionProvider): fetch dependency check metadata from remote

Author: FluoriteCafe-work

src/extension.ts

@@ -26,6 +26,7 @@ import { promotionProvider } from "./promotionProvider";
 
 export async function activate(context: ExtensionContext): Promise<void> {
     contextManager.initialize(context);
+    promotionProvider.initialize(context);
     await initializeFromJsonFile(context.asAbsolutePath("./package.json"));
     await initExpService(context);
     await instrumentOperation("activation", activateExtension)(context);

src/promotionProvider.ts

@@ -7,34 +7,37 @@ import {
     Diagnostic,
     Range,
     DiagnosticSeverity,
-    Uri
+    Uri,
+    type ExtensionContext
 } from "vscode";
 import * as semver from "semver";
 import type { INodeData } from "../extension.bundle";
+import { fetchDependencyCheckMetadata, type DependencyCheckMetadata } from "./utils/requestUtils";
 
 const EARLIEST_JAVA_VERSION_NOT_TO_PROMPT = 21;
 const JAVA_UPGRADE_EXTENSION_ID = "vscjava.vscode-java-upgrade";
-const PACKAGES_TO_CHECK_FOR_EOL: Record<string, { name: string, supportedVersion: string }> = {
-    // https://spring.io/projects/spring-boot#support
-    "org.springframework.boot": {
-        name: "Spring Boot",
-        supportedVersion: "2.7.x || >=3.2.x"
-    },
-    // https://spring.io/projects/spring-framework#support
-    "org.springframework": {
-        name: "Spring Framework",
-        supportedVersion: "5.3.x || >=6.2.x"
-    },
-};
+const METADATA_UPDATE_INTERVAL_IN_DAYS = 7;
+const METADATA_STORAGE_KEY = "dependencyCheckMetadata";
 
+type MementoItem<T> = {
+    lastUpdatedTs: number;
+    data: T;
+}
 
 export class PromotionProvider implements Disposable {
     public static getInstance() {
         return promotionProvider;
     }
 
+    private context: ExtensionContext;
     private haveAlreadyPrompted = false;
-    private diagnostics = languages.createDiagnosticCollection('javaUpgrade')
+    private diagnostics = languages.createDiagnosticCollection('javaUpgrade');
+    private dependencyCheckMetadata: DependencyCheckMetadata = {};
+
+    public initialize(context: ExtensionContext) {
+        this.context = context;
+        this.refreshDependencyCheckMetadata();
+    }
 
     public dispose() {
         this.diagnostics.dispose();
@@ -61,7 +64,7 @@ export class PromotionProvider implements Disposable {
     public checkDependencyVersion(data: INodeData) {
         const versionString = data.metaData?.["maven.version"];
         const groupId = data.metaData?.["maven.groupId"];
-        const supportedVersionDefinition = PACKAGES_TO_CHECK_FOR_EOL[groupId];
+        const supportedVersionDefinition = this.dependencyCheckMetadata[groupId];
         if (!versionString || !groupId || !supportedVersionDefinition) {
             return;
         }
@@ -70,7 +73,23 @@ export class PromotionProvider implements Disposable {
             return;
         }
         if (!semver.satisfies(currentVersion, supportedVersionDefinition.supportedVersion)) {
-            this.triggerFrameworkVersionUpgrade(groupId, versionString);
+            this.triggerFrameworkVersionUpgrade(supportedVersionDefinition.name, versionString);
+        }
+    }
+
+    private async refreshDependencyCheckMetadata(): Promise<void> {
+        const metadata = this.context.globalState.get(METADATA_STORAGE_KEY) as MementoItem<DependencyCheckMetadata> | undefined;
+        const nowTs = Number(new Date()) / 1000;
+        if (!metadata || (nowTs - (metadata?.lastUpdatedTs ?? 0)) > METADATA_UPDATE_INTERVAL_IN_DAYS * 24 * 60 * 60) {
+            const newMetadata = await fetchDependencyCheckMetadata();
+            this.context.globalState.update(METADATA_STORAGE_KEY, {
+                lastUpdatedTs: nowTs,
+                data: newMetadata
+            });
+            this.dependencyCheckMetadata = newMetadata;
+            return;
+        } else {
+            this.dependencyCheckMetadata = metadata.data ?? {};
         }
     }
 
@@ -84,10 +103,9 @@ export class PromotionProvider implements Disposable {
         }
     }
 
-    private triggerFrameworkVersionUpgrade(groupId: string, currentVersion: string) {
+    private triggerFrameworkVersionUpgrade(frameworkName: string, currentVersion: string) {
         if (!this.haveAlreadyPrompted) {
             this.haveAlreadyPrompted = true;
-            const frameworkName = PACKAGES_TO_CHECK_FOR_EOL[groupId].name;
             this.promptForUpgrade(`Your project's ${frameworkName} version (${currentVersion}) has reached end-of-life. Consider upgrading using Java Upgrade Tool for better security and performance.`,
                 `Upgrade ${frameworkName} to a supported version with Java Upgrade Tool`)
         }

src/utils/requestUtils.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import type { IncomingMessage } from "http";
+import * as https from "https";
+
+// TODO: change
+const URL_DEPENDENCY_CHECK_METADATA = "https://gist.githubusercontent.com/FluoriteCafe-work/6126d5d93fe4e35c25c431d98bb9ff7e/raw/c01f7db84044a41e30b6c88fd9ee3cb4841d9e4d/data.json";
+
+export type DependencyCheckMetadata = Record<string, { name: string, supportedVersion: string }>
+
+export async function fetchDependencyCheckMetadata(): Promise<DependencyCheckMetadata> {
+    const raw = await httpsGet(URL_DEPENDENCY_CHECK_METADATA);
+    try {
+        return JSON.parse(raw);
+    } catch (error) {
+        console.error(error);
+        return {};
+    }
+}
+
+// TODO: switch to `fetch()` when we are confident users are using Node 18+
+async function httpsGet(urlString: string): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+        let result = "";
+        https.get(urlString, {
+            headers: {
+                'User-Agent': 'vscode-java-dependency/0.1',
+            }
+        }, (res: IncomingMessage) => {
+            res.on("data", chunk => {
+                result = result.concat(chunk.toString());
+            });
+            res.on("end", () => {
+                resolve(result);
+            });
+            res.on("error", err => {
+                reject(err);
+            });
+        });
+    });
+}