temp [ci skip]

Author: benfdking

sqlmesh/core/model/common.py

@@ -13,7 +13,8 @@
 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 +270,29 @@ 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}."
+        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]
+                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,
+            )
 
-        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,
-        )
 
 
 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/utils/errors.py

@@ -31,6 +31,48 @@ def __init__(self, message: str | Exception, location: t.Optional[Path] = None)
         if location:
             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(self, missing_fields: t.List[str]) -> str:
+        field_names = "'" + "', '".join(self.missing_fields) + "'"
+        return f"Please add required field{'s' if len(self.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 ""
+
+        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,
+        )
+
 
 class MissingDependencyError(SQLMeshError):
     """Local environment is missing a required dependency for the given operation"""