[SCHEMATIC-308] Add ability for JSON Schema type to be set by columnType attribute (#1625)

* add ability for JSON Schema type to bet set by columnType attribute

* clean up docstrings

* ran pre-commit

Author: andrewelamb

schematic/schemas/create_json_schema.py

@@ -12,6 +12,7 @@
 import os
 from typing import Union, Any, Optional
 from dataclasses import dataclass, field, asdict
+import warnings
 
 from schematic.schemas.data_model_graph import DataModelGraphExplorer
 from schematic.utils.schema_utils import get_json_schema_log_file_path
@@ -200,6 +201,9 @@ def __post_init__(self) -> None:
         self.description = self.dmge.get_node_comment(
             node_display_name=self.display_name
         )
+        explicit_js_type = self.dmge.get_node_column_type(
+            node_display_name=self.display_name
+        )
 
         (
             self.is_array,
@@ -208,11 +212,13 @@ def __post_init__(self) -> None:
             self.minimum,
             self.maximum,
             self.pattern,
-        ) = _get_validation_rule_based_fields(validation_rules)
+        ) = _get_validation_rule_based_fields(
+            validation_rules, explicit_js_type, self.name
+        )
 
 
 def _get_validation_rule_based_fields(
-    validation_rules: list[str],
+    validation_rules: list[str], explicit_js_type: Optional[JSONSchemaType], name: str
 ) -> tuple[
     bool,
     Optional[JSONSchemaType],
@@ -234,6 +240,13 @@ def _get_validation_rule_based_fields(
 
     Arguments:
         validation_rules: A list of input validation rules
+        explicit_js_type: A JSONSchemaType if set explicitly in the data model, otherwise None
+        name: The name of the node the validation rules belong to
+
+    Raises:
+       ValueError: When an explicit JSON Schema type is given, but the implicit type is different
+       Warning: When no explicit JSON Schema type is given,
+         and an implicit type is derived from  the validation rules
 
     Returns:
         A tuple containing fields for a Node object:
@@ -262,7 +275,38 @@ def _get_validation_rule_based_fields(
 
         js_is_array = ValidationRuleName.LIST in validation_rule_names
 
-        js_type = get_js_type_from_inputted_rules(validation_rules)
+        # The explicit JSON Schema type is the one set in the data model
+        # The implicit JSON Schema type is the one implied by the presence
+        #   of certain validation rules
+        # Schematic will use the implicit type if the explicit type isn't specified for now,
+        #   but this behavior is deprecated and will be removed in the future by SCHEMATIC-326
+        implicit_js_type = get_js_type_from_inputted_rules(validation_rules)
+        # If there is an explicit type set...
+        if explicit_js_type:
+            # and the implicit type conflicts with the explicit type, then an exception is raised
+            if explicit_js_type != implicit_js_type:
+                msg = (
+                    f"Property: '{name}', has explicit type: '{explicit_js_type}' "
+                    f"that conflicts with the implicit type: '{implicit_js_type}' "
+                    f"derived from its validation rules: {validation_rules}"
+                )
+                raise ValueError(msg)
+            # otherwise the explicit type is used
+            js_type = explicit_js_type
+        # If there is no explicit type...
+        else:
+            # and there is an implicit type...
+            if implicit_js_type:
+                # then the implicit type is used...
+                js_type = implicit_js_type
+                # and a warning is raised since this behavior is deprecated
+                msg = (
+                    f"No explicit type set for property: '{name}', "
+                    "using validation rules to set the type. "
+                    "Using validation rules to set type is deprecated. "
+                    "You should set the columnType for this property in your data model."
+                )
+                warnings.warn(msg)
 
         if ValidationRuleName.URL in validation_rule_names:
             js_format = JSONSchemaFormat.URI

tests/unit/test_create_json_schema.py

@@ -231,7 +231,7 @@ def test_node_init(
     ],
     ids=["No rules", "String", "List", "ListString", "InRange", "Regex", "Date", "URL"],
 )
-def test_get_validation_rule_based_fields(
+def test_get_validation_rule_based_fields_no_explicit_type(
     validation_rules: list[str],
     expected_type: Optional[JSONSchemaType],
     expected_is_array: bool,
@@ -240,15 +240,104 @@ def test_get_validation_rule_based_fields(
     expected_pattern: Optional[str],
     expected_format: Optional[JSONSchemaFormat],
 ) -> None:
-    """Tests for _get_validation_rule_based_fields"""
+    """
+    Test for _get_validation_rule_based_fields
+    Tests that output is expected based on the input validation rules
+    """
+    (
+        is_array,
+        property_type,
+        property_format,
+        minimum,
+        maximum,
+        pattern,
+    ) = _get_validation_rule_based_fields(validation_rules, None, "name")
+    assert property_type == expected_type
+    assert property_format == expected_format
+    assert is_array == expected_is_array
+    assert minimum == expected_min
+    assert maximum == expected_max
+    assert pattern == expected_pattern
+
+
+@pytest.mark.parametrize(
+    "validation_rules, explicit_type, expected_type, expected_is_array, expected_min, expected_max, expected_pattern, expected_format",
+    [
+        (
+            ["str"],
+            JSONSchemaType.STRING,
+            JSONSchemaType.STRING,
+            False,
+            None,
+            None,
+            None,
+            None,
+        ),
+        (
+            ["inRange 50 100"],
+            JSONSchemaType.NUMBER,
+            JSONSchemaType.NUMBER,
+            False,
+            50,
+            100,
+            None,
+            None,
+        ),
+        (
+            ["regex search [a-f]"],
+            JSONSchemaType.STRING,
+            JSONSchemaType.STRING,
+            False,
+            None,
+            None,
+            "[a-f]",
+            None,
+        ),
+        (
+            ["date"],
+            JSONSchemaType.STRING,
+            JSONSchemaType.STRING,
+            False,
+            None,
+            None,
+            None,
+            JSONSchemaFormat.DATE,
+        ),
+        (
+            ["url"],
+            JSONSchemaType.STRING,
+            JSONSchemaType.STRING,
+            False,
+            None,
+            None,
+            None,
+            JSONSchemaFormat.URI,
+        ),
+    ],
+    ids=["String", "InRange", "Regex", "Date", "URL"],
+)
+def test_get_validation_rule_based_fields_with_explicit_type(
+    validation_rules: list[str],
+    explicit_type: JSONSchemaType,
+    expected_type: Optional[JSONSchemaType],
+    expected_is_array: bool,
+    expected_min: Optional[float],
+    expected_max: Optional[float],
+    expected_pattern: Optional[str],
+    expected_format: Optional[JSONSchemaFormat],
+) -> None:
+    """
+    Test for _get_validation_rule_based_fields
+    Tests that output is expected based on the input validation rules, and explicit type
+    """
     (
         is_array,
         property_type,
         property_format,
         minimum,
         maximum,
         pattern,
-    ) = _get_validation_rule_based_fields(validation_rules)
+    ) = _get_validation_rule_based_fields(validation_rules, explicit_type, "name")
     assert property_type == expected_type
     assert property_format == expected_format
     assert is_array == expected_is_array
@@ -257,6 +346,35 @@ def test_get_validation_rule_based_fields(
     assert pattern == expected_pattern
 
 
+@pytest.mark.parametrize(
+    "validation_rules, explicit_type",
+    [
+        (["str"], JSONSchemaType.INTEGER),
+        (["inRange 50 100"], JSONSchemaType.STRING),
+        (["regex search [a-f]"], JSONSchemaType.INTEGER),
+        (["date"], JSONSchemaType.INTEGER),
+        (["url"], JSONSchemaType.INTEGER),
+    ],
+    ids=[
+        "String rule, integer type",
+        "InRange rule, string type",
+        "Regex rule, integer type",
+        "Date rule, integer type",
+        "Url rule, integer type",
+    ],
+)
+def test_get_validation_rule_based_fields_with_exception(
+    validation_rules: list[str],
+    explicit_type: JSONSchemaType,
+) -> None:
+    """
+    Test for _get_validation_rule_based_fields
+    Tests that output is expected based on the input validation rules, and explicit type
+    """
+    with pytest.raises(ValueError):
+        _get_validation_rule_based_fields(validation_rules, explicit_type, "name")
+
+
 class TestGraphTraversalState:
     """Tests for GraphTraversalState class"""