feat(vscode): better errors for missing sqlmesh_lsp (#4288)

Author: benfdking

vscode/extension/eslint.config.mjs

@@ -16,6 +16,7 @@ export default tseslint.config(
   },
   {
     rules: {
+      'no-fallthrough': 'error',
       '@typescript-eslint/switch-exhaustiveness-check': 'error',
       '@typescript-eslint/no-unsafe-assignment': 'off',
       '@typescript-eslint/no-explicit-any': 'off',

vscode/extension/src/commands/format.ts

@@ -3,22 +3,35 @@ import { execSync } from 'child_process'
 import { sqlmesh_exec } from '../utilities/sqlmesh/sqlmesh'
 import { err, isErr, ok, Result } from '../utilities/functional/result'
 import * as vscode from 'vscode'
-import { ErrorType, handleNotSginedInError } from '../utilities/errors'
+import {
+  ErrorType,
+  handleNotSginedInError,
+  handleSqlmeshLspNotFoundError,
+  handleSqlmeshLspDependenciesMissingError,
+} from '../utilities/errors'
 import { AuthenticationProviderTobikoCloud } from '../auth/auth'
 
 export const format =
-  (authProvider: AuthenticationProviderTobikoCloud) => async () => {
+  (authProvider: AuthenticationProviderTobikoCloud) =>
+  async (): Promise<void> => {
     traceLog('Calling format')
     const out = await internalFormat()
     if (isErr(out)) {
-      if (out.error.type === 'not_signed_in') {
-        await handleNotSginedInError(authProvider)
-        return
-      } else {
-        vscode.window.showErrorMessage(
-          `Project format failed: ${out.error.message}`,
-        )
-        return
+      switch (out.error.type) {
+        case 'not_signed_in':
+          await handleNotSginedInError(authProvider)
+          return
+        case 'sqlmesh_lsp_not_found':
+          await handleSqlmeshLspNotFoundError()
+          return
+        case 'sqlmesh_lsp_dependencies_missing':
+          await handleSqlmeshLspDependenciesMissingError(out.error)
+          return
+        case 'generic':
+          await vscode.window.showErrorMessage(
+            `Project format failed: ${out.error.message}`,
+          )
+          return
       }
     }
     vscode.window.showInformationMessage('Project formatted successfully')

vscode/extension/src/extension.ts

@@ -13,7 +13,11 @@ import { signOut } from './commands/signout'
 import { signIn } from './commands/signin'
 import { signInSpecifyFlow } from './commands/signinSpecifyFlow'
 import { isErr } from './utilities/functional/result'
-import { handleNotSginedInError } from './utilities/errors'
+import {
+  handleNotSginedInError,
+  handleSqlmeshLspNotFoundError,
+  handleSqlmeshLspDependenciesMissingError,
+} from './utilities/errors'
 
 let lspClient: LSPClient | undefined
 
@@ -58,17 +62,49 @@ export async function activate(context: vscode.ExtensionContext) {
   lspClient = new LSPClient()
   const result = await lspClient.start()
   if (isErr(result)) {
-    await handleNotSginedInError(authProvider)
+    switch (result.error.type) {
+      case 'not_signed_in':
+        await handleNotSginedInError(authProvider)
+        break
+      case 'sqlmesh_lsp_not_found':
+        await handleSqlmeshLspNotFoundError()
+        break
+      case 'sqlmesh_lsp_dependencies_missing':
+        await handleSqlmeshLspDependenciesMissingError(result.error)
+        break
+      case 'generic':
+        await vscode.window.showErrorMessage(
+          `Failed to start LSP: ${result.error.message}`,
+        )
+        break
+    }
+  } else {
+    context.subscriptions.push(lspClient)
   }
-  context.subscriptions.push(lspClient)
 
   const restart = async () => {
     if (lspClient) {
       traceVerbose('Restarting LSP client')
       const restartResult = await lspClient.restart()
       if (isErr(restartResult)) {
-        await handleNotSginedInError(authProvider)
+        switch (restartResult.error.type) {
+          case 'not_signed_in':
+            await handleNotSginedInError(authProvider)
+            return
+          case 'sqlmesh_lsp_not_found':
+            await handleSqlmeshLspNotFoundError()
+            return
+          case 'sqlmesh_lsp_dependencies_missing':
+            await handleSqlmeshLspDependenciesMissingError(restartResult.error)
+            return
+          case 'generic':
+            await vscode.window.showErrorMessage(
+              `Failed to restart LSP: ${restartResult.error.message}`,
+            )
+            return
+        }
       }
+      context.subscriptions.push(lspClient)
     }
   }
 

vscode/extension/src/utilities/errors.ts

@@ -9,6 +9,16 @@ import { traceInfo } from './common/log'
 export type ErrorType =
   | { type: 'generic'; message: string }
   | { type: 'not_signed_in' }
+  | { type: 'sqlmesh_lsp_not_found' }
+  // sqlmesh_lsp_dependencies_missing is used when the sqlmesh_lsp is found but the lsp extras are missing.
+  | SqlmeshLspDependenciesMissingError
+
+interface SqlmeshLspDependenciesMissingError {
+  type: 'sqlmesh_lsp_dependencies_missing'
+  is_missing_pygls: boolean
+  is_missing_lsprotocol: boolean
+  is_tobiko_cloud: boolean
+}
 
 /**
  * Handles the case where the user is not signed in to Tobiko Cloud.
@@ -26,3 +36,40 @@ export const handleNotSginedInError = async (
     await signIn(authProvider)()
   }
 }
+
+/**
+ * Handles the case where the sqlmesh_lsp is not found.
+ */
+export const handleSqlmeshLspNotFoundError = async (): Promise<void> => {
+  traceInfo('handleSqlmeshLspNotFoundError')
+  await window.showErrorMessage(
+    'SQLMesh LSP not found, please check installation',
+  )
+}
+
+/**
+ * Handles the case where the sqlmesh_lsp is found but the lsp extras are missing.
+ */
+export const handleSqlmeshLspDependenciesMissingError = async (
+  error: SqlmeshLspDependenciesMissingError,
+): Promise<void> => {
+  traceInfo('handleSqlmeshLspDependenciesMissingError')
+  if (error.is_tobiko_cloud) {
+    await window.showErrorMessage(
+      'LSP dependencies missing, make sure to include `lsp` in the `extras` section of your `tcloud.yaml` file.',
+    )
+  } else {
+    const install = await window.showErrorMessage(
+      'LSP dependencies missing, make sure to install `sqlmesh[lsp]`.',
+      'Install',
+    )
+    if (install === 'Install') {
+      const terminal = window.createTerminal({
+        name: 'SQLMesh LSP Install',
+        hideFromUser: false,
+      })
+      terminal.show()
+      terminal.sendText("pip install 'sqlmesh[lsp]'", false)
+    }
+  }
+}

vscode/extension/src/utilities/sqlmesh/sqlmesh.ts

@@ -231,6 +231,46 @@ export const sqlmesh_exec = async (): Promise<
   }
 }
 
+/**
+ * Ensure that the sqlmesh_lsp dependencies are installed.
+ *
+ * @returns A Result indicating whether the sqlmesh_lsp dependencies were installed.
+ */
+export const ensureSqlmeshLspDependenciesInstalled = async (): Promise<
+  Result<undefined, ErrorType>
+> => {
+  const isPyglsInstalled = await isPythonModuleInstalled('pygls')
+  if (isErr(isPyglsInstalled)) {
+    return err({
+      type: 'generic',
+      message: isPyglsInstalled.error,
+    })
+  }
+  const isLsprotocolInstalled = await isPythonModuleInstalled('lsprotocol')
+  if (isErr(isLsprotocolInstalled)) {
+    return err({
+      type: 'generic',
+      message: isLsprotocolInstalled.error,
+    })
+  }
+  const isTobikoCloudInstalled = await isTcloudProject()
+  if (isErr(isTobikoCloudInstalled)) {
+    return err({
+      type: 'generic',
+      message: isTobikoCloudInstalled.error,
+    })
+  }
+  if (!isPyglsInstalled.value || !isLsprotocolInstalled.value) {
+    return err({
+      type: 'sqlmesh_lsp_dependencies_missing',
+      is_missing_pygls: !isPyglsInstalled.value,
+      is_missing_lsprotocol: !isLsprotocolInstalled.value,
+      is_tobiko_cloud: isTobikoCloudInstalled.value,
+    })
+  }
+  return ok(undefined)
+}
+
 /**
  * Get the sqlmesh_lsp executable for the current workspace.
  *
@@ -282,8 +322,17 @@ export const sqlmesh_lsp_exec = async (): Promise<
         })
       }
     }
+    const ensuredDependencies = await ensureSqlmeshLspDependenciesInstalled()
+    if (isErr(ensuredDependencies)) {
+      return ensuredDependencies
+    }
     const binPath = path.join(interpreterDetails.binPath!, 'sqlmesh_lsp')
     traceLog(`Bin path: ${binPath}`)
+    if (!fs.existsSync(binPath)) {
+      return err({
+        type: 'sqlmesh_lsp_not_found',
+      })
+    }
     return ok({
       bin: binPath,
       workspacePath,