feat: version update messages (#35)

Author: juleswritescode

package-lock.json

@@ -2,7 +2,7 @@
   "name": "postgrestools",
   "publisher": "Supabase",
   "description": "Postgres Language Server right in your IDE.",
-  "version": "1.1.7",
+  "version": "1.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/supabase-community/postgrestools-vscode"
@@ -71,6 +71,12 @@
           "default": false,
           "scope": "resource"
         },
+        "postgrestools.allowVersionChecks": {
+          "type": "boolean",
+          "description": "If set, the extension will check periodically whether a new version for PostgresTools is available and if so notify the user.",
+          "default": true,
+          "scope": "resource"
+        },
         "postgrestools.configFile": {
           "type": "string",
           "description": "Path to the `postgrestools.jsonc` file. You don't need to set this if the file is on root level of your project.",

package.json

@@ -5,7 +5,7 @@ import { CONSTANTS } from "./constants";
 import { fileExists } from "./utils";
 import { createRequire } from "node:module";
 import { getConfig } from "./config";
-import { downloadPglt, getDownloadedVersion } from "./downloader";
+import { downloadPglt, getDownloadedBinary } from "./downloader";
 
 export interface BinaryFindStrategy {
   name: string;
@@ -280,14 +280,14 @@ export const downloadPgltStrategy: BinaryFindStrategy = {
   async find() {
     logger.debug(`Trying to find downloaded PostgresTools binary`);
 
-    const downloadedVersion = await getDownloadedVersion();
+    const downloadedBinary = await getDownloadedBinary();
 
-    if (downloadedVersion) {
+    if (downloadedBinary) {
       logger.info(
-        `Using previously downloaded version ${downloadedVersion.version} at ${downloadedVersion.binPath.fsPath}`
+        `Using previously downloaded version ${downloadedBinary.version} at ${downloadedBinary.binPath.fsPath}`
       );
 
-      return downloadedVersion.binPath;
+      return downloadedBinary.binPath;
     }
 
     const proceed =

src/binary-finder-strategies.ts

@@ -1,4 +1,4 @@
-import { RelativePattern, Uri, workspace } from "vscode";
+import { Uri } from "vscode";
 import {
   BinaryFindStrategy,
   downloadPgltStrategy,
@@ -10,41 +10,47 @@ import {
 import { logger } from "./logger";
 
 type Strategy = {
+  label: string;
   strategy: BinaryFindStrategy;
   onSuccess: (u: Uri) => void;
   condition?: (path?: Uri) => Promise<boolean>;
 };
 
 const LOCAL_STRATEGIES: Strategy[] = [
   {
+    label: "VSCode Settings",
     strategy: vsCodeSettingsStrategy,
     onSuccess: (uri) =>
       logger.debug(`Found Binary in VSCode Settings (postgrestools.bin)`, {
         path: uri.fsPath,
       }),
   },
   {
+    label: "NPM node_modules",
     strategy: nodeModulesStrategy,
     onSuccess: (uri) =>
       logger.debug(`Found Binary in Node Modules`, {
         path: uri.fsPath,
       }),
   },
   {
+    label: "Yarn Plug'n'Play node_modules",
     strategy: yarnPnpStrategy,
     onSuccess: (uri) =>
       logger.debug(`Found Binary in Yarn PnP`, {
         path: uri.fsPath,
       }),
   },
   {
+    label: "PATH Environment Variable",
     strategy: pathEnvironmentVariableStrategy,
     onSuccess: (uri) =>
       logger.debug(`Found Binary in PATH Environment Variable`, {
         path: uri.fsPath,
       }),
   },
   {
+    label: "Downloaded Binary",
     strategy: downloadPgltStrategy,
     onSuccess: (uri) =>
       logger.debug(`Found downloaded binary`, {
@@ -65,7 +71,7 @@ export class BinaryFinder {
   }
 
   private static async attemptFind(strategies: Strategy[], path: Uri) {
-    for (const { strategy, onSuccess, condition } of strategies) {
+    for (const { strategy, onSuccess, condition, label } of strategies) {
       if (condition && !(await condition(path))) {
         continue;
       }
@@ -74,7 +80,7 @@ export class BinaryFinder {
         const binary = await strategy.find(path);
         if (binary) {
           onSuccess(binary);
-          return { bin: binary };
+          return { bin: binary, label };
         } else {
           logger.info(`Binary not found with strategy`, {
             strategy: strategy.name,

src/binary-finder.ts

@@ -1,9 +1,14 @@
 import { window } from "vscode";
-import { downloadPglt, getDownloadedVersion } from "./downloader";
+import { downloadPglt, getDownloadedBinary } from "./downloader";
 import { restart, start, stop } from "./lifecycle";
 import { logger } from "./logger";
 import { state } from "./state";
-import { clearGlobalBinaries, clearTemporaryBinaries } from "./utils";
+import {
+  clearGlobalBinaries,
+  clearTemporaryBinaries,
+  getVersion,
+} from "./utils";
+import { Releases } from "./releases";
 
 /**
  * These commands are exposed to the user via the Command Palette.
@@ -37,20 +42,36 @@ export class UserFacingCommands {
     await stop();
     await clearTemporaryBinaries();
     await clearGlobalBinaries();
-    await state.context.globalState.update("downloadedVersion", undefined);
+
+    await Releases.refresh();
+
+    await state.context.globalState.update("lastNotifiedOfUpdate", undefined);
+
     state.activeSession = undefined;
     state.activeProject = undefined;
     logger.info("PostgresTools extension was reset");
+
     await start();
   }
 
   static async currentVersion() {
-    const result = await getDownloadedVersion();
-    if (!result) {
+    const session = state.activeSession;
+
+    if (!session) {
+      window.showInformationMessage("No PostgresTools version installed.");
+      return;
+    }
+
+    const version = await getVersion(session.bin);
+
+    if (!version) {
       window.showInformationMessage("No PostgresTools version installed.");
     } else {
       window.showInformationMessage(
-        `Currently installed PostgresTools version is ${result.version}.`
+        `Currently installed PostgresTools version is ${version}.`
+      );
+      window.showInformationMessage(
+        `Using binary from "${session.binaryStrategyLabel}".`
       );
     }
   }

src/commands.ts

@@ -8,10 +8,8 @@ import {
 import { logger } from "./logger";
 import { state } from "./state";
 import { CONSTANTS } from "./constants";
-import { fileExists } from "./utils";
-import { getConfig } from "./config";
+import { fileExists, getVersion } from "./utils";
 import { chmodSync } from "fs";
-import { getAllReleases } from "./releases";
 
 export async function downloadPglt(): Promise<Uri | null> {
   logger.debug(`Downloading PostgresTools`);
@@ -31,7 +29,7 @@ export async function downloadPglt(): Promise<Uri | null> {
     () => downloadPgltVersion(versionToDownload.label)
   );
 
-  const downloaded = await getDownloadedVersion();
+  const downloaded = await getDownloadedBinary();
 
   return downloaded?.binPath ?? null;
 }
@@ -67,47 +65,41 @@ async function downloadPgltVersion(version: string): Promise<void> {
     const successMsg = `Downloaded PostgresTools ${version} to ${binPath.fsPath}`;
     logger.info(successMsg);
     window.showInformationMessage(successMsg);
-    state.context.globalState.update("downloadedVersion", version);
   } catch (error) {
     logger.error(`Failed to save downloaded binary`, { error });
     window.showErrorMessage(`Failed to save binary.\n\n${error}`);
     return;
   }
 }
 
-export async function getDownloadedVersion(): Promise<{
+export async function getDownloadedBinary(): Promise<{
   version: string;
   binPath: Uri;
 } | null> {
   logger.debug(`Getting downloaded version`);
 
-  const version = state.context.globalState.get<string>("downloadedVersion");
-  if (!version) {
-    logger.debug(`No downloaded version stored in global state context.`);
-    return null;
-  }
+  const bin = getInstalledBinaryPath();
 
-  const binPath = getInstalledBinaryPath();
+  if (await fileExists(bin)) {
+    const version = await getVersion(bin);
+    if (!version) {
+      throw new Error("Just verified file exists, but it doesn't anymore.");
+    }
 
-  if (await fileExists(binPath)) {
     logger.debug(`Found downloaded version and binary`, {
-      path: binPath.fsPath,
+      path: bin.fsPath,
       version,
     });
 
     return {
-      binPath,
+      binPath: bin,
       version,
     };
   }
 
-  logger.info(
-    `Downloaded version found in global state context, but binary does not exist.`,
-    {
-      binPath,
-      version,
-    }
-  );
+  logger.info(`Downloaded binary does not exist.`, {
+    binPath: bin,
+  });
 
   return null;
 }
@@ -117,23 +109,16 @@ async function promptVersionToDownload() {
 
   const itemsPromise: Promise<QuickPickItem[]> = new Promise(
     async (resolve) => {
-      const downloadedVersion = await getDownloadedVersion()
+      const downloadedBinary = await getDownloadedBinary()
         .then((it) => it?.version)
         .catch(() => undefined);
 
-      logger.debug(`Retrieved downloaded version`, { downloadedVersion });
-
-      const withPrereleases =
-        getConfig<boolean>("allowDownloadPrereleases") ?? false;
-
-      const availableVersions = await getAllReleases({
-        withPrereleases,
-      }).catch(() => []);
-
-      logger.debug(`Found ${availableVersions.length} downloadable versions`, {
-        withPrereleases,
+      logger.debug(`Retrieved downloaded version`, {
+        downloadedVersion: downloadedBinary,
       });
 
+      const availableVersions = state.releases.all();
+
       const items: QuickPickItem[] = availableVersions.map((release, index) => {
         const descriptions = [];
 
@@ -145,13 +130,13 @@ async function promptVersionToDownload() {
           descriptions.push("prerelease");
         }
 
+        if (downloadedBinary === release.tag_name) {
+          descriptions.push("(currently installed)");
+        }
+
         return {
           label: release.tag_name,
           description: descriptions.join(", "),
-          detail:
-            downloadedVersion === release.tag_name
-              ? "(currently installed)"
-              : "",
           alwaysShow: index < 3,
         };
       });

src/downloader.ts

@@ -1,4 +1,5 @@
 import { logger } from "./logger";
+import { Releases } from "./releases";
 import { createActiveSession, destroySession } from "./session";
 import { state } from "./state";
 
@@ -37,6 +38,7 @@ export const restart = async () => {
 
 const doStart = async () => {
   try {
+    state.releases = await Releases.load();
     await createActiveSession();
   } catch (e: unknown) {
     if (e instanceof Error) {