datacontract-cli 0.10.2__py3-none-any.whl → 0.10.4__py3-none-any.whl

datacontract/breaking/breaking.py

@@ -256,6 +256,18 @@ def field_breaking_changes(
                 )
             )
             continue
+        
+        if field_definition_field == "items" and old_field.type == 'array' and new_field.type == 'array':
+            results.extend(
+                field_breaking_changes(
+                    old_field=old_value,
+                    new_field=new_value,
+                    composition=composition + ['items'],
+                    new_path=new_path,
+                    include_severities=include_severities,
+                )
+            )
+            continue
 
         rule_name = None
         description = None

datacontract/breaking/breaking_rules.py

@@ -90,6 +90,10 @@ class BreakingRules:
     field_tags_removed = Severity.INFO
     field_tags_updated = Severity.INFO
 
+    field_example_added = Severity.INFO
+    field_example_updated = Severity.INFO
+    field_example_removed = Severity.INFO
+
     # quality Rules
     quality_added = Severity.INFO
     quality_removed = Severity.WARNING

datacontract/catalog/catalog.py

@@ -53,8 +53,10 @@ def create_index_html(contracts, path):
         )
 
         # Load the required template
+        # needs to be included in /MANIFEST.in
         template = env.get_template("index.html")
 
+        # needs to be included in /MANIFEST.in
         style_content, _, _ = package_loader.get_source(env, "style/output.css")
 
         tz = pytz.timezone("UTC")
@@ -69,6 +71,7 @@ def create_index_html(contracts, path):
             datacontract_cli_version=datacontract_cli_version,
             contracts=contracts,
             contracts_size=len(contracts),
+            owners=sorted(set(dc.spec.info.owner for dc in contracts if dc.spec.info.owner)),
         )
         f.write(html_string)
     print(f"Created {index_filepath}")

datacontract/cli.py

@@ -10,12 +10,14 @@ from rich.console import Console
 from rich.table import Table
 from typer.core import TyperGroup
 from typing_extensions import Annotated
+from typing import List
 
-from datacontract.catalog.catalog import create_index_html, \
-    create_data_contract_html
+from datacontract.catalog.catalog import create_index_html, create_data_contract_html
 from datacontract.data_contract import DataContract
-from datacontract.init.download_datacontract_file import \
-    download_datacontract_file, FileExistsException
+from datacontract.init.download_datacontract_file import download_datacontract_file, FileExistsException
+
+from datacontract.publish.publish import publish_to_datamesh_manager
+
 
 console = Console()
 
@@ -158,12 +160,19 @@ class ExportFormat(str, Enum):
     sql = "sql"
     sql_query = "sql-query"
     html = "html"
+    go = "go"
+    bigquery = "bigquery"
 
 
 @app.command()
 def export(
     format: Annotated[ExportFormat, typer.Option(help="The export format.")],
-    output: Annotated[Path, typer.Option(help="Specify the file path where the exported data will be saved. If no path is provided, the output will be printed to stdout.")] = None,
+    output: Annotated[
+        Path,
+        typer.Option(
+            help="Specify the file path where the exported data will be saved. If no path is provided, the output will be printed to stdout."
+        ),
+    ] = None,
     server: Annotated[str, typer.Option(help="The server name to export.")] = None,
     model: Annotated[
         str,
@@ -204,7 +213,7 @@ def export(
     if output is None:
         console.print(result, markup=False)
     else:
-        with output.open('w') as f:
+        with output.open("w") as f:
             f.write(result)
         console.print(f"Written result to {output}")
 
@@ -213,20 +222,39 @@ class ImportFormat(str, Enum):
     sql = "sql"
     avro = "avro"
     glue = "glue"
+    bigquery = "bigquery"
+    jsonschema = "jsonschema"
 
 
 @app.command(name="import")
 def import_(
     format: Annotated[ImportFormat, typer.Option(help="The format of the source file.")],
-    source: Annotated[str, typer.Option(help="The path to the file or Glue Database that should be imported.")],
+    source: Annotated[Optional[str], typer.Option(help="The path to the file or Glue Database that should be imported.")] = None,
+    bigquery_project: Annotated[Optional[str], typer.Option(help="The bigquery project id.")] = None,
+    bigquery_dataset: Annotated[Optional[str], typer.Option(help="The bigquery dataset id.")] = None,
+    bigquery_table: Annotated[Optional[List[str]], typer.Option(help="List of table ids to import from the bigquery API (repeat for multiple table ids, leave empty for all tables in the dataset).")] = None,
 ):
     """
     Create a data contract from the given source location. Prints to stdout.
     """
-    result = DataContract().import_from_source(format, source)
+    result = DataContract().import_from_source(format, source, bigquery_table, bigquery_project, bigquery_dataset)
     console.print(result.to_yaml())
 
 
+@app.command(name="publish")
+def publish(
+    location: Annotated[
+        str, typer.Argument(help="The location (url or path) of the data contract yaml.")
+    ] = "datacontract.yaml",
+):
+    """
+    Publish the data contract to the Data Mesh Manager.
+    """
+    publish_to_datamesh_manager(
+        data_contract=DataContract(data_contract_file=location),
+    )
+
+
 @app.command(name="catalog")
 def catalog(
     files: Annotated[

datacontract/data_contract.py

@@ -6,16 +6,15 @@ import typing
 import yaml
 from pyspark.sql import SparkSession
 
-from datacontract.breaking.breaking import models_breaking_changes, \
-    quality_breaking_changes
+from datacontract.breaking.breaking import models_breaking_changes, quality_breaking_changes
 from datacontract.engines.datacontract.check_that_datacontract_contains_valid_servers_configuration import (
     check_that_datacontract_contains_valid_server_configuration,
 )
-from datacontract.engines.fastjsonschema.check_jsonschema import \
-    check_jsonschema
+from datacontract.engines.fastjsonschema.check_jsonschema import check_jsonschema
 from datacontract.engines.soda.check_soda_execute import check_soda_execute
 from datacontract.export.avro_converter import to_avro_schema_json
 from datacontract.export.avro_idl_converter import to_avro_idl
+from datacontract.export.bigquery_converter import to_bigquery_json
 from datacontract.export.dbt_converter import to_dbt_models_yaml, \
     to_dbt_sources_yaml, to_dbt_staging_sql
 from datacontract.export.great_expectations_converter import \
@@ -25,13 +24,16 @@ from datacontract.export.jsonschema_converter import to_jsonschema_json
 from datacontract.export.odcs_converter import to_odcs_yaml
 from datacontract.export.protobuf_converter import to_protobuf
 from datacontract.export.pydantic_converter import to_pydantic_model_str
+from datacontract.export.go_converter import to_go_types
 from datacontract.export.rdf_converter import to_rdf_n3
 from datacontract.export.sodacl_converter import to_sodacl_yaml
 from datacontract.export.sql_converter import to_sql_ddl, to_sql_query
 from datacontract.export.terraform_converter import to_terraform
 from datacontract.imports.avro_importer import import_avro
+from datacontract.imports.bigquery_importer import import_bigquery_from_api, import_bigquery_from_json
 from datacontract.imports.glue_importer import import_glue
 from datacontract.imports.sql_importer import import_sql
+from datacontract.imports.jsonschema_importer import import_jsonschema
 from datacontract.integration.publish_datamesh_manager import \
     publish_datamesh_manager
 from datacontract.integration.publish_opentelemetry import publish_opentelemetry
@@ -39,17 +41,12 @@ from datacontract.lint import resolve
 from datacontract.lint.linters.description_linter import DescriptionLinter
 from datacontract.lint.linters.example_model_linter import ExampleModelLinter
 from datacontract.lint.linters.field_pattern_linter import FieldPatternLinter
-from datacontract.lint.linters.field_reference_linter import \
-    FieldReferenceLinter
+from datacontract.lint.linters.field_reference_linter import FieldReferenceLinter
 from datacontract.lint.linters.notice_period_linter import NoticePeriodLinter
-from datacontract.lint.linters.quality_schema_linter import \
-    QualityUsesSchemaLinter
-from datacontract.lint.linters.valid_constraints_linter import \
-    ValidFieldConstraintsLinter
-from datacontract.model.breaking_change import BreakingChanges, BreakingChange, \
-    Severity
-from datacontract.model.data_contract_specification import \
-    DataContractSpecification, Server
+from datacontract.lint.linters.quality_schema_linter import QualityUsesSchemaLinter
+from datacontract.lint.linters.valid_constraints_linter import ValidFieldConstraintsLinter
+from datacontract.model.breaking_change import BreakingChanges, BreakingChange, Severity
+from datacontract.model.data_contract_specification import DataContractSpecification, Server
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Run, Check
 
@@ -289,28 +286,8 @@ class DataContract:
             inline_quality=True,
         )
         if export_format == "jsonschema":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_jsonschema_json(model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_jsonschema_json(model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_jsonschema_json(model_name, model_value)
         if export_format == "sodacl":
             return to_sodacl_yaml(data_contract)
         if export_format == "dbt":
@@ -318,28 +295,8 @@ class DataContract:
         if export_format == "dbt-sources":
             return to_dbt_sources_yaml(data_contract, self._server)
         if export_format == "dbt-staging-sql":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_dbt_staging_sql(data_contract, model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_dbt_staging_sql(data_contract, model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_dbt_staging_sql(data_contract, model_name, model_value)
         if export_format == "odcs":
             return to_odcs_yaml(data_contract)
         if export_format == "rdf":
@@ -347,28 +304,8 @@ class DataContract:
         if export_format == "protobuf":
             return to_protobuf(data_contract)
         if export_format == "avro":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_avro_schema_json(model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_avro_schema_json(model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_avro_schema_json(model_name, model_value)
         if export_format == "avro-idl":
             return to_avro_idl(data_contract)
         if export_format == "terraform":
@@ -377,59 +314,26 @@ class DataContract:
             server_type = self._determine_sql_server_type(data_contract, sql_server_type)
             return to_sql_ddl(data_contract, server_type=server_type)
         if export_format == "sql-query":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
             server_type = self._determine_sql_server_type(data_contract, sql_server_type)
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_sql_query(data_contract, model_name, model_value, server_type)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_sql_query(data_contract, model_name, model_value, server_type)
-
+            return to_sql_query(data_contract, model_name, model_value, server_type)
         if export_format == "great-expectations":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model "
-                        f"$MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_great_expectations(data_contract, model_name)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. " f"Available models: {model_names}"
-                    )
-
-                return to_great_expectations(data_contract, model_name)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_great_expectations(data_contract, model_name)
         if export_format == "pydantic-model":
             return to_pydantic_model_str(data_contract)
         if export_format == "html":
             return to_html(data_contract)
+        if export_format == "go":
+            return to_go_types(data_contract)
+        if export_format == "bigquery":
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            found_server = data_contract.servers.get(self._server)
+            if found_server is None:
+                raise RuntimeError(f"Export to {export_format} requires selecting a bigquery server from the data contract.")
+            if found_server.type != 'bigquery':
+                raise RuntimeError(f"Export to {export_format} requires selecting a bigquery server from the data contract.")
+            return to_bigquery_json(model_name, model_value, found_server)
         else:
             print(f"Export format {export_format} not supported.")
             return ""
@@ -483,8 +387,31 @@ class DataContract:
         )
         run.log_info(f"Using {server} for testing the examples")
         return server
+    
+    def _check_models_for_export(self, data_contract: DataContractSpecification, model: str, export_format: str) -> typing.Tuple[str, str]:
+        if data_contract.models is None:
+            raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
+
+        model_names = list(data_contract.models.keys())
 
-    def import_from_source(self, format: str, source: str) -> DataContractSpecification:
+        if model == "all":
+            if len(data_contract.models.items()) != 1:
+                raise RuntimeError(
+                    f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
+                )
+
+            model_name, model_value = next(iter(data_contract.models.items()))
+        else:
+            model_name = model
+            model_value = data_contract.models.get(model_name)
+            if model_value is None:
+                raise RuntimeError(
+                    f"Model {model_name} not found in the data contract. Available models: {model_names}"
+                )
+            
+        return model_name, model_value
+
+    def import_from_source(self, format: str, source: typing.Optional[str] = None, bigquery_tables: typing.Optional[typing.List[str]] = None, bigquery_project: typing.Optional[str] = None, bigquery_dataset: typing.Optional[str] = None) -> DataContractSpecification:
         data_contract_specification = DataContract.init()
 
         if format == "sql":
@@ -493,6 +420,13 @@ class DataContract:
             data_contract_specification = import_avro(data_contract_specification, source)
         elif format == "glue":
             data_contract_specification = import_glue(data_contract_specification, source)
+        elif format == "jsonschema":
+            data_contract_specification = import_jsonschema(data_contract_specification, source)
+        elif format == "bigquery":
+            if source is not None:
+                data_contract_specification = import_bigquery_from_json(data_contract_specification, source)
+            else:
+                data_contract_specification = import_bigquery_from_api(data_contract_specification, bigquery_tables, bigquery_project, bigquery_dataset)
         else:
             print(f"Import format {format} not supported.")
 

datacontract/export/avro_converter.py

@@ -34,6 +34,10 @@ def to_avro_field(field, field_name):
     if field.description is not None:
         avro_field["doc"] = field.description
     avro_field["type"] = to_avro_type(field, field_name)
+    # add logical type definitions for any of the date type fields
+    if field.type in ["timestamp", "timestamp_tz", "timestamp_ntz", "date"]:
+        avro_field["logicalType"] = to_avro_logical_type(field.type)
+
     return avro_field
 
 
@@ -54,9 +58,9 @@ def to_avro_type(field: Field, field_name: str) -> str | dict:
     elif field.type in ["boolean"]:
         return "boolean"
     elif field.type in ["timestamp", "timestamp_tz"]:
-        return "string"
+        return "long"
     elif field.type in ["timestamp_ntz"]:
-        return "string"
+        return "long"
     elif field.type in ["date"]:
         return "int"
     elif field.type in ["time"]:
@@ -72,3 +76,13 @@ def to_avro_type(field: Field, field_name: str) -> str | dict:
         return "null"
     else:
         return "bytes"
+
+def to_avro_logical_type(type: str) -> str:
+    if type in ["timestamp", "timestamp_tz"]:
+        return "timestamp-millis"
+    elif type in ["timestamp_ntz"]:
+        return "local-timestamp-millis"
+    elif type in ["date"]:
+        return "date"
+    else:
+        return ""

datacontract/export/bigquery_converter.py

@@ -0,0 +1,106 @@
+import json
+import logging
+from typing import Dict, List
+
+from datacontract.model.data_contract_specification import Model, Field, Server
+from datacontract.model.exceptions import DataContractException
+
+def to_bigquery_json(model_name: str, model_value: Model, server: Server) -> str:
+    bigquery_table = to_bigquery_schema(model_name, model_value, server)
+    return json.dumps(bigquery_table, indent=2)
+
+def to_bigquery_schema(model_name: str, model_value: Model, server: Server) -> dict:
+    return {
+        "kind": "bigquery#table",
+        "tableReference": {
+            "datasetId": server.dataset,
+            "projectId": server.project,
+            "tableId": model_name
+        },
+        "description": model_value.description,
+        "schema": {
+            "fields": to_fields_array(model_value.fields)
+            }
+    }
+
+def to_fields_array(fields: Dict[str, Field]) -> List[Dict[str, Field]]:
+    bq_fields = []
+    for field_name, field in fields.items():
+        bq_fields.append(to_field(field_name, field))
+
+    return bq_fields
+
+
+def to_field(field_name: str, field: Field) -> dict:
+
+    bq_type = map_type_to_bigquery(field.type, field_name)
+    bq_field = {
+        "name": field_name,
+        "type": bq_type,
+        "mode": "REQUIRED" if field.required else "NULLABLE",
+        "description": field.description
+    }
+
+    # handle arrays
+    if field.type == 'array':
+        bq_field["mode"] = 'REPEATED'
+        if field.items.type == 'object':
+            # in case the array type is a complex object, we want to copy all its fields
+            bq_field["fields"] = to_fields_array(field.items.fields)
+        else:
+            # otherwise we make up a structure that gets us a single field of the specified type
+            bq_field["fields"] = to_fields_array({ f"{field_name}_1": Field(type=field.items.type, required=False, description="")})
+    # all of these can carry other fields
+    elif bq_type.lower() in ["record", "struct"]:
+        bq_field["fields"] = to_fields_array(field.fields)
+
+    # strings can have a maxlength
+    if bq_type.lower() == "string":
+        bq_field["maxLength"] = field.maxLength
+
+    # number types have precision and scale
+    if bq_type.lower() in ["numeric", "bignumeric"]:
+        bq_field["precision"] = field.precision
+        bq_field["scale"] = field.scale
+
+    return bq_field
+
+def map_type_to_bigquery(type_str: str, field_name: str) -> str:
+    logger = logging.getLogger(__name__)
+    if type_str.lower() in ["string", "varchar", "text"]:
+        return "STRING"
+    elif type_str == "bytes":
+        return "BYTES"
+    elif type_str.lower() in ["int", "integer"]:
+        return "INTEGER"
+    elif type_str.lower() in ["long", "bigint"]:
+        return "INT64"
+    elif type_str == "float":
+        return "FLOAT"
+    elif type_str == "boolean":
+        return "BOOLEAN"
+    elif type_str.lower() in ["timestamp", "timestamp_tz"]:
+        return "TIMESTAMP"
+    elif type_str == "date":
+        return "DATE"
+    elif type_str == "timestamp_ntz":
+        return "TIME"
+    elif type_str.lower() in ["number", "decimal", "numeric"]:
+        return "NUMERIC"
+    elif type_str == "double":
+        return "BIGNUMERIC"
+    elif type_str.lower() in ["object", "record", "array"]:
+        return "RECORD"
+    elif type_str == "struct":
+        return "STRUCT"
+    elif type_str == "null":
+        logger.info(f"Can't properly map {field_name} to bigquery Schema, as 'null' is not supported as a type. Mapping it to STRING.")
+        return "STRING"
+    else:
+        raise DataContractException(
+            type="schema",
+            result="failed",
+            name="Map datacontract type to bigquery data type",
+            reason=f"Unsupported type {type_str} in data contract definition.",
+            engine="datacontract",
+        )

datacontract/export/go_converter.py

@@ -0,0 +1,98 @@
+import datacontract.model.data_contract_specification as spec
+from typing import List
+import re
+
+
+def to_go_types(contract: spec.DataContractSpecification) -> str:
+    result = "package main\n\n"
+
+    for key in contract.models.keys():
+        go_types = generate_go_type(contract.models[key], key)
+        for go_type in go_types:
+            # print(go_type + "\n\n")
+            result += f"\n{go_type}\n"
+
+    return result
+
+
+def python_type_to_go_type(py_type) -> str:
+    match py_type:
+        case "text":
+            return "string"
+        case "timestamp":
+            return "time.Time"
+        case "long":
+            return "int64"
+        case "int":
+            return "int"
+        case "float":
+            return "float64"
+        case "boolean":
+            return "bool"
+        case _:
+            return "interface{}"
+
+
+def to_camel_case(snake_str) -> str:
+    return "".join(word.capitalize() for word in re.split(r"_|(?<!^)(?=[A-Z])", snake_str))
+
+
+def get_subtype(field_info, nested_types, type_name, camel_case_name) -> str:
+    go_type = "interface{}"
+    if field_info.fields:
+        nested_type_name = to_camel_case(f"{type_name}_{camel_case_name}")
+        nested_types[nested_type_name] = field_info.fields
+        go_type = nested_type_name
+
+    match field_info.type:
+        case "array":
+            if field_info.items:
+                item_type = get_subtype(field_info.items, nested_types, type_name, camel_case_name + "Item")
+                go_type = f"[]{item_type}"
+            else:
+                go_type = "[]interface{}"
+        case "record":
+            if field_info.fields:
+                nested_type_name = to_camel_case(f"{type_name}_{camel_case_name}")
+                nested_types[nested_type_name] = field_info.fields
+                go_type = nested_type_name
+            else:
+                go_type = "interface{}"
+        case "object":
+            pass
+        case _:
+            go_type = field_info.type
+
+    return go_type
+
+
+def generate_go_type(model, model_name) -> List[str]:
+    go_types = []
+    type_name = to_camel_case(model_name)
+    lines = [f"type {type_name} struct {{"]
+
+    nested_types = {}
+
+    for field_name, field_info in model.fields.items():
+        go_type = python_type_to_go_type(field_info.type)
+        camel_case_name = to_camel_case(field_name)
+        json_tag = field_name if field_info.required else f"{field_name},omitempty"
+        avro_tag = field_name
+
+        if go_type == "interface{}":
+            go_type = get_subtype(field_info, nested_types, type_name, camel_case_name)
+
+        go_type = go_type if field_info.required else f"*{go_type}"
+
+        lines.append(
+            f'    {camel_case_name} {go_type} `json:"{json_tag}" avro:"{avro_tag}"`  // {field_info.description}'
+        )
+    lines.append("}")
+    go_types.append("\n".join(lines))
+
+    for nested_type_name, nested_fields in nested_types.items():
+        nested_model = spec.Model(fields=nested_fields)
+        nested_go_types = generate_go_type(nested_model, nested_type_name)
+        go_types.extend(nested_go_types)
+
+    return go_types