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

atlas_init/cli_tf/schema.py

@@ -1,10 +1,14 @@
 import logging
+from collections.abc import Iterable
+from functools import singledispatch
 from pathlib import Path
-from typing import Literal
+from typing import Annotated, Literal, NamedTuple
 
 import pydantic
 import requests
 from model_lib import Entity, dump, field_names, parse_model
+from zero_3rdparty import dict_nested
+from zero_3rdparty.enum_utils import StrEnum
 
 logger = logging.getLogger(__name__)
 
@@ -23,10 +27,53 @@ class ProviderSpecAttribute(Entity):
         return self.model_dump(exclude_none=True)
 
 
+class IgnoreNested(Entity):
+    type: Literal["ignore_nested"] = "ignore_nested"
+    path: str
+
+    @property
+    def use_wildcard(self) -> bool:
+        return "*" in self.path
+
+
+class RenameAttribute(Entity):
+    type: Literal["rename_attribute"] = "rename_attribute"
+    from_name: str
+    to_name: str
+
+
+class ComputedOptionalRequired(StrEnum):
+    COMPUTED_OPTIONAL = "computed_optional"
+    REQUIRED = "required"
+    COMPUTED = "computed"
+    OPTIONAL = "optional"
+
+
+class ChangeAttributeType(Entity):
+    type: Literal["change_attribute_type"] = "change_attribute_type"
+    path: str
+    new_value: ComputedOptionalRequired
+
+    @classmethod
+    def read_value(cls, attribute_dict: dict) -> str:
+        return attribute_dict["string"]["computed_optional_required"]
+
+    def update_value(self, attribute_dict: dict) -> None:
+        attribute_dict["string"]["computed_optional_required"] = self.new_value
+
+
+class SkipValidators(Entity):
+    type: Literal["skip_validators"] = "skip_validators"
+
+
+Extension = Annotated[IgnoreNested | RenameAttribute | ChangeAttributeType | SkipValidators, pydantic.Field("type")]
+
+
 class TFResource(Entity):
     model_config = pydantic.ConfigDict(extra="allow")
     name: str
-    provider_spec_attributes: list[ProviderSpecAttribute]
+    extensions: list[Extension] = pydantic.Field(default_factory=list)
+    provider_spec_attributes: list[ProviderSpecAttribute] = pydantic.Field(default_factory=list)
 
     def dump_generator_config(self) -> dict:
         names = field_names(self)
@@ -35,6 +82,7 @@ class TFResource(Entity):
 
 class PyTerraformSchema(Entity):
     resources: list[TFResource]
+    data_sources: list[TFResource] = pydantic.Field(default_factory=list)
 
     def resource(self, resource: str) -> TFResource:
         return next(r for r in self.resources if r.name == resource)
@@ -48,27 +96,89 @@ def dump_generator_config(schema: PyTerraformSchema) -> str:
     resources = {}
     for resource in schema.resources:
         resources[resource.name] = resource.dump_generator_config()
+    data_sources = {ds.name: ds.dump_generator_config() for ds in schema.data_sources}
     generator_config = {
         "provider": {"name": "mongodbatlas"},
         "resources": resources,
+        "data_sources": data_sources,
     }
     return dump(generator_config, "yaml")
 
 
+class AttributeTuple(NamedTuple):
+    name: str
+    path: str
+    attribute_dict: dict
+
+    @property
+    def attribute_path(self) -> str:
+        return f"{self.path}.{self.name}" if self.path else self.name
+
+
 class ProviderCodeSpec(Entity):
     model_config = pydantic.ConfigDict(extra="allow")
     provider: dict
     resources: list[dict]
+    datasources: list[dict] = pydantic.Field(default_factory=list)
     version: str
 
-    def resource_attributes(self, name: str) -> list:
-        for r in self.resources:
-            if r["name"] == name:
-                return r["schema"]["attributes"]
-        raise ValueError(f"resource: {name} not found!")
+    def root_dict(self, name: str, is_datasource: bool = False) -> dict:  # noqa: FBT002
+        resources = self.datasources if is_datasource else self.resources
+        root_value = next((r for r in resources if r["name"] == name), None)
+        if root_value is None:
+            raise ValueError(f"{self.root_name(name, is_datasource)} not found!")
+        return root_value
+
+    def schema_attributes(self, name: str, is_datasource: bool = False) -> list:  # noqa: FBT002
+        root_dict = self.root_dict(name, is_datasource)
+        return root_dict["schema"]["attributes"]
+
+    def _type_name(self, is_datasource: bool):
+        return "datasource" if is_datasource else "resource"
 
-    def resource_attribute_names(self, name: str) -> list[str]:
-        return [a["name"] for a in self.resource_attributes(name)]
+    def root_name(self, name: str, is_datasource: bool):
+        return f"{self._type_name(is_datasource)}.{name}"
+
+    def attribute_names(self, name: str, is_datasource: bool = False) -> list[str]:  # noqa: FBT002
+        return [a["name"] for a in self.schema_attributes(name, is_datasource=is_datasource)]
+
+    def iter_all_attributes(self, name: str, is_datasource: bool = False) -> Iterable[AttributeTuple]:  # noqa: FBT002
+        for attribute in self.schema_attributes(name=name, is_datasource=is_datasource):
+            yield AttributeTuple(attribute["name"], "", attribute)
+        yield from self.iter_nested_attributes(name, is_datasource=is_datasource)
+
+    def iter_nested_attributes(self, name: str, is_datasource: bool = False) -> Iterable[AttributeTuple]:  # noqa: FBT002
+        for i, attribute in enumerate(self.schema_attributes(name=name, is_datasource=is_datasource)):
+            for path, attr_dict in dict_nested.iter_nested_key_values(
+                attribute, type_filter=dict, include_list_indexes=True
+            ):
+                full_path = f"[{i}].{path}"
+                if name := attr_dict.get("name", ""):
+                    yield AttributeTuple(name, full_path, attr_dict)
+
+    def remove_nested_attribute(self, name: str, path: str, is_datasource: bool = False) -> None:  # noqa: FBT002
+        root_name = self.root_name(name, is_datasource)
+        logger.info(f"will remove attribute from {root_name} with path: {path}")
+        root_attributes = self.root_dict(name, is_datasource)
+        full_path = f"schema.attributes.{path}"
+        popped = dict_nested.pop_nested(root_attributes, full_path, "")
+        if popped == "":
+            raise ValueError(f"failed to remove attribute from resource {name} with path: {full_path}")
+        assert isinstance(popped, dict), f"expected removed attribute to be a dict, got: {popped}"
+        logger.info(f"removal ok, attribute_name: '{root_name}.{popped.get('name')}'")
+
+    def read_attribute(self, name: str, path: str, *, is_datasource: bool = False) -> dict:
+        if "." not in path:
+            attribute_dict = next((a for a in self.schema_attributes(name, is_datasource) if a["name"] == path), None)
+        else:
+            root_dict = self.root_dict(name, is_datasource)
+            attribute_dict = dict_nested.read_nested_or_none(root_dict, f"schema.attributes.{path}")
+        if attribute_dict is None:
+            raise ValueError(f"attribute {path} not found in {self.root_name(name, is_datasource)}")
+        assert isinstance(
+            attribute_dict, dict
+        ), f"expected attribute to be a dict, got: {attribute_dict} @ {path} for resource={name}"
+        return attribute_dict
 
 
 def update_provider_code_spec(schema: PyTerraformSchema, provider_code_spec_path: Path) -> str:
@@ -76,21 +186,115 @@ def update_provider_code_spec(schema: PyTerraformSchema, provider_code_spec_path
     for resource in schema.resources:
         resource_name = resource.name
         if extra_spec_attributes := resource.provider_spec_attributes:
-            resource_attributes = spec.resource_attributes(resource_name)
-            existing_names = spec.resource_attribute_names(resource_name)
-            new_names = [extra.name for extra in extra_spec_attributes]
-            if both := set(existing_names) & set(new_names):
-                raise ValueError(f"resource: {resource_name}, has already: {both} attributes")
-            resource_attributes.extend(extra.dump_provider_code_spec() for extra in extra_spec_attributes)
+            add_explicit_attributes(spec, resource_name, extra_spec_attributes)
+        for extension in resource.extensions:
+            apply_extension(extension, spec, resource_name)
+    for data_source in schema.data_sources:
+        data_source_name = data_source.name
+        if extra_spec_attributes := data_source.provider_spec_attributes:
+            add_explicit_attributes(spec, data_source_name, extra_spec_attributes, is_datasource=True)
+        for extension in data_source.extensions:
+            apply_extension(extension, spec, data_source_name, is_datasource=True)
     return dump(spec, "json")
 
 
+def add_explicit_attributes(
+    spec: ProviderCodeSpec, name: str, extra_spec_attributes: list[ProviderSpecAttribute], *, is_datasource=False
+):
+    resource_attributes = spec.schema_attributes(name, is_datasource=is_datasource)
+    existing_names = spec.attribute_names(name, is_datasource=is_datasource)
+    new_names = [extra.name for extra in extra_spec_attributes]
+    if both := set(existing_names) & set(new_names):
+        raise ValueError(f"resource: {name}, has already: {both} attributes")
+    resource_attributes.extend(extra.dump_provider_code_spec() for extra in extra_spec_attributes)
+
+
+@singledispatch
+def apply_extension(extension: object, spec: ProviderCodeSpec, resource_name: str, *, is_datasource: bool = False):  # noqa: ARG001
+    raise NotImplementedError(f"unsupported extension: {extension!r}")
+
+
+@apply_extension.register  # type: ignore
+def _ignore_nested(extension: IgnoreNested, spec: ProviderCodeSpec, resource_name: str, *, is_datasource: bool = False):
+    if extension.use_wildcard:
+        name_to_remove = extension.path.removeprefix("*.")
+        assert "*" not in name_to_remove, f"only prefix *. is allowed for wildcard in path {extension.path}"
+        found_paths = [
+            path
+            for name, path, attribute_dict in spec.iter_nested_attributes(resource_name, is_datasource=is_datasource)
+            if name == name_to_remove
+        ]
+        while found_paths:
+            next_to_remove = found_paths.pop()
+            spec.remove_nested_attribute(resource_name, next_to_remove, is_datasource=is_datasource)
+            found_paths = [
+                path
+                for name, path, attribute_dict in spec.iter_nested_attributes(
+                    resource_name, is_datasource=is_datasource
+                )
+                if name == name_to_remove
+            ]
+    else:
+        err_msg = "only wildcard path is supported"
+        raise NotImplementedError(err_msg)
+
+
+@apply_extension.register  # type: ignore
+def _rename_attribute(
+    extension: RenameAttribute, spec: ProviderCodeSpec, resource_name: str, *, is_datasource: bool = False
+):
+    for attribute_dict in spec.schema_attributes(resource_name, is_datasource=is_datasource):
+        if attribute_dict.get("name") == extension.from_name:
+            logger.info(
+                f"renaming attribute for {spec.root_name(resource_name, is_datasource)}: {extension.from_name} -> {extension.to_name}"
+            )
+            attribute_dict["name"] = extension.to_name
+
+
+@apply_extension.register  # type: ignore
+def _change_attribute_type(
+    extension: ChangeAttributeType, spec: ProviderCodeSpec, resource_name: str, *, is_datasource: bool = False
+):
+    attribute_dict = spec.read_attribute(resource_name, extension.path, is_datasource=is_datasource)
+    old_value = extension.read_value(attribute_dict)
+    if old_value == extension.new_value:
+        logger.info(
+            f"no change for '{spec.root_name(resource_name, is_datasource)}': {extension.path} -> {extension.new_value}"
+        )
+        return
+
+    logger.info(
+        f"changing attribute type for '{spec.root_name(resource_name, is_datasource)}.{extension.path}': {old_value} -> {extension.new_value}"
+    )
+    extension.update_value(attribute_dict)
+
+
+@apply_extension.register  # type: ignore
+def _skip_validators(_: SkipValidators, spec: ProviderCodeSpec, resource_name: str, *, is_datasource: bool = False):
+    for attr_tuple in spec.iter_all_attributes(resource_name, is_datasource=is_datasource):
+        attribute_dict = attr_tuple.attribute_dict
+        paths_to_pop = [
+            f"{path}.validators"
+            for path, nested_dict in dict_nested.iter_nested_key_values(attribute_dict, type_filter=dict)
+            if "validators" in nested_dict
+        ]
+        if paths_to_pop:
+            logger.info(f"popping validators from '{attr_tuple.attribute_path}'")
+        for path in paths_to_pop:
+            dict_nested.pop_nested(attribute_dict, path)
+
+
 # reusing url from terraform-provider-mongodbatlas/scripts/schema-scaffold.sh
 ADMIN_API_URL = "https://raw.githubusercontent.com/mongodb/atlas-sdk-go/main/openapi/atlas-api-transformed.yaml"
 
 
-def download_admin_api(dest: Path) -> None:
-    logger.info(f"downloading admin api to {dest} from {ADMIN_API_URL}")
-    response = requests.get(ADMIN_API_URL, timeout=10)
+def admin_api_url(branch: str) -> str:
+    return ADMIN_API_URL.replace("/main/", f"/{branch}/")
+
+
+def download_admin_api(dest: Path, branch: str = "main") -> None:
+    url = admin_api_url(branch)
+    logger.info(f"downloading admin api to {dest} from {url}")
+    response = requests.get(url, timeout=10)
     response.raise_for_status()
     dest.write_bytes(response.content)

atlas_init/cli_tf/schema_go_parser.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import logging
+import re
+from collections import defaultdict
+from typing import NamedTuple
+
+from model_lib import Entity
+from pydantic import Field
+
+from atlas_init.cli_tf.schema_table_models import (
+    AttrRefLine,
+    FuncCallLine,
+    TFSchemaAttribute,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def parse_attribute_ref(
+    name: str, rest: str, go_code: str, code_lines: list[str], ref_line_nr: int
+) -> TFSchemaAttribute | None:
+    attr_ref = rest.lstrip("&").rstrip(",").strip()
+    if not attr_ref.isidentifier():
+        return None
+    try:
+        _instantiate_regex = re.compile(rf"{attr_ref}\s=\sschema\.\w+\{{$", re.M)
+    except re.error:
+        return None
+    instantiate_match = _instantiate_regex.search(go_code)
+    if not instantiate_match:
+        return None
+    line_start_nr = go_code[: instantiate_match.start()].count("\n") + 1
+    line_start = code_lines[line_start_nr]
+    attribute = parse_attribute_lines(code_lines, line_start_nr, line_start, name, is_attr_ref=True)
+    attribute.attr_ref_line = AttrRefLine(line_nr=ref_line_nr, attr_ref=attr_ref)
+    return attribute
+
+
+def parse_func_call_line(
+    name: str, rest: str, lines: list[str], go_code: str, call_line_nr: int
+) -> TFSchemaAttribute | None:
+    func_def_line = _function_line(rest, go_code)
+    if not func_def_line:
+        return None
+    func_name, args = rest.split("(", maxsplit=1)
+    func_start, func_end = _func_lines(name, lines, func_def_line)
+    call = FuncCallLine(
+        call_line_nr=call_line_nr,
+        func_name=func_name.strip(),
+        args=args.removesuffix("),").strip(),
+        func_line_start=func_start,
+        func_line_end=func_end,
+    )
+    return TFSchemaAttribute(
+        name=name,
+        lines=lines[func_start:func_end],
+        line_start=func_start,
+        line_end=func_end,
+        func_call=call,
+        indent="\t",
+    )
+
+
+def _func_lines(name: str, lines: list[str], func_def_line: str) -> tuple[int, int]:
+    start_line = lines.index(func_def_line)
+    for line_nr, line in enumerate(lines[start_line + 1 :], start=start_line + 1):
+        if line.rstrip() == "}":
+            return start_line, line_nr
+    raise ValueError(f"no end line found for {name} on line {start_line}: {func_def_line}")
+
+
+def _function_line(rest: str, go_code: str) -> str:
+    function_name = rest.split("(")[0].strip()
+    pattern = re.compile(rf"func {function_name}\(.*\) \*?schema\.\w+ \{{$", re.M)
+    match = pattern.search(go_code)
+    if not match:
+        return ""
+    return go_code[match.start() : match.end()]
+
+
+def parse_attribute_lines(
+    lines: list[str],
+    line_nr: int,
+    line: str,
+    name: str,
+    *,
+    is_attr_ref: bool = False,
+) -> TFSchemaAttribute:
+    indents = len(line) - len(line.lstrip())
+    indent = indents * "\t"
+    end_line = f"{indent}}}" if is_attr_ref else f"{indent}}},"
+    for extra_lines, next_line in enumerate(lines[line_nr + 1 :], start=1):
+        if next_line == end_line:
+            return TFSchemaAttribute(
+                name=name,
+                lines=lines[line_nr : line_nr + extra_lines],
+                line_start=line_nr,
+                line_end=line_nr + extra_lines,
+                indent=indent,
+            )
+    raise ValueError(f"no end line found for {name}, starting on line {line_nr}")
+
+
+_schema_attribute_go_regex = re.compile(
+    r'^\s+"(?P<name>[^"]+)":\s(?P<rest>.+)$',
+)
+
+
+def find_attributes(go_code: str) -> list[TFSchemaAttribute]:
+    lines = ["", *go_code.splitlines()]  # support line_nr indexing
+    attributes = []
+    for line_nr, line in enumerate(lines):
+        match = _schema_attribute_go_regex.match(line)
+        if not match:
+            continue
+        name = match.group("name")
+        rest = match.group("rest")
+        if rest.endswith("),"):
+            if attr := parse_func_call_line(name, rest, lines, go_code, line_nr):
+                attributes.append(attr)
+        elif attr := parse_attribute_ref(name, rest, go_code, lines, line_nr):
+            attributes.append(attr)
+        else:
+            try:
+                attr = parse_attribute_lines(lines, line_nr, line, name)
+            except ValueError as e:
+                logger.warning(e)
+                continue
+            if not attr.type:
+                continue
+            attributes.append(attr)
+    set_attribute_paths(attributes)
+    return attributes
+
+
+class StartEnd(NamedTuple):
+    start: int
+    end: int
+    name: str
+    func_call_line: FuncCallLine | None
+
+    def has_parent(self, other: StartEnd) -> bool:
+        if self.name == other.name:
+            return False
+        if func_call := self.func_call_line:
+            func_call_line = func_call.call_line_nr
+            return other.start < func_call_line < other.end
+        return self.start > other.start and self.end < other.end
+
+
+def set_attribute_paths(attributes: list[TFSchemaAttribute]) -> list[TFSchemaAttribute]:
+    start_stops = [StartEnd(a.line_start, a.line_end, a.name, a.func_call) for a in attributes]
+    overlaps = [
+        (attribute, [other for other in start_stops if start_stop.has_parent(other)])
+        for attribute, start_stop in zip(attributes, start_stops, strict=False)
+    ]
+    for attribute, others in overlaps:
+        if not others:
+            attribute.attribute_path = attribute.name
+            continue
+        overlaps = defaultdict(list)
+        for other in others:
+            overlaps[(other.start, other.end)].append(other.name)
+        paths = []
+        for names in overlaps.values():
+            if len(names) == 1:
+                paths.append(names[0])
+            else:
+                paths.append(f"({'|'.join(names)})")
+        paths.append(attribute.name)
+        attribute.attribute_path = ".".join(paths)
+    return attributes
+
+
+class GoSchemaFunc(Entity):
+    name: str
+    line_start: int
+    line_end: int
+    call_attributes: list[TFSchemaAttribute] = Field(default_factory=list)
+    attributes: list[TFSchemaAttribute] = Field(default_factory=list)
+
+    @property
+    def attribute_names(self) -> set[str]:
+        return {a.name for a in self.call_attributes}
+
+    @property
+    def attribute_paths(self) -> str:
+        paths = set()
+        for a in self.call_attributes:
+            path = ".".join(a.parent_attribute_names())
+            paths.add(path)
+        return f"({'|'.join(paths)})" if len(paths) > 1 else paths.pop()
+
+    def contains_attribute(self, attribute: TFSchemaAttribute) -> bool:
+        names = self.attribute_names
+        return any(parent_attribute in names for parent_attribute in attribute.parent_attribute_names())
+
+
+def find_schema_functions(attributes: list[TFSchemaAttribute]) -> list[GoSchemaFunc]:
+    function_call_attributes = defaultdict(list)
+    for a in attributes:
+        if a.is_function_call:
+            call = a.func_call
+            assert call
+            function_call_attributes[call.func_name].append(a)
+    root_function = GoSchemaFunc(name="", line_start=0, line_end=0)
+    functions: list[GoSchemaFunc] = [
+        GoSchemaFunc(
+            name=name,
+            line_start=func_attributes[0].line_start,
+            line_end=func_attributes[0].line_end,
+            call_attributes=func_attributes,
+        )
+        for name, func_attributes in function_call_attributes.items()
+    ]
+    for attribute in attributes:
+        if match_functions := [func for func in functions if func.contains_attribute(attribute)]:
+            func_names = [func.name for func in match_functions]
+            err_msg = f"multiple functions found for {attribute.name}, {func_names}"
+            assert len(match_functions) == 1, err_msg
+            function = match_functions[0]
+            function.attributes.append(attribute)
+            attribute.absolute_attribute_path = f"{function.attribute_paths}.{attribute.attribute_path}".lstrip(".")
+        else:
+            root_function.attributes.append(attribute)
+            attribute.absolute_attribute_path = attribute.attribute_path
+    return [root_function, *functions]
+
+
+def parse_schema_functions(
+    go_code: str,
+) -> tuple[list[TFSchemaAttribute], list[GoSchemaFunc]]:
+    attributes = find_attributes(go_code)
+    functions = find_schema_functions(attributes)
+    return sorted(attributes), functions

atlas_init/cli_tf/schema_table.py

@@ -0,0 +1,150 @@
+# import typer
+
+
+from collections import defaultdict
+from collections.abc import Iterable
+from functools import total_ordering
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+from model_lib import Entity, Event
+from pydantic import Field, model_validator
+from zero_3rdparty import iter_utils
+
+from atlas_init.cli_tf.schema_go_parser import parse_schema_functions
+from atlas_init.cli_tf.schema_table_models import TFSchemaAttribute, TFSchemaTableColumn
+from atlas_init.settings.path import default_factory_cwd
+
+
+def default_table_columns() -> list[TFSchemaTableColumn]:
+    return [TFSchemaTableColumn.Computability]
+
+
+def file_name_path(file: str) -> tuple[str, Path]:
+    if ":" in file:
+        file, path = file.split(":", 1)
+        return file, Path(path)
+    path = Path(file)
+    return f"{path.parent.name}/{path.stem}"[:20], path
+
+
+@total_ordering
+class TFSchemaSrc(Event):
+    name: str
+    file_path: Path | None = None
+    url: str = ""
+
+    @model_validator(mode="after")
+    def validate(self):
+        assert self.file_path or self.url, "must provide file path or url"
+        if self.file_path:
+            assert self.file_path.exists(), f"file does not exist for {self.name}: {self.file_path}"
+        return self
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, TFSchemaSrc):
+            raise TypeError
+        return self.name < other.name
+
+    def go_code(self) -> str:
+        if path := self.file_path:
+            return path.read_text()
+        raise NotImplementedError
+
+
+TableOutputFormats: TypeAlias = Literal["md"]
+
+
+class TFSchemaTableInput(Entity):
+    sources: list[TFSchemaSrc] = Field(default_factory=list)
+    output_format: TableOutputFormats = "md"
+    output_path: Path = Field(default_factory=default_factory_cwd("schema_table.md"))
+    columns: list[TFSchemaTableColumn] = Field(default_factory=default_table_columns)
+    explode_rows: bool = False
+
+    @model_validator(mode="after")
+    def validate(self):
+        assert self.columns, "must provide at least 1 column"
+        self.columns = sorted(self.columns)
+        assert self.sources, "must provide at least 1 source"
+        self.sources = sorted(self.sources)
+        assert len(self.sources) == len(set(self.sources)), f"duplicate source names: {self.source_names}"
+        return self
+
+    @property
+    def source_names(self) -> list[str]:
+        return [s.name for s in self.sources]
+
+    def headers(self) -> list[str]:
+        return ["Attribute Name"] + [f"{name}-{col}" for name in self.source_names for col in self.columns]
+
+
+@total_ordering
+class TFSchemaTableData(Event):
+    source: TFSchemaSrc
+    schema_path: str = ""  # e.g., "" is root, "replication_specs.region_config"
+    attributes: list[TFSchemaAttribute] = Field(default_factory=list)
+
+    @property
+    def id(self) -> str:
+        return f"{self.schema_path}:{self.source.name}"
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, TFSchemaTableData):
+            raise TypeError
+        return self.id < other.id
+
+
+def sorted_schema_paths(schema_paths: Iterable[str]) -> list[str]:
+    return sorted(schema_paths, key=lambda x: (x.count("."), x.split(".")[-1]))
+
+
+class RawTable(Event):
+    columns: list[str]
+    rows: list[list[str]]
+
+
+def merge_tables(config: TFSchemaTableInput, schema_path: str, tables: list[TFSchemaTableData]) -> RawTable:
+    if schema_path != "":
+        raise NotImplementedError
+    columns = config.headers()
+    if len(tables) > 1:
+        err_msg = "only 1 table per schema path supported"
+        raise NotImplementedError(err_msg)
+    table = tables[0]
+    rows = [[attr.absolute_attribute_path, *attr.row(config.columns)] for attr in table.attributes]
+    return RawTable(columns=columns, rows=rows)
+
+
+def format_table(table: RawTable, table_format: TableOutputFormats) -> list[str]:
+    # sourcery skip: merge-list-append
+    assert table_format == "md", "only markdown format supported"
+    lines = []
+    lines.append("|".join(table.columns))
+    lines.append("|".join(["---"] * len(table.columns)))
+    lines.extend("|".join(row) for row in table.rows)
+    return lines
+
+
+def explode_attributes(attributes: list[TFSchemaAttribute]) -> list[TFSchemaAttribute]:
+    return sorted(iter_utils.flat_map(attr.explode() for attr in attributes))
+
+
+def schema_table(config: TFSchemaTableInput) -> str:
+    path_tables: dict[str, list[TFSchemaTableData]] = defaultdict(list)
+    for source in config.sources:
+        go_code = source.go_code()
+        attributes, functions = parse_schema_functions(go_code)
+        if config.explode_rows:
+            attributes = explode_attributes(attributes)
+        schema_path = ""  # using only root for now
+        path_tables[schema_path].append(
+            TFSchemaTableData(source=source, attributes=attributes, schema_path=schema_path)
+        )
+    output_lines = []
+    for schema_path in sorted_schema_paths(path_tables.keys()):
+        tables = path_tables[schema_path]
+        table = merge_tables(config, schema_path, tables)
+        output_lines.extend(["", f"## {schema_path or 'Root'}", ""])
+        output_lines.extend(format_table(table, table_format=config.output_format))
+    return "\n".join(output_lines)