feat: render model without active editor

Author: benfdking

sqlmesh/lsp/context.py

@@ -5,7 +5,7 @@
 
 from sqlmesh.core.model.definition import SqlModel
 from sqlmesh.core.linter.definition import AnnotatedRuleViolation
-from sqlmesh.lsp.custom import RenderModelEntry
+from sqlmesh.lsp.custom import RenderModelEntry, ModelForRendering
 from sqlmesh.lsp.uri import URI
 
 
@@ -148,3 +148,29 @@ def lint_model(self, uri: URI) -> t.List[AnnotatedRuleViolation]:
         # Store in cache
         self._lint_cache[path] = diagnostics
         return diagnostics
+
+    def list_of_models_for_rendering(self) -> t.List[ModelForRendering]:
+        """Get a list of models for rendering.
+
+        Returns:
+            List of ModelForRendering objects.
+        """
+        return [
+            ModelForRendering(
+                name=model.name,
+                fqn=model.fqn,
+                description=model.description,
+                uri=URI.from_path(model._path).value,
+            )
+            for model in self.context.models.values()
+            if isinstance(model, SqlModel) and model._path is not None
+        ] + [
+            ModelForRendering(
+                name=audit.name,
+                fqn=audit.fqn,
+                description=audit.description,
+                uri=URI.from_path(audit._path).value,
+            )
+            for audit in self.context.standalone_audits.values()
+            if audit._path is not None
+        ]

sqlmesh/lsp/custom.py

@@ -46,3 +46,29 @@ class RenderModelResponse(PydanticModel):
     """
 
     models: t.List[RenderModelEntry]
+
+
+ALL_MODELS_FOR_RENDER_FEATURE = "sqlmesh/all_models_for_render"
+
+
+class ModelForRendering(PydanticModel):
+    """
+    A model that is available for rendering.
+    """
+
+    name: str
+    fqn: str
+    description: t.Optional[str] = None
+    uri: str
+
+
+class AllModelsForRenderRequest(PydanticModel):
+    pass
+
+
+class AllModelsForRenderResponse(PydanticModel):
+    """
+    Response to get all the models that are in the current project for rendering purposes.
+    """
+
+    models: t.List[ModelForRendering]

sqlmesh/lsp/main.py

@@ -27,9 +27,12 @@
 )
 from sqlmesh.lsp.custom import (
     ALL_MODELS_FEATURE,
+    ALL_MODELS_FOR_RENDER_FEATURE,
     RENDER_MODEL_FEATURE,
     AllModelsRequest,
     AllModelsResponse,
+    AllModelsForRenderRequest,
+    AllModelsForRenderResponse,
     RenderModelRequest,
     RenderModelResponse,
 )
@@ -117,6 +120,17 @@ def render_model(ls: LanguageServer, params: RenderModelRequest) -> RenderModelR
             context = self._context_get_or_load(uri)
             return RenderModelResponse(models=context.render_model(uri))
 
+        @self.server.feature(ALL_MODELS_FOR_RENDER_FEATURE)
+        def all_models_for_render(
+            ls: LanguageServer, params: AllModelsForRenderRequest
+        ) -> AllModelsForRenderResponse:
+            if self.lsp_context is None:
+                current_path = Path.cwd()
+                self._ensure_context_in_folder(current_path)
+            if self.lsp_context is None:
+                raise RuntimeError("No context found")
+            return AllModelsForRenderResponse(models=self.lsp_context.list_of_models_for_rendering())
+
         @self.server.feature(API_FEATURE)
         def api(ls: LanguageServer, request: ApiRequest) -> t.Dict[str, t.Any]:
             ls.log_trace(f"API request: {request}")

vscode/extension/src/commands/renderModel.ts

@@ -9,21 +9,60 @@ export function renderModel(
   renderedModelProvider?: RenderedModelProvider,
 ) {
   return async () => {
+    if (!lspClient) {
+      vscode.window.showErrorMessage('LSP client not available')
+      return
+    }
+
     // Get the current active editor
     const activeEditor = vscode.window.activeTextEditor
 
+    let documentUri: string
+
     if (!activeEditor) {
-      vscode.window.showErrorMessage('No active editor found')
-      return
-    }
+      // No active editor, show a list of all models
+      const allModelsResult = await lspClient.call_custom_method(
+        'sqlmesh/all_models_for_render',
+        {},
+      )
 
-    if (!lspClient) {
-      vscode.window.showErrorMessage('LSP client not available')
-      return
-    }
+      if (isErr(allModelsResult)) {
+        vscode.window.showErrorMessage(
+          `Failed to get models: ${allModelsResult.error}`,
+        )
+        return
+      }
+
+      if (
+        !allModelsResult.value.models ||
+        allModelsResult.value.models.length === 0
+      ) {
+        vscode.window.showInformationMessage('No models found in the project')
+        return
+      }
 
-    // Get the current document URI
-    const documentUri = activeEditor.document.uri.toString(true)
+      // Let user choose from all models
+      const items = allModelsResult.value.models.map(model => ({
+        label: model.name,
+        description: model.fqn,
+        detail: model.description ? model.description : undefined,
+        model: model,
+      }))
+
+      const selected = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select a model to render',
+      })
+
+      if (!selected) {
+        return
+      }
+
+      // Use the selected model's URI
+      documentUri = selected.model.uri
+    } else {
+      // Get the current document URI
+      documentUri = activeEditor.document.uri.toString(true)
+    }
 
     // Call the render model API
     const result = await lspClient.call_custom_method('sqlmesh/render_model', {

vscode/extension/src/lsp/custom.ts

@@ -30,6 +30,7 @@ export type CustomLSPMethods =
   | AllModelsMethod
   | AbstractAPICall
   | RenderModelMethod
+  | AllModelsForRenderMethod
 
 interface AllModelsRequest {
   textDocument: {
@@ -54,3 +55,23 @@ export interface AbstractAPICall {
   request: AbstractAPICallRequest
   response: object
 }
+
+export interface AllModelsForRenderMethod {
+  method: 'sqlmesh/all_models_for_render'
+  request: AllModelsForRenderRequest
+  response: AllModelsForRenderResponse
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface AllModelsForRenderRequest {}
+
+interface AllModelsForRenderResponse {
+  models: ModelForRendering[]
+}
+
+export interface ModelForRendering {
+  name: string
+  fqn: string
+  description: string | null | undefined
+  uri: string
+}

vscode/extension/tests/render.spec.ts

@@ -153,3 +153,44 @@ test('Render works correctly with every rendered model opening a new tab', async
     await fs.remove(tempDir)
   }
 })
+
+test('Render shows model picker when no active editor is open', async () => {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-'))
+  await fs.copy(SUSHI_SOURCE_PATH, tempDir)
+
+  try {
+    const { window, close } = await startVSCode(tempDir)
+
+    // Load the lineage view to initialize SQLMesh context (like lineage.spec.ts does)
+    await window.keyboard.press(
+      process.platform === 'darwin' ? 'Meta+Shift+P' : 'Control+Shift+P',
+    )
+    await window.keyboard.type('Lineage: Focus On View')
+    await window.keyboard.press('Enter')
+
+    // Wait for "Loaded SQLmesh Context" text to appear
+    const loadedContextText = window.locator('text=Loaded SQLMesh Context')
+    await expect(loadedContextText.first()).toBeVisible({ timeout: 10_000 })
+
+    // Run the render command without any active editor
+    await window.keyboard.press(
+      process.platform === 'darwin' ? 'Meta+Shift+P' : 'Control+Shift+P',
+    )
+    await window.keyboard.type('Render Model')
+    await window.keyboard.press('Enter')
+
+    // Type to filter for customers model and select it
+    await window.keyboard.type('customers')
+    await window.waitForSelector('text=sushi.customers', { timeout: 5000 })
+    await window.locator('text=sushi.customers').click()
+
+    // Verify the rendered model is shown
+    await expect(window.locator('text=sushi.customers (rendered)')).toBeVisible(
+      { timeout: 15000 },
+    )
+
+    await close()
+  } finally {
+    await fs.remove(tempDir)
+  }
+})