feat(vscode): before running commands check if signed in

- when someone runs a command that requires a user to be signed in
rather than fail, this nudges a user to sign in before hand

Author: benfdking

vscode/extension/eslint.config.mjs

@@ -20,9 +20,9 @@ export default [{
             format: ["camelCase", "PascalCase"],
         }],
 
-        curly: "warn",
-        eqeqeq: "warn",
-        "no-throw-literal": "warn",
+        curly: "error",
+        eqeqeq: "error",
+        "no-throw-literal": "error",
         semi: ["error", "never"]
     },
 }];

vscode/extension/src/auth/auth.ts

@@ -332,3 +332,18 @@ export class AuthenticationProviderTobikoCloud
     }
   }
 }
+
+/**
+ * Checks if the user is currently signed into Tobiko Cloud.
+ * @returns A promise that resolves to true if the user is signed in, false otherwise.
+ */
+export async function isSignedIntoTobikoCloud(): Promise<boolean> {
+  try {
+    const authProvider = new AuthenticationProviderTobikoCloud()
+    const sessions = await authProvider.getSessions()
+    return sessions.length > 0
+  } catch (error) {
+    traceError(`Error checking authentication status: ${error}`)
+    return false
+  }
+}

vscode/extension/src/commands/format.ts

@@ -1,36 +1,41 @@
-import { traceError, traceLog } from "../utilities/common/log"
+import { traceLog } from "../utilities/common/log"
 import { execSync } from "child_process"
 import { sqlmesh_exec } from "../utilities/sqlmesh/sqlmesh"
-import { isErr } from "../utilities/functional/result"
+import { err, isErr, ok, Result } from "../utilities/functional/result"
 import * as vscode from "vscode"
+import { ErrorType, handleNotSginedInError } from "../utilities/errors"
+import { AuthenticationProviderTobikoCloud } from "../auth/auth"
 
-export const format = async () => {
+export const format = (authProvider: AuthenticationProviderTobikoCloud) => async () => {
   traceLog("Calling format")
   const out = await internalFormat()
-  if (out === 0) {
-    vscode.window.showInformationMessage("Project formatted successfully")
-  } else {
-    vscode.window.showErrorMessage("Project format failed")
+  if (isErr(out)) {
+    if (out.error.type === "not_signed_in") {
+      handleNotSginedInError(authProvider)
+    } else {
+      vscode.window.showErrorMessage(
+        `Project format failed: ${out.error.message}`
+      )
+    }
   }
 }
 
-const internalFormat = async (): Promise<number> => {
+const internalFormat = async (): Promise<Result<number, ErrorType>> => {
   try {
     const exec = await sqlmesh_exec()
     if (isErr(exec)) {
-      traceError(exec.error)
-      return 1
+      return exec
     }
     execSync(`${exec.value.bin} format`, {
       encoding: "utf-8",
       cwd: exec.value.workspacePath,
       env: exec.value.env,
     })
-    return 0
+    return ok(0)
   } catch (error: any) {
-    traceError("Error executing sqlmesh format:", error.message)
-    traceError(error.stdout)
-    traceError(error.stderr)
-    return error.status || 1
+    return err({
+      type: "generic",
+      message: `Error executing sqlmesh format: ${error.message}`,
+    })
   }
 }

vscode/extension/src/extension.ts

@@ -1,5 +1,5 @@
-import * as vscode from "vscode"
 import { format } from "./commands/format"
+import * as vscode from "vscode"
 import {
   createOutputChannel,
   onDidChangeConfiguration,
@@ -16,6 +16,8 @@ import { AuthenticationProviderTobikoCloud } from "./auth/auth"
 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"
 
 let lspClient: LSPClient | undefined
 
@@ -44,7 +46,6 @@ export async function activate(context: vscode.ExtensionContext) {
   context.subscriptions.push(
     vscode.commands.registerCommand("sqlmesh.signin", signIn(authProvider))
   )
-
   context.subscriptions.push(
     vscode.commands.registerCommand(
       "sqlmesh.signinSpecifyFlow",
@@ -55,19 +56,26 @@ export async function activate(context: vscode.ExtensionContext) {
     vscode.commands.registerCommand("sqlmesh.signout", signOut(authProvider))
   )
   context.subscriptions.push(
-    vscode.commands.registerCommand("sqlmesh.format", format)
+    vscode.commands.registerCommand("sqlmesh.format", format(authProvider))
   )
 
   lspClient = new LSPClient()
-  await lspClient.start()
+  const result = await lspClient.start()
+  if (isErr(result)) {
+    handleNotSginedInError(authProvider)
+  }
   context.subscriptions.push(lspClient)
 
   const restart = async () => {
     if (lspClient) {
       traceVerbose("Restarting LSP client")
-      await lspClient.restart()
+      const result = await lspClient.restart()
+      if (isErr(result)) {
+        handleNotSginedInError(authProvider)
+      }
     }
   }
+
   context.subscriptions.push(
     onDidChangePythonInterpreter(async () => {
       await restart()

vscode/extension/src/lsp/lsp.ts

@@ -4,6 +4,7 @@ import { sqlmesh_lsp_exec } from "../utilities/sqlmesh/sqlmesh"
 import { err, isErr, ok, Result } from "../utilities/functional/result"
 import { getWorkspaceFolders } from "../utilities/common/vscodeapi"
 import { traceError } from "../utilities/common/log"
+import { ErrorType } from "../utilities/errors"
 
 let outputChannel: OutputChannel | undefined
 
@@ -14,20 +15,23 @@ export class LSPClient implements Disposable {
         this.client = undefined
     }
 
-    public async start(): Promise<Result<undefined, string>> {
+    public async start(): Promise<Result<undefined, ErrorType>> {
         if (!outputChannel) {
             outputChannel = window.createOutputChannel('sqlmesh-lsp')
         }
 
         const sqlmesh = await sqlmesh_lsp_exec()
         if (isErr(sqlmesh)) {
             traceError(`Failed to get sqlmesh_lsp_exec: ${sqlmesh.error}`)
-            return sqlmesh
+            return sqlmesh 
         }
         const workspaceFolders = getWorkspaceFolders()
         if (workspaceFolders.length !== 1) {
             traceError(`Invalid number of workspace folders: ${workspaceFolders.length}`)
-            return err("Invalid number of workspace folders")
+            return err({
+                type: "generic",
+                message: "Invalid number of workspace folders",
+            })
         }
 
         let folder = workspaceFolders[0]
@@ -67,9 +71,9 @@ export class LSPClient implements Disposable {
         return ok(undefined)
     }
 
-    public async restart() {
+    public async restart(): Promise<Result<undefined, ErrorType>> {
         await this.stop()
-        await this.start()
+        return await this.start()
     }
 
     public async stop() {

vscode/extension/src/utilities/errors.ts

@@ -0,0 +1,28 @@
+import { window } from "vscode"
+import { AuthenticationProviderTobikoCloud } from "../auth/auth"
+import { signIn } from "../commands/signin"
+import { traceInfo } from "./common/log"
+
+/**
+ * Represents different types of errors that can occur in the application.
+ */
+export type ErrorType =
+  | { type: "generic"; message: string }
+  | { type: "not_signed_in" };
+
+/**
+ * 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 (
+  authProvider: AuthenticationProviderTobikoCloud
+): Promise<void> => {
+  traceInfo("handleNotSginedInError")
+  const result = await window.showInformationMessage(
+    "Please sign in to Tobiko Cloud to use SQLMesh",
+    "Sign In"
+  )
+  if (result === "Sign In") {
+    await signIn(authProvider)()
+  }
+}

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

@@ -7,6 +7,8 @@ import { execFile } from "child_process"
 import { promisify } from "util"
 import { isPythonModuleInstalled } from "../python"
 import fs from "fs"
+import { ErrorType } from "../errors"
+import { isSignedIntoTobikoCloud } from "../../auth/auth"
 
 export type sqlmesh_exec = {
   workspacePath: string;
@@ -51,7 +53,7 @@ export const get_tcloud_bin = async (): Promise<Result<string, string>> => {
  *
  * @returns The sqlmesh executable for the current workspace.
  */
-export const sqlmesh_exec = async (): Promise<Result<sqlmesh_exec, string>> => {
+export const sqlmesh_exec = async (): Promise<Result<sqlmesh_exec, ErrorType>> => {
   const projectRoot = await getProjectRoot()
   const workspacePath = projectRoot.uri.fsPath
   const interpreterDetails = await getInterpreterDetails()
@@ -67,12 +69,24 @@ export const sqlmesh_exec = async (): Promise<Result<sqlmesh_exec, string>> => {
     traceLog("Using virtual environment")
     const tcloudInstalled = await isTcloudProject()
     if (isErr(tcloudInstalled)) {
-      return tcloudInstalled
+      return err({
+        type: "generic",
+        message: tcloudInstalled.error,
+      }) 
     }
     if (tcloudInstalled.value) {
       const tcloudBin = await get_tcloud_bin()
       if (isErr(tcloudBin)) {
-        return tcloudBin
+        return err({
+          type: "generic",
+          message: tcloudBin.error,
+        })
+      }
+      const isSignedIn = await isSignedIntoTobikoCloud()
+      if (!isSignedIn) {
+        return err({
+          type: "not_signed_in",
+        })
       }
       return ok({
         bin: `${tcloudBin.value} sqlmesh`,
@@ -113,7 +127,7 @@ export const sqlmesh_exec = async (): Promise<Result<sqlmesh_exec, string>> => {
  * @returns The sqlmesh_lsp executable for the current workspace.
  */
 export const sqlmesh_lsp_exec = async (): Promise<
-  Result<sqlmesh_exec, string>
+  Result<sqlmesh_exec, ErrorType>
 > => {
   const projectRoot = await getProjectRoot()
   const workspacePath = projectRoot.uri.fsPath
@@ -130,13 +144,25 @@ export const sqlmesh_lsp_exec = async (): Promise<
     traceLog("Using virtual environment")
     const tcloudInstalled = await isTcloudProject()
     if (isErr(tcloudInstalled)) {
-      return tcloudInstalled
+      return err({
+        type: "generic",
+        message: tcloudInstalled.error,
+      })
     }
     if (tcloudInstalled.value) {
       traceLog("Tcloud installed, installing sqlmesh")
       const tcloudBin = await get_tcloud_bin()
       if (isErr(tcloudBin)) {
-        return tcloudBin
+        return err({
+          type: "generic",
+          message: tcloudBin.error,
+        })
+      }
+      const isSignedIn = await isSignedIntoTobikoCloud()
+      if (!isSignedIn) {
+        return err({
+          type: "not_signed_in",
+        })
       }
       const execFileAsync = promisify(execFile)
       await execFileAsync(tcloudBin.value, ["install_sqlmesh"], {