temp [ci skip]

Author: benfdking

examples/sushi/models/marketing.sql

@@ -2,6 +2,7 @@ MODEL (
   name sushi.marketing,
   kind SCD_TYPE_2(unique_key customer_id),
   owner jen,
+  owners test,
   cron '@daily',
   grain customer_id,
   description 'Sushi marketing data'

sqlmesh/core/loader.py

@@ -364,7 +364,7 @@ def _load(path: Path) -> t.List[Model]:
                             self._failed_to_load_model_error(
                                 path, f"Duplicate external model name: '{model.name}'."
                             ),
-                            path
+                            path,
                         )
                     models[model.fqn] = model
 
@@ -404,13 +404,15 @@ def _load_requirements(self) -> t.Tuple[t.Dict[str, str], t.Set[str]]:
                     args = [k.strip() for k in line.split("==")]
                     if len(args) != 2:
                         raise ConfigError(
-                            f"Invalid lock file entry '{line.strip()}'. Only 'dep==ver' is supported", requirements_path
+                            f"Invalid lock file entry '{line.strip()}'. Only 'dep==ver' is supported",
+                            requirements_path,
                         )
                     dep, ver = args
                     other_ver = requirements.get(dep, ver)
                     if ver != other_ver:
                         raise ConfigError(
-                            f"Conflicting requirement {dep}: {ver} != {other_ver}. Fix your {c.REQUIREMENTS} file.", requirements_path
+                            f"Conflicting requirement {dep}: {ver} != {other_ver}. Fix your {c.REQUIREMENTS} file.",
+                            requirements_path,
                         )
                     requirements[dep] = ver
 
@@ -622,7 +624,7 @@ def _load_sql_models(
                                     self._failed_to_load_model_error(
                                         path, f"Duplicate SQL model name: '{model.name}'."
                                     ),
-                                    path
+                                    path,
                                 )
                             elif model.enabled:
                                 model._path = path
@@ -785,7 +787,9 @@ def _load_metrics(self) -> UniqueKeyDict[str, MetricMeta]:
                         metric = load_metric_ddl(expression, path=path, dialect=dialect)
                         metrics[metric.name] = metric
                 except SqlglotError as ex:
-                    raise ConfigError(f"Failed to parse metric definitions at '{path}': {ex}.", path)
+                    raise ConfigError(
+                        f"Failed to parse metric definitions at '{path}': {ex}.", path
+                    )
 
         return metrics
 

sqlmesh/core/model/common.py

@@ -13,7 +13,13 @@
 from sqlmesh.core import dialect as d
 from sqlmesh.core.macros import MacroRegistry, MacroStrTemplate
 from sqlmesh.utils import str_to_bool
-from sqlmesh.utils.errors import ConfigError, SQLMeshError, raise_config_error
+from sqlmesh.utils.errors import (
+    ConfigError,
+    SQLMeshError,
+    raise_config_error,
+    ModelBlockFieldValidationMissingFieldsError,
+    ModeBlockExtraFields,
+)
 from sqlmesh.utils.metaprogramming import (
     Executable,
     SqlValue,
@@ -269,34 +275,28 @@ def validate_extra_and_required_fields(
 ) -> None:
     missing_required_fields = klass.missing_required_fields(provided_fields)
     if missing_required_fields:
-        field_names = "'" + "', '".join(missing_required_fields) + "'"
-        raise_config_error(
-            f"Please add required field{'s' if len(missing_required_fields) > 1 else ''} {field_names} to the {entity_name}."
-        )
+        if path is None:
+            raise_config_error(
+        raise ModelBlockFieldValidationMissingFieldsError(path, missing_required_fields)
 
     extra_fields = klass.extra_fields(provided_fields)
     if extra_fields:
         extra_field_names = "'" + "', '".join(extra_fields) + "'"
 
         all_fields = klass.all_fields()
-        close_matches = {}
+        extra_with_close_match: t.Dict[str, t.Optional[str]] = {}
         for field in extra_fields:
             matches = get_close_matches(field, all_fields, n=1)
             if matches:
-                close_matches[field] = matches[0]
-
-        if len(close_matches) == 1:
-            similar_msg = ". Did you mean " + "'" + "', '".join(close_matches.values()) + "'?"
-        else:
-            similar = [
-                f"- {field}: Did you mean '{match}'?" for field, match in close_matches.items()
-            ]
-            similar_msg = "\n\n  " + "\n  ".join(similar) if similar else ""
-
-        raise_config_error(
-            f"Invalid field name{'s' if len(extra_fields) > 1 else ''} present in the {entity_name}: {extra_field_names}{similar_msg}",
-            path,
-        )
+                extra_with_close_match[field] = matches[0]
+            else:
+                extra_with_close_match[field] = None
+
+        if extra_with_close_match:
+            raise ModeBlockExtraFields(
+                path,
+                extra_fields=extra_with_close_match,
+            )
 
 
 def single_value_or_tuple(values: t.Sequence) -> exp.Identifier | exp.Tuple:

sqlmesh/core/model/kind.py

@@ -1015,8 +1015,8 @@ def create_model_kind(v: t.Any, dialect: str, defaults: t.Dict[str, t.Any]) -> M
                     "The 'materialization' property is required for models of the CUSTOM kind"
                 )
 
-            # The below call will print a warning if a materialization with the given name doesn't exist
-            # we dont want to throw an error here because we still want Models with a CustomKind to be able
+            # The below call prints a warning if no materialization with the given name doesn't exist.
+            # We don't throw an error here because we still want Models with a CustomKind to be able
             # to be serialized / deserialized in contexts where the custom materialization class may not be available,
             # such as in HTTP request handlers
             custom_materialization = get_custom_materialization_type(

sqlmesh/lsp/errors.py

@@ -0,0 +1,34 @@
+from lsprotocol.types import Diagnostic
+from sqlmesh.utils.errors import ConfigError, ModeBlockExtraFields, ModelBlockFieldValidationMissingFieldsError
+import typing as t
+
+type ContextFailedError = str | ConfigError | ModeBlockExtraFields | ModelBlockFieldValidationMissingFieldsError
+
+def contextErrorToDiagnostic(error: Exception,) -> t.Tuple[t.Optional[t.Tuple[str, Diagnostic]], ContextFailedError]:
+    if isinstance(error, ModelBlockFieldValidationMissingFieldsError):
+        return missingErrorToDiagnostic(error), error
+    if isinstance(error, ModeBlockExtraFields)
+        return extraFieldsErrorToDiagnostic(error), error
+    if isinstance(error, ConfigError):
+        return configErrorToDiagnostic(error), error
+    return None, str(error)
+
+
+def missingErrorToDiagnostic(
+        error: ModelBlockFieldValidationMissingFieldsError,
+) ->t.Optional[t.Tuple[str, Diagnostic]]:
+    raise NotImplementedError()
+
+def extraFieldsErrorToDiagnostic(
+        error: ModeBlockExtraFields,
+) -> t.Optional[t.Tuple[str, Diagnostic]]:
+    raise NotImplementedError()
+
+def configErrorToDiagnostic(
+        error: ConfigError,
+) ->t.Optional[t.Tuple[str, Diagnostic]]:
+    return Diagnostic(
+
+    )
+    raise NotImplementedError()
+

sqlmesh/lsp/main.py

@@ -46,6 +46,7 @@
     FormatProjectResponse,
     CustomMethod,
 )
+from sqlmesh.lsp.errors import ContextFailedError, contextErrorToDiagnostic
 from sqlmesh.lsp.hints import get_hints
 from sqlmesh.lsp.reference import (
     LSPCteReference,
@@ -56,7 +57,7 @@
 )
 from sqlmesh.lsp.rename import prepare_rename, rename_symbol, get_document_highlights
 from sqlmesh.lsp.uri import URI
-from sqlmesh.utils.errors import ConfigError
+from sqlmesh.utils.errors import ConfigError, ModelBlockFieldValidationMissingFieldsError, ModeBlockExtraFields
 from web.server.api.endpoints.lineage import column_lineage, model_lineage
 from web.server.api.endpoints.models import get_models
 from typing import Union
@@ -77,9 +78,6 @@ class ContextLoaded:
     lsp_context: LSPContext
 
 
-type ContextFailedError = str | ConfigError
-
-
 @dataclass
 class ContextFailed:
     """State when context failed to load with an error message."""
@@ -324,7 +322,9 @@ def initialize(ls: LanguageServer, params: types.InitializeParams) -> None:
                         ls.show_message("Client supports pull diagnostics", types.MessageType.Info)
                     else:
                         self.client_supports_pull_diagnostics = False
-                        ls.show_message("Client does not support pull diagnostics", types.MessageType.Info)
+                        ls.show_message(
+                            "Client does not support pull diagnostics", types.MessageType.Info
+                        )
                 else:
                     self.client_supports_pull_diagnostics = False
                     ls.show_message("Client capabilities not available", types.MessageType.Info)
@@ -357,7 +357,7 @@ def did_open(ls: LanguageServer, params: types.DidOpenTextDocumentParams) -> Non
             uri = URI(params.text_document.uri)
             try:
                 context = self._context_get_or_load(ls, uri)
-                
+
                 # Only publish diagnostics if client doesn't support pull diagnostics
                 if not self.client_supports_pull_diagnostics:
                     diagnostics = context.lint_model(uri)
@@ -894,30 +894,9 @@ def _create_lsp_context(
             return self.context_state.lsp_context
         except Exception as e:
             # Only show the error message once
-            if not self.has_raised_loading_error:
-                location_info = f" at {e.location}" if isinstance(e, ConfigError) and e.location else ""
-                self.server.show_message(
-                    f"Error creating context error type {type(e)}: {e}{location_info}",
-                    types.MessageType.Error,
-                )
-                self.has_raised_loading_error = True
-            error_message = e if isinstance(e, ConfigError) else str(e)
-            if isinstance(e, ConfigError) and e.location is not None:
-                uri = URI.from_path(e.location)
-                ls.show_message(f"Publishing diagnostic to URI: {uri.value}", types.MessageType.Info)
-                ls.publish_diagnostics(
-                    uri.value,
-                    [
-                        types.Diagnostic(
-                            range=types.Range(
-                                start=types.Position(line=0, character=0),
-                                end=types.Position(line=0, character=0),
-                            ),
-                            message=str(error_message),
-                            severity=types.DiagnosticSeverity.Error,
-                        )
-                    ],
-                )
+            (uri, diagnostic), error = contextErrorToDiagnostic(e)
+            if diagnostic:
+                ls.publish_diagnostics(uri, [diagnostic])
 
             # Store the error in context state such that later requests can
             # show the actual error. Try to preserve any partially loaded context
@@ -927,7 +906,7 @@ def _create_lsp_context(
                 context = self.context_state.lsp_context.context
             elif isinstance(self.context_state, ContextFailed) and self.context_state.context:
                 context = self.context_state.context
-            self.context_state = ContextFailed(error_message=error_message, context=context)
+            self.context_state = ContextFailed(error_message=error, context=context)
             return None
 
     @staticmethod

sqlmesh/utils/errors.py

@@ -32,6 +32,49 @@ def __init__(self, message: str | Exception, location: t.Optional[Path] = None)
             self.location = Path(location) if isinstance(location, str) else location
 
 
+class ModelBlockFieldValidationMissingFieldsError(ConfigError):
+    """Raised when required fields are missing from a model block."""
+
+    missing_fields: t.Set[str]
+
+    def __init__(self, path: Path, missing_fields: t.Set[str]) -> None:
+        super().__init__(
+            self.message(missing_fields),
+            path,
+        )
+        self.missing_fields = missing_fields
+
+    @staticmethod
+    def message(missing_fields: t.Set[str]) -> str:
+        field_names = "'" + "', '".join(missing_fields) + "'"
+        return f"Please add required field{'s' if len(missing_fields) > 1 else ''} {field_names} to the model block."
+
+
+class ModeBlockExtraFields(ConfigError):
+    """Raised when there are extra fields in a model block that are not defined in the model schema. If there are close
+     matches, this tries to recommend them"""
+
+    def __init__(self, path: Path, extra_fields: t.Dict[str, t.Optional[None]]) -> None:
+        super().__init__(
+            self.message(extra_fields),
+            path,
+        )
+        self.extra_fields = extra_fields
+
+    @staticmethod
+    def message(extra_fields: t.Dict[str, t.Optional[None]]) -> str:
+        if len(extra_with_close_match) == 1:
+            similar_msg = (
+                ". Did you mean " + "'" + "', '".join(extra_with_close_match.values()) + "'?"
+            )
+        else:
+            similar = [
+                f"- {field}: Did you mean '{match}'?" for field, match in close_matches.items()
+            ]
+            similar_msg = "\n\n  " + "\n  ".join(similar) if similar else ""
+        return f"Invalid field name{'s' if len(extra_fields) > 1 else ''} present in the {entity_name}: {extra_field_names}{similar_msg}"
+
+
 class MissingDependencyError(SQLMeshError):
     """Local environment is missing a required dependency for the given operation"""