datacontract-cli 0.10.35__py3-none-any.whl → 0.10.36__py3-none-any.whl

datacontract/api.py

@@ -10,7 +10,7 @@ from fastapi.security.api_key import APIKeyHeader
 from datacontract.data_contract import DataContract, ExportFormat
 from datacontract.model.run import Run
 
-DATA_CONTRACT_EXAMPLE_PAYLOAD = """dataContractSpecification: 1.2.0
+DATA_CONTRACT_EXAMPLE_PAYLOAD = """dataContractSpecification: 1.2.1
 id: urn:datacontract:checkout:orders-latest
 info:
   title: Orders Latest

datacontract/cli.py

@@ -331,7 +331,7 @@ def import_(
     """
     Create a data contract from the given source location. Saves to file specified by `output` option if present, otherwise prints to stdout.
     """
-    result = DataContract().import_from_source(
+    result = DataContract.import_from_source(
         format=format,
         source=source,
         spec=spec,

datacontract/data_contract.py

@@ -26,11 +26,6 @@ from datacontract.imports.importer_factory import importer_factory
 from datacontract.init.init_template import get_init_template
 from datacontract.integration.datamesh_manager import publish_test_results_to_datamesh_manager
 from datacontract.lint import resolve
-from datacontract.lint.linters.description_linter import DescriptionLinter
-from datacontract.lint.linters.field_pattern_linter import FieldPatternLinter
-from datacontract.lint.linters.field_reference_linter import FieldReferenceLinter
-from datacontract.lint.linters.notice_period_linter import NoticePeriodLinter
-from datacontract.lint.linters.valid_constraints_linter import ValidFieldConstraintsLinter
 from datacontract.model.data_contract_specification import DataContractSpecification, Info
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Check, ResultEnum, Run
@@ -64,24 +59,14 @@ class DataContract:
         self._inline_definitions = inline_definitions
         self._inline_quality = inline_quality
         self._ssl_verification = ssl_verification
-        self.all_linters = {
-            FieldPatternLinter(),
-            FieldReferenceLinter(),
-            NoticePeriodLinter(),
-            ValidFieldConstraintsLinter(),
-            DescriptionLinter(),
-        }
 
     @classmethod
     def init(cls, template: typing.Optional[str], schema: typing.Optional[str] = None) -> DataContractSpecification:
         template_str = get_init_template(template)
         return resolve.resolve_data_contract(data_contract_str=template_str, schema_location=schema)
 
-    def lint(self, enabled_linters: typing.Union[str, set[str]] = "all") -> Run:
-        """Lint the data contract by deserializing the contract and checking the schema, as well as calling the configured linters.
-
-        enabled_linters can be either "all" or "none", or a set of linter IDs. The "schema" linter is always enabled, even with enabled_linters="none".
-        """
+    def lint(self) -> Run:
+        """Lint the data contract by validating it against the JSON schema."""
         run = Run.create_run()
         try:
             run.log_info("Linting data contract")
@@ -101,27 +86,6 @@ class DataContract:
                     engine="datacontract",
                 )
             )
-            if enabled_linters == "none":
-                linters_to_check = set()
-            elif enabled_linters == "all":
-                linters_to_check = self.all_linters
-            elif isinstance(enabled_linters, set):
-                linters_to_check = {linter for linter in self.all_linters if linter.id in enabled_linters}
-            else:
-                raise RuntimeError(f"Unknown argument enabled_linters={enabled_linters} for lint()")
-            for linter in linters_to_check:
-                try:
-                    run.checks.extend(linter.lint(data_contract))
-                except Exception as e:
-                    run.checks.append(
-                        Check(
-                            type="general",
-                            result=ResultEnum.error,
-                            name=f"Linter '{linter.name}'",
-                            reason=str(e),
-                            engine="datacontract",
-                        )
-                    )
             run.dataContractId = data_contract.id
             run.dataContractVersion = data_contract.info.version
         except DataContractException as e:
@@ -292,10 +256,9 @@ class DataContract:
                 export_args=kwargs,
             )
 
-    # REFACTOR THIS
-    # could be a class method, not using anything from the instance
+    @classmethod
     def import_from_source(
-        self,
+        cls,
         format: str,
         source: typing.Optional[str] = None,
         template: typing.Optional[str] = None,
@@ -307,7 +270,7 @@ class DataContract:
         owner = kwargs.get("owner")
 
         if spec == Spec.odcs or format == ImportFormat.excel:
-            data_contract_specification_initial = DataContract.init(template=template, schema=schema)
+            data_contract_specification_initial = cls.init(template=template, schema=schema)
 
             odcs_imported = importer_factory.create(format).import_source(
                 data_contract_specification=data_contract_specification_initial, source=source, import_args=kwargs
@@ -317,12 +280,12 @@ class DataContract:
                 # convert automatically
                 odcs_imported = to_odcs_v3(odcs_imported)
 
-            self._overwrite_id_in_odcs(odcs_imported, id)
-            self._overwrite_owner_in_odcs(odcs_imported, owner)
+            cls._overwrite_id_in_odcs(odcs_imported, id)
+            cls._overwrite_owner_in_odcs(odcs_imported, owner)
 
             return odcs_imported
         elif spec == Spec.datacontract_specification:
-            data_contract_specification_initial = DataContract.init(template=template, schema=schema)
+            data_contract_specification_initial = cls.init(template=template, schema=schema)
 
             data_contract_specification_imported = importer_factory.create(format).import_source(
                 data_contract_specification=data_contract_specification_initial, source=source, import_args=kwargs
@@ -334,8 +297,8 @@ class DataContract:
                     data_contract_specification_initial, data_contract_specification_imported
                 )
 
-            self._overwrite_id_in_data_contract_specification(data_contract_specification_imported, id)
-            self._overwrite_owner_in_data_contract_specification(data_contract_specification_imported, owner)
+            cls._overwrite_id_in_data_contract_specification(data_contract_specification_imported, id)
+            cls._overwrite_owner_in_data_contract_specification(data_contract_specification_imported, owner)
 
             return data_contract_specification_imported
         else:
@@ -347,16 +310,18 @@ class DataContract:
                 engine="datacontract",
             )
 
+    @staticmethod
     def _overwrite_id_in_data_contract_specification(
-        self, data_contract_specification: DataContractSpecification, id: str | None
+        data_contract_specification: DataContractSpecification, id: str | None
     ):
         if not id:
             return
 
         data_contract_specification.id = id
 
+    @staticmethod
     def _overwrite_owner_in_data_contract_specification(
-        self, data_contract_specification: DataContractSpecification, owner: str | None
+        data_contract_specification: DataContractSpecification, owner: str | None
     ):
         if not owner:
             return
@@ -365,7 +330,8 @@ class DataContract:
             data_contract_specification.info = Info()
         data_contract_specification.info.owner = owner
 
-    def _overwrite_owner_in_odcs(self, odcs: OpenDataContractStandard, owner: str | None):
+    @staticmethod
+    def _overwrite_owner_in_odcs(odcs: OpenDataContractStandard, owner: str | None):
         if not owner:
             return
 
@@ -377,7 +343,8 @@ class DataContract:
                 return
         odcs.customProperties.append(CustomProperty(property="owner", value=owner))
 
-    def _overwrite_id_in_odcs(self, odcs: OpenDataContractStandard, id: str | None):
+    @staticmethod
+    def _overwrite_id_in_odcs(odcs: OpenDataContractStandard, id: str | None):
         if not id:
             return
 

datacontract/engines/data_contract_checks.py

@@ -15,6 +15,7 @@ from datacontract.model.run import Check
 class QuotingConfig:
     quote_field_name: bool = False
     quote_model_name: bool = False
+    quote_model_name_with_backticks: bool = False
 
 
 def create_checks(data_contract_spec: DataContractSpecification, server: Server) -> List[Check]:
@@ -35,15 +36,18 @@ def to_model_checks(model_key, model_value, server: Server) -> List[Check]:
 
     check_types = is_check_types(server)
 
-    quoting_config = QuotingConfig(
-        quote_field_name=server_type in ["postgres", "sqlserver"],
-        quote_model_name=server_type in ["postgres", "sqlserver"],
+    type1 = server.type if server and server.type else None
+    config = QuotingConfig(
+        quote_field_name=type1 in ["postgres", "sqlserver"],
+        quote_model_name=type1 in ["postgres", "sqlserver"],
+        quote_model_name_with_backticks=type1 == "bigquery",
     )
+    quoting_config = config
 
     for field_name, field in fields.items():
         checks.append(check_field_is_present(model_name, field_name, quoting_config))
         if check_types and field.type is not None:
-            sql_type = convert_to_sql_type(field, server_type)
+            sql_type: str = convert_to_sql_type(field, server_type)
             checks.append(check_field_type(model_name, field_name, sql_type, quoting_config))
         if field.required:
             checks.append(check_field_required(model_name, field_name, quoting_config))
@@ -82,9 +86,11 @@ def to_model_checks(model_key, model_value, server: Server) -> List[Check]:
     return checks
 
 
-def checks_for(model_name, quote_model_name: bool):
-    if quote_model_name:
+def checks_for(model_name: str, quoting_config: QuotingConfig, check_type: str) -> str:
+    if quoting_config.quote_model_name:
         return f'checks for "{model_name}"'
+    elif quoting_config.quote_model_name_with_backticks and check_type not in ["field_is_present", "field_type"]:
+        return f"checks for `{model_name}`"
     return f"checks for {model_name}"
 
 
@@ -114,7 +120,7 @@ def check_field_is_present(model_name, field_name, quoting_config: QuotingConfig
     check_type = "field_is_present"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 "schema": {
                     "name": check_key,
@@ -145,7 +151,7 @@ def check_field_type(
     check_type = "field_type"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 "schema": {
                     "name": check_key,
@@ -181,7 +187,7 @@ def check_field_required(model_name: str, field_name: str, quoting_config: Quoti
     check_type = "field_required"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"missing_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -212,7 +218,7 @@ def check_field_unique(model_name: str, field_name: str, quoting_config: Quoting
     check_type = "field_unique"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"duplicate_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -245,7 +251,7 @@ def check_field_min_length(
     check_type = "field_min_length"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -279,7 +285,7 @@ def check_field_max_length(
     check_type = "field_max_length"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -313,7 +319,7 @@ def check_field_minimum(
     check_type = "field_minimum"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -347,7 +353,7 @@ def check_field_maximum(
     check_type = "field_maximum"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -381,7 +387,7 @@ def check_field_not_equal(
     check_type = "field_not_equal"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -413,7 +419,7 @@ def check_field_enum(model_name: str, field_name: str, enum: list, quoting_confi
     check_type = "field_enum"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -445,7 +451,7 @@ def check_field_regex(model_name: str, field_name: str, pattern: str, quoting_co
     check_type = "field_regex"
     check_key = f"{model_name}__{field_name}__{check_type}"
     sodacl_check_dict = {
-        checks_for(model_name, quoting_config.quote_model_name): [
+        checks_for(model_name, quoting_config, check_type): [
             {
                 f"invalid_count({field_name_for_soda}) = 0": {
                     "name": check_key,
@@ -468,6 +474,212 @@ def check_field_regex(model_name: str, field_name: str, pattern: str, quoting_co
     )
 
 
+def check_row_count(model_name: str, threshold: str, quoting_config: QuotingConfig = QuotingConfig()):
+    check_type = "row_count"
+    check_key = f"{model_name}__{check_type}"
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"row_count {threshold}": {"name": check_key},
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="schema",
+        type=check_type,
+        name=f"Check that model {model_name} has row_count {threshold}",
+        model=model_name,
+        field=None,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
+def check_model_duplicate_values(
+    model_name: str, cols: list[str], threshold: str, quoting_config: QuotingConfig = QuotingConfig()
+):
+    check_type = "model_duplicate_values"
+    check_key = f"{model_name}__{check_type}"
+    col_joined = ", ".join(cols)
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"duplicate_count({col_joined}) {threshold}": {"name": check_key},
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="quality",
+        type=check_type,
+        name=f"Check that model {model_name} has duplicate_count {threshold} for columns {col_joined}",
+        model=model_name,
+        field=None,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
+def check_field_duplicate_values(
+    model_name: str, field_name: str, threshold: str, quoting_config: QuotingConfig = QuotingConfig()
+):
+    if quoting_config.quote_field_name:
+        field_name_for_soda = f'"{field_name}"'
+    else:
+        field_name_for_soda = field_name
+
+    check_type = "field_duplicate_values"
+    check_key = f"{model_name}__{field_name}__{check_type}"
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"duplicate_count({field_name_for_soda}) {threshold}": {
+                    "name": check_key,
+                },
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="quality",
+        type=check_type,
+        name=f"Check that field {field_name} has duplicate_count {threshold}",
+        model=model_name,
+        field=field_name,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
+def check_field_null_values(
+    model_name: str, field_name: str, threshold: str, quoting_config: QuotingConfig = QuotingConfig()
+):
+    if quoting_config.quote_field_name:
+        field_name_for_soda = f'"{field_name}"'
+    else:
+        field_name_for_soda = field_name
+
+    check_type = "field_null_values"
+    check_key = f"{model_name}__{field_name}__{check_type}"
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"missing_count({field_name_for_soda}) {threshold}": {
+                    "name": check_key,
+                },
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="quality",
+        type=check_type,
+        name=f"Check that field {field_name} has missing_count {threshold}",
+        model=model_name,
+        field=field_name,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
+def check_field_invalid_values(
+    model_name: str,
+    field_name: str,
+    threshold: str,
+    valid_values: list = None,
+    quoting_config: QuotingConfig = QuotingConfig(),
+):
+    if quoting_config.quote_field_name:
+        field_name_for_soda = f'"{field_name}"'
+    else:
+        field_name_for_soda = field_name
+
+    check_type = "field_invalid_values"
+    check_key = f"{model_name}__{field_name}__{check_type}"
+
+    sodacl_check_config = {
+        "name": check_key,
+    }
+
+    if valid_values is not None:
+        sodacl_check_config["valid values"] = valid_values
+
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"invalid_count({field_name_for_soda}) {threshold}": sodacl_check_config,
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="quality",
+        type=check_type,
+        name=f"Check that field {field_name} has invalid_count {threshold}",
+        model=model_name,
+        field=field_name,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
+def check_field_missing_values(
+    model_name: str,
+    field_name: str,
+    threshold: str,
+    missing_values: list = None,
+    quoting_config: QuotingConfig = QuotingConfig(),
+):
+    if quoting_config.quote_field_name:
+        field_name_for_soda = f'"{field_name}"'
+    else:
+        field_name_for_soda = field_name
+
+    check_type = "field_missing_values"
+    check_key = f"{model_name}__{field_name}__{check_type}"
+
+    sodacl_check_config = {
+        "name": check_key,
+    }
+
+    if missing_values is not None:
+        # Filter out null/None values as SodaCL handles these automatically
+        filtered_missing_values = [v for v in missing_values if v is not None]
+        if filtered_missing_values:
+            sodacl_check_config["missing values"] = filtered_missing_values
+
+    sodacl_check_dict = {
+        checks_for(model_name, quoting_config, check_type): [
+            {
+                f"missing_count({field_name_for_soda}) {threshold}": sodacl_check_config,
+            }
+        ],
+    }
+    return Check(
+        id=str(uuid.uuid4()),
+        key=check_key,
+        category="quality",
+        type=check_type,
+        name=f"Check that field {field_name} has missing_count {threshold}",
+        model=model_name,
+        field=field_name,
+        engine="soda",
+        language="sodacl",
+        implementation=yaml.dump(sodacl_check_dict),
+    )
+
+
 def check_quality_list(
     model_name, field_name, quality_list: List[Quality], quoting_config: QuotingConfig = QuotingConfig()
 ) -> List[Check]:
@@ -519,6 +731,49 @@ def check_quality_list(
                     implementation=yaml.dump(sodacl_check_dict),
                 )
             )
+        elif quality.metric is not None:
+            threshold = to_sodacl_threshold(quality)
+
+            if threshold is None:
+                logger.warning(f"Quality metric {quality.metric} has no valid threshold")
+                continue
+
+            if quality.metric == "rowCount":
+                checks.append(check_row_count(model_name, threshold, quoting_config))
+            elif quality.metric == "duplicateValues":
+                if field_name is None:
+                    # TODO check that quality.arguments.get("properties") is a list of strings and contains at lease one property
+                    checks.append(
+                        check_model_duplicate_values(
+                            model_name, quality.arguments.get("properties"), threshold, quoting_config
+                        )
+                    )
+                else:
+                    checks.append(check_field_duplicate_values(model_name, field_name, threshold, quoting_config))
+            elif quality.metric == "nullValues":
+                if field_name is not None:
+                    checks.append(check_field_null_values(model_name, field_name, threshold, quoting_config))
+                else:
+                    logger.warning("Quality check nullValues is only supported at field level")
+            elif quality.metric == "invalidValues":
+                if field_name is not None:
+                    valid_values = quality.arguments.get("validValues") if quality.arguments else None
+                    checks.append(
+                        check_field_invalid_values(model_name, field_name, threshold, valid_values, quoting_config)
+                    )
+                else:
+                    logger.warning("Quality check invalidValues is only supported at field level")
+            elif quality.metric == "missingValues":
+                if field_name is not None:
+                    missing_values = quality.arguments.get("missingValues") if quality.arguments else None
+                    checks.append(
+                        check_field_missing_values(model_name, field_name, threshold, missing_values, quoting_config)
+                    )
+                else:
+                    logger.warning("Quality check missingValues is only supported at field level")
+            else:
+                logger.warning(f"Quality check {quality.metric} is not yet supported")
+
         count += 1
 
     return checks
@@ -541,6 +796,8 @@ def prepare_query(
 
     if quoting_config.quote_model_name:
         model_name_for_soda = f'"{model_name}"'
+    elif quoting_config.quote_model_name_with_backticks:
+        model_name_for_soda = f"`{model_name}`"
     else:
         model_name_for_soda = model_name
 
@@ -563,10 +820,14 @@ def to_sodacl_threshold(quality: Quality) -> str | None:
         return f"!= {quality.mustNotBe}"
     if quality.mustBeGreaterThan is not None:
         return f"> {quality.mustBeGreaterThan}"
+    if quality.mustBeGreaterOrEqualTo is not None:
+        return f">= {quality.mustBeGreaterOrEqualTo}"
     if quality.mustBeGreaterThanOrEqualTo is not None:
         return f">= {quality.mustBeGreaterThanOrEqualTo}"
     if quality.mustBeLessThan is not None:
         return f"< {quality.mustBeLessThan}"
+    if quality.mustBeLessOrEqualTo is not None:
+        return f"<= {quality.mustBeLessOrEqualTo}"
     if quality.mustBeLessThanOrEqualTo is not None:
         return f"<= {quality.mustBeLessThanOrEqualTo}"
     if quality.mustBeBetween is not None:
@@ -639,7 +900,7 @@ def to_servicelevel_freshness_check(data_contract_spec: DataContractSpecificatio
     check_key = "servicelevel_freshness"
 
     sodacl_check_dict = {
-        checks_for(model_name, False): [
+        checks_for(model_name, QuotingConfig(), check_type): [
             {
                 f"freshness({field_name}) < {threshold}": {
                     "name": check_key,
@@ -691,7 +952,7 @@ def to_servicelevel_retention_check(data_contract_spec) -> Check | None:
     check_type = "servicelevel_retention"
     check_key = "servicelevel_retention"
     sodacl_check_dict = {
-        checks_for(model_name, False): [
+        checks_for(model_name, QuotingConfig(), check_type): [
             {
                 f"orders_servicelevel_retention < {period_in_seconds}": {
                     "orders_servicelevel_retention expression": f"TIMESTAMPDIFF(SECOND, MIN({field_name}), CURRENT_TIMESTAMP)",

datacontract/export/dbt_converter.py

@@ -115,9 +115,28 @@ def _to_dbt_model(
         dbt_model["config"]["contract"] = {"enforced": True}
     if model_value.description is not None:
         dbt_model["description"] = model_value.description.strip().replace("\n", " ")
-    columns = _to_columns(data_contract_spec, model_value.fields, _supports_constraints(model_type), adapter_type)
+
+    # Handle model-level primaryKey (before columns for better YAML ordering)
+    primary_key_columns = []
+    if hasattr(model_value, "primaryKey") and model_value.primaryKey:
+        if isinstance(model_value.primaryKey, list) and len(model_value.primaryKey) > 1:
+            # Multiple columns: use dbt_utils.unique_combination_of_columns
+            dbt_model["data_tests"] = [
+                {"dbt_utils.unique_combination_of_columns": {"combination_of_columns": model_value.primaryKey}}
+            ]
+        elif isinstance(model_value.primaryKey, list) and len(model_value.primaryKey) == 1:
+            # Single column: handle at column level (pass to _to_columns)
+            primary_key_columns = model_value.primaryKey
+        elif isinstance(model_value.primaryKey, str):
+            # Single column as string: handle at column level
+            primary_key_columns = [model_value.primaryKey]
+
+    columns = _to_columns(
+        data_contract_spec, model_value.fields, _supports_constraints(model_type), adapter_type, primary_key_columns
+    )
     if columns:
         dbt_model["columns"] = columns
+
     return dbt_model
 
 
@@ -143,10 +162,13 @@ def _to_columns(
     fields: Dict[str, Field],
     supports_constraints: bool,
     adapter_type: Optional[str],
+    primary_key_columns: Optional[list] = None,
 ) -> list:
     columns = []
+    primary_key_columns = primary_key_columns or []
     for field_name, field in fields.items():
-        column = _to_column(data_contract_spec, field_name, field, supports_constraints, adapter_type)
+        is_primary_key = field_name in primary_key_columns
+        column = _to_column(data_contract_spec, field_name, field, supports_constraints, adapter_type, is_primary_key)
         columns.append(column)
     return columns
 
@@ -164,6 +186,7 @@ def _to_column(
     field: Field,
     supports_constraints: bool,
     adapter_type: Optional[str],
+    is_primary_key: bool = False,
 ) -> dict:
     column = {"name": field_name}
     adapter_type = adapter_type or "snowflake"
@@ -178,12 +201,15 @@ def _to_column(
         )
     if field.description is not None:
         column["description"] = field.description.strip().replace("\n", " ")
-    if field.required:
+    # Handle required/not_null constraint
+    if field.required or is_primary_key:
         if supports_constraints:
             column.setdefault("constraints", []).append({"type": "not_null"})
         else:
             column["data_tests"].append("not_null")
-    if field.unique:
+
+    # Handle unique constraint
+    if field.unique or is_primary_key:
         if supports_constraints:
             column.setdefault("constraints", []).append({"type": "unique"})
         else: