Merge pull request #97 from senkenn/senkenn/issue73

Restart SQL Language Server

Author: senkenn

.vscode/settings.json

@@ -25,10 +25,7 @@
     "./sql-extraction/rs/Cargo.toml",
     "./vsce-test/test-workspace-rs/Cargo.toml"
   ],
-  "github-actions.workflows.pinned.workflows": [
-    ".github/workflows/e2e-test.yaml",
-    ".github/workflows/rust-test.yaml"
-  ],
+  "github-actions.workflows.pinned.workflows": [".github/workflows/test.yaml"],
   "github-actions.workflows.pinned.refresh.interval": 3,
   "github-actions.workflows.pinned.refresh.enabled": true,
   "markdown.copyFiles.destination": {

vsce-test/test/suite-ts/extension.test.ts

@@ -34,6 +34,33 @@ describe("Install sqls if not found in PATH", () => {
   });
 });
 
+describe("Restart Language Server Test", () => {
+  test("Should restart SQL language server", async () => {
+    await vscode.commands.executeCommand("sqlsurge.restartSqlLanguageServer");
+
+    // confirm completion
+    const filePath = path.resolve(wsPath, "src", "index.ts");
+    const docUri = vscode.Uri.file(filePath);
+    const doc = await vscode.workspace.openTextDocument(docUri);
+
+    // Wait for server activation
+    await sleep(waitingTimeCompletion);
+
+    const pos = new vscode.Position(5, 44);
+    const actualCompletionList =
+      await vscode.commands.executeCommand<vscode.CompletionList>(
+        "vscode.executeCompletionItemProvider",
+        docUri,
+        pos,
+      );
+
+    expect(actualCompletionList.items.length).toBe(1);
+    const { label, kind } = actualCompletionList.items[0];
+    expect(label).toBe("SELECT");
+    expect(kind).toBe(vscode.CompletionItemKind.Keyword);
+  });
+});
+
 describe("Completion Test", () => {
   test('Should be completed "SELECT" with $queryRaw single line', async () => {
     const filePath = path.resolve(wsPath, "src", "index.ts");

vsce/README.md

@@ -102,6 +102,14 @@ const someQuery = await entityManager.query(
 }
 ```
 
+## VS Code Commands <!-- omit in toc -->
+
+- `sqlsurge: Install sqls`: Install sqls.
+- `sqlsurge: Restart SQL Language Server`: Restart SQL Language Server.
+  - This command is useful when you update sqls or change the configuration.
+- `sqlsurge: Format SQL`: Format Raw SQL query.
+- `Format Document`: Format SQL file with sqls.
+
 ## TODOs <!-- omit in toc -->
 
 - [x] Support for Prisma in TypeScript

vsce/package.json

@@ -117,6 +117,10 @@
         "command": "sqlsurge.installSqls",
         "title": "sqlsurge: Install sqls"
       },
+      {
+        "command": "sqlsurge.restartSqlLanguageServer",
+        "title": "sqlsurge: Restart SQL Language Server"
+      },
       {
         "command": "sqlsurge.formatSql",
         "title": "sqlsurge: Format SQL"

vsce/src/commands/installSqls.ts

@@ -47,11 +47,11 @@ export const command = vscode.commands.registerCommand(
       .createOutputChannel("sqlsurge")
       .appendLine("sqls is installed.");
     const actions = await vscode.window.showInformationMessage(
-      "sqls was successfully installed! Reload window to enable SQL language features.",
-      "Reload Window",
+      "sqls was successfully installed! Restart language server to enable SQL language features.",
+      "Restart Language Server",
     );
-    if (actions === "Reload Window") {
-      vscode.commands.executeCommand("workbench.action.reloadWindow");
+    if (actions === "Restart Language Server") {
+      vscode.commands.executeCommand("sqlsurge.restartSqlLanguageServer");
     }
   },
 );

vsce/src/commands/restartLS.ts

@@ -0,0 +1,9 @@
+import * as vscode from "vscode";
+import { restartLanguageServer } from "../startSqlsClient";
+
+export const command = vscode.commands.registerCommand(
+  "sqlsurge.restartSqlLanguageServer",
+  async () => {
+    await restartLanguageServer();
+  },
+);

vsce/src/completion.ts

@@ -17,7 +17,7 @@ export async function completionProvider(
     ) {
       const logger = createLogger();
 
-      logger.info("[provideCompletionItems]", "Starting completion...");
+      logger.debug("[provideCompletionItems]", "Starting completion...");
       logger.debug("[provideCompletionItems]", "file: ", document.fileName);
       const sqlNodes = await refresh(document);
       const sqlNode = sqlNodes.find(({ code_range: { start, end } }) => {
@@ -47,7 +47,7 @@ export async function completionProvider(
       const vDocUriString = `${ORIGINAL_SCHEME}:${sqlNode.vFileName}`;
       const vDocUri = vscode.Uri.parse(vDocUriString);
 
-      logger.info("[provideCompletionItems] Finished completion.");
+      logger.debug("[provideCompletionItems] Finished completion.");
       return vscode.commands.executeCommand<vscode.CompletionList>(
         "vscode.executeCompletionItemProvider",
         vDocUri,

vsce/src/extension.ts

@@ -7,6 +7,7 @@ import * as vscode from "vscode";
 
 import { commandFormatSqlProvider } from "./commands/formatSql";
 import { command as commandInstallSqls } from "./commands/installSqls";
+import { command as commandRestartLS } from "./commands/restartLS";
 import { completionProvider } from "./completion";
 import { getWorkspaceConfig } from "./extConfig";
 import {
@@ -20,7 +21,7 @@ import { client, startSqlsClient } from "./startSqlsClient";
 export async function activate(context: vscode.ExtensionContext) {
   const logger = createLogger();
 
-  startSqlsClient().catch((err) => {
+  await startSqlsClient().catch((err) => {
     logger.error(err, "[startSqlsClient] Failed to start sqls client.");
     vscode.window.showErrorMessage("sqlsurge: Failed to start sqls client.");
   });
@@ -48,6 +49,7 @@ export async function activate(context: vscode.ExtensionContext) {
     completion,
     commandInstallSqls,
     commandFormatSql,
+    commandRestartLS,
   );
 
   // on save event
@@ -111,7 +113,7 @@ export async function activate(context: vscode.ExtensionContext) {
   async function refresh(
     document: vscode.TextDocument,
   ): Promise<(SqlNode & { vFileName: string })[]> {
-    logger.info("[refresh]", "Refreshing...");
+    logger.debug("[refresh]", "Refreshing...");
     try {
       const service = getOrCreateLanguageService(document.uri)!;
       const fileName = document.fileName;
@@ -169,7 +171,7 @@ export async function activate(context: vscode.ExtensionContext) {
           index: idx,
         };
       });
-      logger.info("[refresh]", "Refreshed.");
+      logger.debug("[refresh]", "Refreshed.");
       return sqlNodesWithVirtualDoc;
     } catch (e) {
       logger.error("[refresh]", `${e}`);

vsce/src/startSqlsClient.ts

@@ -4,59 +4,29 @@ import {
   LanguageClient,
   type LanguageClientOptions,
   type ServerOptions,
+  State,
 } from "vscode-languageclient/node";
 import { createLogger } from "./outputChannel";
 
 interface LanguageServerConfig {
   flags: string[];
 }
 
-export let client: LanguageClient;
+export let client: LanguageClient | undefined = undefined;
 
-export async function startSqlsClient() {
-  const logger = createLogger();
+const logger = createLogger();
 
-  logger.info("[startSqlsClient]", "Starting sqls client...");
+export async function startSqlsClient() {
+  logger.debug("[startSqlsClient]", "Starting sqls client...");
   const sqlsConfig = vscode.workspace.getConfiguration("sqlsurge");
   const config: LanguageServerConfig = {
     flags: sqlsConfig.languageServerFlags || [],
   };
 
-  let sqlsInPATH = await findSqlsInPath();
+  const sqlsInPATH = await findSqlsInPath();
   if (!sqlsInPATH) {
-    // not found sqls, install sqls automatically
-    const action = await vscode.window.showInformationMessage(
-      "sqls is not installed yet. You need to install sqls to enable SQL language features.",
-      "Install with command",
-      "Install manually (Jump to the installation guide)",
-    );
-    switch (action) {
-      case "Install with command":
-        await vscode.commands.executeCommand("sqlsurge.installSqls");
-        break;
-      case "Install manually (Jump to the installation guide)":
-        await vscode.commands.executeCommand(
-          "vscode.open",
-          vscode.Uri.parse(
-            "https://github.com/sqls-server/sqls?tab=readme-ov-file#installation",
-          ),
-        );
-        vscode.window
-          .createOutputChannel("sqlsurge")
-          .appendLine("sqls is not installed.");
-        return;
-      default:
-        vscode.window
-          .createOutputChannel("sqlsurge")
-          .appendLine("sqls is not installed.");
-        return;
-    }
-
-    // check again
-    sqlsInPATH = await findSqlsInPath();
-    if (!sqlsInPATH) {
-      throw new Error("sqls should be installed but not found in PATH");
-    }
+    showSqlsNotFoundMessage();
+    return;
   }
 
   const serverOptions: ServerOptions = {
@@ -74,6 +44,37 @@ export async function startSqlsClient() {
   logger.info("[startSqlsClient]", "Started sqls client.");
 }
 
+export async function restartLanguageServer() {
+  logger.debug("[restartLanguageServer]", "Restarting SQL language server...");
+  if (!client) {
+    await startSqlsClient();
+    return;
+  }
+
+  const sqlsInPATH = await findSqlsInPath();
+  if (!sqlsInPATH) {
+    showSqlsNotFoundMessage();
+    return;
+  }
+
+  if (client.state === State.Stopped) {
+    await client.start();
+    logger.debug("[restartLanguageServer]", "Started SQL language server.");
+  }
+  if (client.state === State.Running) {
+    await client.restart();
+    logger.debug("[restartLanguageServer]", "Restarted SQL language server.");
+  }
+
+  vscode.window.showInformationMessage(
+    "Successfully restarted SQL language server.",
+  );
+  logger.info(
+    "[restartLanguageServer]",
+    "Successfully restarted SQL language server.",
+  );
+}
+
 export async function findSqlsInPath(): Promise<vscode.Uri | undefined> {
   const path = process.env.PATH;
   if (!path) {
@@ -83,22 +84,49 @@ export async function findSqlsInPath(): Promise<vscode.Uri | undefined> {
   const sqlsFileName = process.platform === "win32" ? "sqls.exe" : "sqls";
   for (const dir of path.split(delimiter)) {
     const sqls = vscode.Uri.joinPath(vscode.Uri.file(dir), sqlsFileName);
-    if (await fileExists(sqls)) {
+    if (await existsFile(sqls)) {
       return sqls;
     }
   }
 
   return;
 }
 
-async function fileExists(path: vscode.Uri) {
-  try {
-    await vscode.workspace.fs.stat(path);
-    return true;
-  } catch (err: any) {
-    if (err.code === "ENOENT" || err.code === "FileNotFound") {
-      return false;
-    }
-    throw err;
+async function existsFile(path: vscode.Uri) {
+  return vscode.workspace.fs.stat(path).then(
+    () => true,
+    (err) => {
+      logger.debug("[existsFile]", err);
+      if (err.code === "ENOENT" || err.code === "FileNotFound") {
+        return false;
+      }
+      throw err;
+    },
+  );
+}
+
+async function showSqlsNotFoundMessage() {
+  // not found sqls, install sqls automatically
+  const action = await vscode.window.showInformationMessage(
+    "sqls is not installed yet or not found in PATH. Install sqls to enable SQL language features.",
+    "Install with command",
+    "Install manually (Jump to the installation guide)",
+  );
+  switch (action) {
+    case "Install with command":
+      await vscode.commands.executeCommand("sqlsurge.installSqls");
+      break;
+    case "Install manually (Jump to the installation guide)":
+      await vscode.commands.executeCommand(
+        "vscode.open",
+        vscode.Uri.parse(
+          "https://github.com/sqls-server/sqls?tab=readme-ov-file#installation",
+        ),
+      );
+      logger.info("[startSqlsClient]", "sqls is not installed.");
+      return;
+    default:
+      logger.info("[startSqlsClient]", "sqls is not installed.");
+      return;
   }
 }