refactor(vscode): centralise error handlers

Author: benfdking

vscode/extension/src/commands/format.ts

@@ -2,13 +2,7 @@ import { traceLog } from '../utilities/common/log'
 import { sqlmeshExec } from '../utilities/sqlmesh/sqlmesh'
 import { err, isErr, ok, Result } from '@bus/result'
 import * as vscode from 'vscode'
-import {
-  ErrorType,
-  handleNotSginedInError,
-  handleSqlmeshLspNotFoundError,
-  handleSqlmeshLspDependenciesMissingError,
-  handleTcloudBinNotFoundError,
-} from '../utilities/errors'
+import { ErrorType, handleError } from '../utilities/errors'
 import { AuthenticationProviderTobikoCloud } from '../auth/auth'
 import { execAsync } from '../utilities/exec'
 
@@ -18,25 +12,7 @@ export const format =
     traceLog('Calling format')
     const out = await internalFormat()
     if (isErr(out)) {
-      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 'tcloud_bin_not_found':
-          await handleTcloudBinNotFoundError()
-          return
-        case 'generic':
-          await vscode.window.showErrorMessage(
-            `Project format failed: ${out.error.message}`,
-          )
-          return
-      }
+      return handleError(authProvider, out.error, 'Project format failed')
     }
     vscode.window.showInformationMessage('Project formatted successfully')
   }

vscode/extension/src/extension.ts

@@ -14,12 +14,7 @@ import { signIn } from './commands/signin'
 import { signInSpecifyFlow } from './commands/signinSpecifyFlow'
 import { renderModel, reRenderModelForSourceFile } from './commands/renderModel'
 import { isErr } from '@bus/result'
-import {
-  handleNotSginedInError,
-  handleSqlmeshLspNotFoundError,
-  handleSqlmeshLspDependenciesMissingError,
-  handleTcloudBinNotFoundError,
-} from './utilities/errors'
+import { handleError } from './utilities/errors'
 import { selector, completionProvider } from './completion/completion'
 import { LineagePanel } from './webviews/lineagePanel'
 import { RenderedModelProvider } from './providers/renderedModelProvider'
@@ -117,25 +112,11 @@ export async function activate(context: vscode.ExtensionContext) {
       traceVerbose('Restarting LSP client')
       const restartResult = await lspClient.restart()
       if (isErr(restartResult)) {
-        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 'tcloud_bin_not_found':
-            await handleTcloudBinNotFoundError()
-            return
-          case 'generic':
-            await vscode.window.showErrorMessage(
-              `Failed to restart LSP: ${restartResult.error.message}`,
-            )
-            return
-        }
+        return handleError(
+          authProvider,
+          restartResult.error,
+          'LSP restart failed',
+        )
       }
       context.subscriptions.push(lspClient)
     }
@@ -155,25 +136,7 @@ export async function activate(context: vscode.ExtensionContext) {
 
   const result = await lspClient.start()
   if (isErr(result)) {
-    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 'tcloud_bin_not_found':
-        await handleTcloudBinNotFoundError()
-        break
-      case 'generic':
-        await vscode.window.showErrorMessage(
-          `Failed to start LSP: ${result.error.message}`,
-        )
-        break
-    }
+    return handleError(authProvider, result.error, 'Failed to start LSP')
   } else {
     context.subscriptions.push(lspClient)
   }

vscode/extension/src/utilities/errors.ts

@@ -13,21 +13,49 @@ export type ErrorType =
   // tcloud_bin_not_found is used when the tcloud executable is not found. This is likely to happen if the user
   // opens a project that has a `tcloud.yaml` file but doesn't have tcloud installed.
   | { type: 'tcloud_bin_not_found' }
-  // sqlmesh_lsp_dependencies_missing is used when the sqlmesh_lsp is found but the lsp extras are missing.
   | SqlmeshLspDependenciesMissingError
 
+/**
+ * SqlmeshLspDependenciesMissingError is used when the sqlmesh_lsp is found but
+ * the lsp extras are missing.
+ */
 interface SqlmeshLspDependenciesMissingError {
   type: 'sqlmesh_lsp_dependencies_missing'
   is_missing_pygls: boolean
   is_missing_lsprotocol: boolean
   is_tobiko_cloud: boolean
 }
 
+export async function handleError(
+  authProvider: AuthenticationProviderTobikoCloud,
+  error: ErrorType,
+  genericErrorPrefix?: string,
+): Promise<void> {
+  traceInfo('handleError', error)
+  switch (error.type) {
+    case 'not_signed_in':
+      return handleNotSignedInError(authProvider)
+    case 'sqlmesh_lsp_not_found':
+      return handleSqlmeshLspNotFoundError()
+    case 'sqlmesh_lsp_dependencies_missing':
+      return handleSqlmeshLspDependenciesMissingError(error)
+    case 'tcloud_bin_not_found':
+      return handleTcloudBinNotFoundError()
+    case 'generic':
+      if (genericErrorPrefix) {
+        await window.showErrorMessage(`${genericErrorPrefix}: ${error.message}`)
+      } else {
+        await window.showErrorMessage(`An error occurred: ${error.message}`)
+      }
+      return
+  }
+}
+
 /**
  * Handles the case where the user is not signed in to Tobiko Cloud.
  * @param authProvider - The authentication provider to use for signing in.
  */
-export const handleNotSginedInError = async (
+const handleNotSignedInError = async (
   authProvider: AuthenticationProviderTobikoCloud,
 ): Promise<void> => {
   traceInfo('handleNotSginedInError')
@@ -43,7 +71,7 @@ export const handleNotSginedInError = async (
 /**
  * Handles the case where the sqlmesh_lsp is not found.
  */
-export const handleSqlmeshLspNotFoundError = async (): Promise<void> => {
+const handleSqlmeshLspNotFoundError = async (): Promise<void> => {
   traceInfo('handleSqlmeshLspNotFoundError')
   await window.showErrorMessage(
     'SQLMesh LSP not found, please check installation',
@@ -53,7 +81,7 @@ export const handleSqlmeshLspNotFoundError = async (): Promise<void> => {
 /**
  * Handles the case where the sqlmesh_lsp is found but the lsp extras are missing.
  */
-export const handleSqlmeshLspDependenciesMissingError = async (
+const handleSqlmeshLspDependenciesMissingError = async (
   error: SqlmeshLspDependenciesMissingError,
 ): Promise<void> => {
   traceInfo('handleSqlmeshLspDependenciesMissingError')
@@ -80,7 +108,7 @@ export const handleSqlmeshLspDependenciesMissingError = async (
 /**
  * Handles the case where the tcloud executable is not found.
  */
-export const handleTcloudBinNotFoundError = async (): Promise<void> => {
+const handleTcloudBinNotFoundError = async (): Promise<void> => {
   const result = await window.showErrorMessage(
     'tcloud executable not found, please check installation',
     'Install',