atlas-init 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

atlas_init/cli_tf/schema_v2_api_parsing.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Iterable
+from pathlib import Path
+from queue import Queue
+from typing import ClassVar
+
+from model_lib import Entity, dump
+from pydantic import Field
+
+from atlas_init.cli_tf.schema_v2 import (
+    NewAttribute,
+    SchemaAttribute,
+    SchemaResource,
+    SchemaV2,
+    SkipAttribute,
+    parse_model,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def api_spec_text_changes(schema: SchemaV2, api_spec_parsed: OpenapiSchema) -> OpenapiSchema:
+    openapi_changes = schema.openapi_changes
+    schema_to_update = api_spec_parsed.components.get("schemas", {})
+    original_schema = {**api_spec_parsed.components.get("schemas", {})}  # copy used for iteration
+    assert isinstance(original_schema, dict), "Expected a dict @ components.schemas"
+    for prefix in openapi_changes.schema_prefix_removal:
+        for name, value in original_schema.items():
+            if name.startswith(prefix):
+                schema_to_update.pop(name)
+                name_no_prefix = name.removeprefix(prefix)
+                assert (
+                    name_no_prefix not in schema_to_update
+                ), f"removed {prefix} from {name} in schema but {name_no_prefix} already exists"
+                schema_to_update[name_no_prefix] = value
+    openapi_yaml = dump(api_spec_parsed, "yaml")
+    for prefix in openapi_changes.schema_prefix_removal:
+        pattern = re.compile(rf"{OpenapiSchema.SCHEMAS_PREFIX}(?P<prefix>{prefix})(?P<name>\w+)")
+        openapi_yaml = pattern.sub(rf"{OpenapiSchema.SCHEMAS_PREFIX}\g<name>", openapi_yaml)
+    return parse_model(openapi_yaml, t=OpenapiSchema, format="yaml")
+
+
+def parse_openapi_schema_after_modifications(schema: SchemaV2, api_spec_path: Path) -> OpenapiSchema:
+    original = parse_model(api_spec_path, t=OpenapiSchema)
+    return api_spec_text_changes(schema, original)
+
+
+class OpenapiSchema(Entity):
+    PARAMETERS_PREFIX: ClassVar[str] = "#/components/parameters/"
+    SCHEMAS_PREFIX: ClassVar[str] = "#/components/schemas/"
+
+    openapi: str
+    info: dict
+    paths: dict
+    components: dict
+    tags: list = Field(default_factory=list)
+
+    def create_method(self, path: str) -> dict | None:
+        return self.paths.get(path, {}).get("post")
+
+    def read_method(self, path: str) -> dict | None:
+        return self.paths.get(path, {}).get("get")
+
+    def method_refs(self, path: str) -> Iterable[str]:
+        for method in [self.create_method(path), self.read_method(path)]:
+            if method:
+                if req_ref := self.method_request_body_ref(method):
+                    yield req_ref
+                if resp_ref := self.method_response_ref(method):
+                    yield resp_ref
+
+    def parameter(self, ref: str) -> dict:
+        assert ref.startswith(OpenapiSchema.PARAMETERS_PREFIX)
+        parameter_name = ref.split("/")[-1]
+        param_dict = self.components["parameters"][parameter_name]
+        assert isinstance(param_dict, dict), f"Expected a dict @ {ref}"
+        return param_dict
+
+    def schema_properties(self, ref: str) -> Iterable[dict]:
+        assert ref.startswith(OpenapiSchema.SCHEMAS_PREFIX)
+        schema_name = ref.split("/")[-1]
+        schema_dict = self.components["schemas"][schema_name]
+        assert isinstance(schema_dict, dict), f"Expected a dict @ {ref}"
+        properties = schema_dict.get("properties", {})
+        assert isinstance(properties, dict), f"Expected a dict @ {ref}.properties"
+        for name, prop in properties.items():
+            assert isinstance(prop, dict), f"Expected a dict @ {ref}.properties.{name}"
+            prop["name"] = name
+            yield prop
+
+    def method_request_body_ref(self, method: dict) -> str | None:
+        request_body = method.get("requestBody", {})
+        return self._unpack_schema_ref(request_body)
+
+    def method_response_ref(self, method: dict) -> str | None:
+        responses = method.get("responses", {})
+        ok_response = responses.get("200", {})
+        return self._unpack_schema_ref(ok_response)
+
+    def _unpack_schema_ref(self, response: dict) -> str | None:
+        content = {**response.get("content", {})}  # avoid side effects
+        if not content:
+            return None
+        key, value = content.popitem()
+        if not isinstance(key, str) or not key.endswith("json"):
+            return None
+        return value.get("schema", {}).get("$ref")
+
+    def schema_ref_component(self, ref: str, attributes_skip: set[str]) -> SchemaResource:
+        schemas = self.components.get("schemas", {})
+        assert isinstance(schemas, dict), "Expected a dict @ components.schemas"
+        schema = schemas.get(ref.split("/")[-1])
+        assert isinstance(schema, dict), f"Expected a dict @ components.schemas.{ref}"
+        return self._as_schema_resource(attributes_skip, schema, ref)
+
+    def schema_ref_components(self, attributes_skip: set[str]) -> Iterable[SchemaResource]:
+        schemas = self.components.get("schemas", {})
+        assert isinstance(schemas, dict), "Expected a dict @ components.schemas"
+        for name, schema in schemas.items():
+            ref = f"#/components/schemas/{name}"
+            yield self._as_schema_resource(attributes_skip, schema, ref)
+
+    def _as_schema_resource(self, attributes_skip: set[str], schema: dict, ref: str):
+        schema_resource = SchemaResource(
+            name=ref,
+            description=schema.get("description", ""),
+            attributes_skip=attributes_skip,
+        )
+        required_names = schema.get("required", [])
+        for prop in self.schema_properties(ref):
+            if attr := parse_api_spec_param(self, prop, schema_resource):
+                attr.is_required = prop["name"] in required_names
+                schema_resource.attributes[attr.name] = attr
+        return schema_resource
+
+    def add_schema_ref(self, ref: str, ref_value: dict) -> None:
+        if ref.startswith(self.PARAMETERS_PREFIX):
+            prefix = self.PARAMETERS_PREFIX
+            parent_dict = self.components["parameters"]
+        elif ref.startswith(self.SCHEMAS_PREFIX):
+            prefix = self.SCHEMAS_PREFIX
+            parent_dict = self.components["schemas"]
+        else:
+            err_msg = f"Unknown schema_ref {ref}"
+            raise ValueError(err_msg)
+        parent_dict[ref.removeprefix(prefix)] = ref_value
+
+    def resolve_ref(self, ref: str) -> dict:
+        if ref.startswith(self.PARAMETERS_PREFIX):
+            return self.parameter(ref)
+        if ref.startswith(self.SCHEMAS_PREFIX):
+            return self.components["schemas"][ref.split("/")[-1]]
+        err_msg = f"Unknown ref {ref}"
+        raise ValueError(err_msg)
+
+
+def parse_api_spec_param(api_spec: OpenapiSchema, param: dict, resource: SchemaResource) -> SchemaAttribute | None:
+    match param:
+        case {"$ref": ref} if ref.startswith(OpenapiSchema.PARAMETERS_PREFIX):
+            param_root = api_spec.parameter(ref)
+            found_attribute = parse_api_spec_param(api_spec, param_root, resource)
+            if found_attribute:
+                found_attribute.parameter_ref = ref
+            return found_attribute
+        case {"$ref": ref, "name": name} if ref.startswith(OpenapiSchema.SCHEMAS_PREFIX):
+            # nested attribute
+            attribute = SchemaAttribute(
+                type="object",
+                name=name,
+                schema_ref=ref,
+            )
+        case {"type": "array", "items": {"$ref": ref}, "name": name}:
+            attribute = SchemaAttribute(
+                type="array",
+                name=name,
+                schema_ref=ref,
+                description=param.get("description", ""),
+                is_computed=param.get("readOnly", False),
+                is_required=param.get("required", False),
+            )
+        case {"name": name, "schema": schema}:
+            attribute = SchemaAttribute(
+                type=schema["type"],
+                name=name,
+                description=param.get("description", ""),
+                is_computed=schema.get("readOnly", False),
+                is_required=param.get("required", False),
+            )
+        case {"name": name, "type": type_}:
+            attribute = SchemaAttribute(
+                type=type_,
+                name=name,
+                description=param.get("description", ""),
+                is_computed=param.get("readOnly", False),
+                is_required=param.get("required", False),
+            )
+        case _:
+            raise NotImplementedError
+    try:
+        existing = resource.lookup_attribute(attribute.name)
+        logger.info(f"Merging attribute {attribute.name} into {existing.name}")
+        attribute = existing.merge(attribute)
+    except NewAttribute:
+        logger.info("Adding new attribute %s to %s", attribute.name, resource.name)
+    except SkipAttribute:
+        return None
+    resource.attributes[attribute.name] = attribute
+    return attribute
+
+
+def add_api_spec_info(schema: SchemaV2, api_spec_path: Path, *, minimal_refs: bool = False) -> None:
+    api_spec = parse_openapi_schema_after_modifications(schema, api_spec_path)
+    for resource in schema.resources.values():
+        for path in resource.paths:
+            create_method = api_spec.create_method(path)
+            if not create_method:
+                continue
+            for param in create_method.get("parameters", []):
+                parse_api_spec_param(api_spec, param, resource)
+            if req_ref := api_spec.method_request_body_ref(create_method):
+                for property_dict in api_spec.schema_properties(req_ref):
+                    parse_api_spec_param(api_spec, property_dict, resource)
+        for path in resource.paths:
+            read_method = api_spec.read_method(path)
+            if not read_method:
+                continue
+            for param in read_method.get("parameters", []):
+                parse_api_spec_param(api_spec, param, resource)
+            if response_ref := api_spec.method_response_ref(read_method):
+                for property_dict in api_spec.schema_properties(response_ref):
+                    parse_api_spec_param(api_spec, property_dict, resource)
+    if minimal_refs:
+        minimal_ref_resources(schema, api_spec)
+    else:
+        for resource in api_spec.schema_ref_components(schema.attributes_skip):
+            schema.ref_resources[resource.name] = resource
+
+
+def minimal_ref_resources(schema: SchemaV2, api_spec: OpenapiSchema) -> None:
+    include_refs = Queue()
+    seen_refs = set()
+    for resource in schema.resources.values():
+        for attribute in resource.attributes.values():
+            if attribute.schema_ref:
+                include_refs.put(attribute.schema_ref)
+    while not include_refs.empty():
+        ref = include_refs.get()
+        logger.info(f"Adding ref {ref}")
+        seen_refs.add(ref)
+        ref_resource = api_spec.schema_ref_component(ref, schema.attributes_skip)
+        schema.ref_resources[ref_resource.name] = ref_resource
+        for attribute in ref_resource.attributes.values():
+            if attribute.schema_ref and attribute.schema_ref not in seen_refs:
+                include_refs.put(attribute.schema_ref)
+
+
+def minimal_api_spec(schema: SchemaV2, original_api_spec_path: Path) -> OpenapiSchema:
+    schema.reset_attributes_skip()
+    full_spec = parse_openapi_schema_after_modifications(schema, original_api_spec_path)
+    add_api_spec_info(schema, original_api_spec_path, minimal_refs=True)
+    minimal_spec = OpenapiSchema(
+        openapi=full_spec.openapi,
+        info=full_spec.info,
+        paths={},
+        components={"schemas": {}, "parameters": {}},
+    )
+    include_refs = Queue()
+    seen_refs = set()
+
+    def add_from_resource(resource: SchemaResource) -> None:
+        for path in resource.paths:
+            minimal_spec.paths[path] = full_spec.paths[path]
+            for ref in full_spec.method_refs(path):
+                minimal_spec.add_schema_ref(ref, full_spec.resolve_ref(ref))
+                include_refs.put(ref)
+        for attribute in resource.attributes.values():
+            if attribute.schema_ref:
+                minimal_spec.add_schema_ref(attribute.schema_ref, full_spec.resolve_ref(attribute.schema_ref))
+                include_refs.put(attribute.schema_ref)
+            if attribute.parameter_ref:
+                minimal_spec.add_schema_ref(
+                    attribute.parameter_ref,
+                    full_spec.resolve_ref(attribute.parameter_ref),
+                )
+
+    for resource in schema.resources.values():
+        add_from_resource(resource)
+    while not include_refs.empty():
+        ref = include_refs.get()
+        if ref in seen_refs:
+            continue
+        seen_refs.add(ref)
+        ref_resource = full_spec.schema_ref_component(ref, schema.attributes_skip)
+        add_from_resource(ref_resource)
+    return minimal_spec

atlas_init/cli_tf/schema_v2_sdk.py

@@ -0,0 +1,361 @@
+from __future__ import annotations
+
+import logging
+import re
+from functools import total_ordering
+from pathlib import Path
+from queue import Queue
+from typing import NamedTuple
+
+from model_lib import Entity
+from pydantic import Field
+from zero_3rdparty.enum_utils import StrEnum
+
+from atlas_init.cli_tf.schema_v2 import (
+    SchemaAttribute,
+    SchemaResource,
+    SchemaV2,
+    add_go_variable_names,
+    as_struct_name,
+    custom_object_type_name,
+    extend_import_urls,
+    go_fmt,
+    import_lines,
+    package_name,
+)
+from atlas_init.humps import camelize, decamelize, pascalize
+
+logger = logging.getLogger(__name__)
+
+
+class GoStdlibType(StrEnum):
+    STRING = "string"
+    STRING_POINTER = "*string"
+    TIME = "time.Time"
+    TIME_POINTER = "*time.Time"
+    BOOL = "bool"
+    BOOL_POINTER = "*bool"
+    INT = "int"
+    INT_POINTER = "*int"
+    INT64 = "int64"
+    INT64_POINTER = "*int64"
+    FLOAT64 = "float64"
+    FLOAT64_POINTER = "*float64"
+    MAP_STRING = "map[string]string"
+    MAP_STRING_POINTER = "*map[string]string"
+
+
+_go_types = set(GoStdlibType)
+
+
+def is_go_type(value: str) -> bool:
+    return value in _go_types
+
+
+class GoVarName(StrEnum):
+    INPUT = "input"
+    ITEM = "item"
+    DIAGS = "diags"
+    CTX = "ctx"
+    ELEMENTS = "elements"
+    RESP = "resp"
+
+
+add_go_variable_names(list(GoVarName))
+
+
+_sdk_to_tf_funcs = {
+    ("*string", "string"): lambda sdk_ref: f"types.StringPointerValue({sdk_ref})",
+    ("string", "string"): lambda sdk_ref: f"types.StringValue({sdk_ref})",
+    (
+        "*time.Time",
+        "string",
+    ): lambda sdk_ref: f"types.StringPointerValue(conversion.TimePtrToStringPtr({sdk_ref}))",
+}
+# sdk_name -> tf_name
+_sdk_attribute_aliases = {
+    "group_id": "project_id",
+    "mongo_dbemployee_access_grant": "mongo_db_employee_access_grant",
+    "mongo_dbmajor_version": "mongo_db_major_version",
+    "mongo_dbversion": "mongo_db_version",
+}
+
+
+@total_ordering
+class SDKAttribute(Entity):
+    go_type: GoStdlibType | str
+    json_name: str
+    struct_name: str
+    nested_attributes: dict[str, SDKAttribute] = Field(default_factory=dict)
+
+    @property
+    def tf_name(self) -> str:
+        default = decamelize(self.json_name)
+        if override := _sdk_attribute_aliases.get(default):
+            return override
+        return default
+
+    @property
+    def is_nested(self) -> bool:
+        return not is_go_type(self.go_type) or bool(self.nested_attributes)
+
+    @property
+    def struct_type_name(self) -> str:
+        assert self.is_nested
+        return self.go_type.removeprefix("*").removeprefix("[]")
+
+    def list_nested_attributes(self) -> list[SDKAttribute]:
+        return [attribute for attribute in sorted(self.nested_attributes.values()) if attribute.is_nested]
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, SDKAttribute):
+            raise TypeError
+        return self.json_name < other.json_name
+
+    def as_sdk_model(self) -> SDKModel:
+        assert self.is_nested
+        return SDKModel(
+            name=self.struct_type_name,
+            attributes=self.nested_attributes,
+        )
+
+
+SDKAttribute.model_rebuild()
+
+
+class SDKModel(Entity):
+    name: str
+    attributes: dict[str, SDKAttribute] = Field(default_factory=dict)
+    example_files: list[str] = Field(default_factory=list)
+
+    def lookup_tf_name(self, tf_name: str) -> SDKAttribute:
+        for attribute in self.attributes.values():
+            if attribute.tf_name == tf_name:
+                return attribute
+        raise ValueError(f"Could not find SDK attribute for {self.name}.{tf_name}")
+
+    def list_nested_attributes(self) -> list[SDKAttribute]:
+        return [attribute for attribute in sorted(self.attributes.values()) if attribute.is_nested]
+
+
+json_attribute_line = re.compile(
+    r"^\s+(?P<struct_name>\w+)\s+(?P<go_type>[\w\*\.\[\]]+)\s+`json:\"(?P<json_name>\w+)",
+    re.M,
+)
+
+_ignored_sdk_attributes = {"href", "links"}
+
+
+def parse_sdk_model(repo_path: Path, model_name: str) -> SDKModel:
+    model_path = repo_path / "admin" / f"model_{decamelize(model_name)}.go"
+    model = SDKModel(name=model_name)
+    for match in json_attribute_line.finditer(model_path.read_text()):
+        struct_name = match.group("struct_name")
+        go_type = match.group("go_type")
+        json_name = match.group("json_name")
+        if json_name in _ignored_sdk_attributes:
+            continue
+        sdk_attribute = model.attributes[struct_name] = SDKAttribute(
+            go_type=go_type, json_name=json_name, struct_name=struct_name
+        )
+        if sdk_attribute.is_nested:
+            nested_model = parse_sdk_model(repo_path, sdk_attribute.struct_type_name)
+            sdk_attribute.nested_attributes = nested_model.attributes
+    return model
+
+
+def generate_model_go(schema: SchemaV2, resource: SchemaResource, sdk_model: SDKModel) -> str:
+    func_lines = sdk_to_tf_func(schema, resource, sdk_model)
+    import_urls = set()
+    extend_import_urls(import_urls, func_lines)
+    unformatted = "\n".join(
+        [
+            f"package {package_name(resource.name)}",
+            "",
+            *import_lines(import_urls),
+            "",
+            *func_lines,
+        ]
+    )
+    return go_fmt(resource.name, unformatted)
+
+
+def find_schema_attribute(schema: SchemaV2, parent: SchemaResource, sdk_attribute: SDKAttribute) -> SchemaAttribute:
+    err_msg = "we might need the schema to lookup sdk_attribute as an escape hatch"
+    assert schema, err_msg
+    return parent.lookup_tf_name(sdk_attribute.tf_name)
+
+
+def find_sdk_attribute(schema_attribute: SchemaAttribute, sdk_model: SDKModel) -> SDKAttribute:
+    return sdk_model.lookup_tf_name(schema_attribute.tf_name)
+
+
+class SDKAndSchemaAttribute(NamedTuple):
+    sdk_attribute: SDKAttribute
+    schema_attribute: SchemaAttribute
+
+
+def sdk_to_tf_attribute_value(
+    schema_attribute: SchemaAttribute,
+    sdk_attribute: SDKAttribute,
+    variable_name: GoVarName = GoVarName.INPUT,
+) -> str:
+    key = (sdk_attribute.go_type, schema_attribute.type)
+    if key in _sdk_to_tf_funcs:
+        return _sdk_to_tf_funcs[key](f"{variable_name}.{sdk_attribute.struct_name}")
+    raise ValueError(f"Could not find conversion function for {key}")
+
+
+def sdk_to_tf_func(schema: SchemaV2, resource: SchemaResource, sdk_model: SDKModel) -> list[str]:
+    struct_name = as_struct_name(resource.name, "")
+    lines = [
+        f"func New{struct_name}(ctx context.Context, {GoVarName.INPUT} *admin.{sdk_model.name}) (*{struct_name}, diag.Diagnostics) {{"
+    ]
+    nested_attributes, call_lines = call_nested_functions(schema, resource, sdk_model.list_nested_attributes())
+    lines.extend(call_lines)
+
+    lines.append(f"  return &{struct_name}{{")
+    lines.extend(tf_struct_create(resource, sdk_model))
+    lines.append("  }, nil")  # close return
+    lines.append("}\n")  # close function
+
+    lines.extend(process_nested_attributes(schema, nested_attributes))
+    return lines
+
+
+def process_nested_attributes(schema: SchemaV2, nested_attributes: Queue[SDKAndSchemaAttribute]) -> list[str]:
+    lines = []
+    while not nested_attributes.empty():
+        sdk_attribute, schema_attribute = nested_attributes.get()
+        lines.extend(sdk_to_tf_func_nested(schema, schema_attribute, sdk_attribute))
+    return lines
+
+
+def as_tf_struct_field_name(schema_attribute: SchemaAttribute) -> str:
+    default = pascalize(schema_attribute.name)
+    if default.endswith("Id"):
+        return default[:-2] + "ID"
+    return default
+
+
+def tf_struct_create(
+    resource: SchemaResource,
+    sdk_model: SDKModel,
+    sdk_var_name: GoVarName = GoVarName.INPUT,
+) -> list[str]:
+    lines = []
+    for schema_attribute in resource.sorted_attributes():
+        sdk_attribute = find_sdk_attribute(schema_attribute, sdk_model)
+        tf_struct_field_name = as_tf_struct_field_name(schema_attribute)
+        if sdk_attribute.is_nested:
+            var_name = camelize(sdk_attribute.struct_name)
+            lines.append(f"    {tf_struct_field_name}: {var_name},")
+        else:
+            lines.append(
+                f"    {tf_struct_field_name}: {sdk_to_tf_attribute_value(schema_attribute, sdk_attribute, sdk_var_name)},"
+            )
+    return lines
+
+
+def call_nested_functions(
+    schema: SchemaV2, resource: SchemaResource, sdk_attributes: list[SDKAttribute]
+) -> tuple[Queue[SDKAndSchemaAttribute], list[str]]:
+    nested_attributes: Queue[SDKAndSchemaAttribute] = Queue()
+    lines = []
+    for sdk_attribute in sdk_attributes:
+        schema_attribute = find_schema_attribute(schema, resource, sdk_attribute)
+        var_name = camelize(sdk_attribute.struct_name)
+        lines.append(
+            f"  {var_name} := New{custom_object_type_name(schema_attribute)}(ctx, {GoVarName.INPUT}.{sdk_attribute.struct_name}, {GoVarName.DIAGS})"
+        )
+        nested_attributes.put(SDKAndSchemaAttribute(sdk_attribute, schema_attribute))
+    if lines:
+        lines.insert(0, "  diags := &diag.Diagnostics{}")
+        lines.extend(
+            [
+                "  if diags.HasError() {",
+                "    return nil, *diags",
+                "  }",
+            ]
+        )
+    return nested_attributes, lines
+
+
+_used_refs: set[str] = set()
+
+
+def sdk_to_tf_func_nested(
+    schema: SchemaV2, schema_attribute: SchemaAttribute, sdk_attribute: SDKAttribute
+) -> list[str]:
+    if schema_attribute.schema_ref in _used_refs:
+        return []
+    _used_refs.add(schema_attribute.schema_ref)
+    is_object = schema_attribute.type == "object"
+    if is_object:
+        return sdk_to_tf_func_object(schema, schema_attribute, sdk_attribute)
+    return sdk_to_tf_func_list(schema, schema_attribute, sdk_attribute)
+
+
+def sdk_to_tf_func_object(
+    schema: SchemaV2, schema_attribute: SchemaAttribute, sdk_attribute: SDKAttribute
+) -> list[str]:
+    object_type_name = custom_object_type_name(schema_attribute)
+    lines: list[str] = [
+        f"func New{object_type_name}(ctx context.Context, {GoVarName.INPUT} *admin.{sdk_attribute.struct_type_name}, diags *diag.Diagnostics) types.Object {{",
+        f"  var nilPointer *admin.{sdk_attribute.struct_type_name}",
+        f"  if {GoVarName.INPUT} == nilPointer {{",
+        f"    return types.ObjectNull({object_type_name}.AttrTypes)",
+        "  }",
+    ]
+    resource = schema.ref_resource(schema_attribute.schema_ref, use_name=schema_attribute.schema_ref_name)
+    nested_attributes, call_lines = call_nested_functions(schema, resource, sdk_attribute.list_nested_attributes())
+    lines.extend(call_lines)
+    struct_name = as_struct_name(resource.name, "")
+
+    lines.extend(
+        [
+            f"  tfModel := {struct_name}{{",
+            *tf_struct_create(resource, sdk_attribute.as_sdk_model()),
+            "  }",
+            f"  objType, diagsLocal := types.ObjectValueFrom(ctx, {object_type_name}.AttrTypes, tfModel)",
+            f"  {GoVarName.DIAGS}.Append(diagsLocal...)",
+            "  return objType",
+            "}\n",
+        ]
+    )
+    lines.extend(process_nested_attributes(schema, nested_attributes))
+    return lines
+
+
+def sdk_to_tf_func_list(schema: SchemaV2, schema_attribute: SchemaAttribute, sdk_attribute: SDKAttribute) -> list[str]:
+    list_object_type = custom_object_type_name(schema_attribute)
+    nested_resource = schema.ref_resource(schema_attribute.schema_ref, use_name=schema_attribute.schema_ref_name)
+    lines: list[str] = [
+        f"func New{list_object_type}(ctx context.Context, {GoVarName.INPUT} *[]admin.{sdk_attribute.struct_type_name}, diags *diag.Diagnostics) types.List {{",
+        f"  var nilPointer *[]admin.{sdk_attribute.struct_type_name}",
+        f"  if {GoVarName.INPUT} == nilPointer {{",
+        f"    return types.ListNull({list_object_type})",
+        "  }",
+    ]
+    struct_name = as_struct_name(nested_resource.name, "")
+    if nested_list_attributes := [attr for attr in sdk_attribute.list_nested_attributes() if attr.is_nested]:
+        logger.warning(f"Nested list attributes: {nested_list_attributes}, are not supported yet.")
+    lines.extend(
+        [
+            f"  tfModels := make([]{struct_name}, len(*{GoVarName.INPUT}))",
+            f"  for i, item := range *{GoVarName.INPUT} {{",
+            f"    tfModels[i] = {struct_name}{{",
+            *tf_struct_create(
+                nested_resource,
+                sdk_attribute.as_sdk_model(),
+                sdk_var_name=GoVarName.ITEM,
+            ),
+            "    }",
+            "  }",
+            f"  listType, diagsLocal := types.ListValueFrom(ctx, {list_object_type}, tfModels)",
+            f"  {GoVarName.DIAGS}.Append(diagsLocal...)",
+            "  return listType",
+            "}\n",
+        ]
+    )
+    return lines