erdify 0.4.1__tar.gz → 0.4.2__tar.gz

{erdify-0.4.1 → erdify-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: erdify
-Version: 0.4.1
+Version: 0.4.2
 Summary: Generate PlantUML ERD diagrams from SQLModel, SQLAlchemy, Pydantic and dataclass models
 Keywords: sqlmodel,sqlalchemy,pydantic,dataclass,erd,plantuml,diagram,database,erdify
 Author: devsuit GmbH, Fabian Clemenz
@@ -49,7 +49,7 @@ Description-Content-Type: text/markdown
 - 🎚️ **Source Filtering** - Restrict the diagram to specific model kinds with `--sources` (e.g. ORM tables only)
 - 📦 **Inheritance Support** - Correctly resolves fields from base classes and mixins
 - 🏷️ **Enum Support** - Includes enum definitions in the diagram
-- 🔄 **Link Table Detection** - Identifies many-to-many relationship tables
+- 🔄 **Link Table Detection** - Identifies many-to-many association tables structurally (two FK columns that form the primary key), regardless of class name, including SQLAlchemy Core `Table()` association tables referenced via `relationship(secondary=...)`
 - 🎨 **Beautiful Output** - Clean, readable PlantUML with proper styling
 
 ## 📦 Installation

{erdify-0.4.1 → erdify-0.4.2}/README.md

@@ -24,7 +24,7 @@
 - 🎚️ **Source Filtering** - Restrict the diagram to specific model kinds with `--sources` (e.g. ORM tables only)
 - 📦 **Inheritance Support** - Correctly resolves fields from base classes and mixins
 - 🏷️ **Enum Support** - Includes enum definitions in the diagram
-- 🔄 **Link Table Detection** - Identifies many-to-many relationship tables
+- 🔄 **Link Table Detection** - Identifies many-to-many association tables structurally (two FK columns that form the primary key), regardless of class name, including SQLAlchemy Core `Table()` association tables referenced via `relationship(secondary=...)`
 - 🎨 **Beautiful Output** - Clean, readable PlantUML with proper styling
 
 ## 📦 Installation

{erdify-0.4.1 → erdify-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "erdify"
-version = "0.4.1"
+version = "0.4.2"
 description = "Generate PlantUML ERD diagrams from SQLModel, SQLAlchemy, Pydantic and dataclass models"
 readme = "README.md"
 license = "MIT"

{erdify-0.4.1 → erdify-0.4.2}/src/erdify/generator.py

@@ -174,6 +174,11 @@ class PlantUMLGenerator:
                 default_val = default_val.split(".")[-1]
             default = f" = {default_val}"
 
+        # Omit the type suffix entirely when the type is unknown (e.g. an
+        # untyped Core Column on a synthesized link table) to avoid a dangling ":".
+        if not type_str:
+            return f"{prefix}({field.name})"
+
         return f"{prefix}({field.name}) : {type_str}{nullable}{default}"
 
     def _build_link_table_map(self) -> Dict[Tuple[str, str], str]:

{erdify-0.4.1 → erdify-0.4.2}/src/erdify/parser.py

@@ -5,7 +5,7 @@ import re
 import sys
 from fnmatch import fnmatchcase
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, TypeGuard
 
 from .config import EntityInfo, EnumInfo, FieldInfo
 
@@ -62,6 +62,10 @@ class ASTDatabaseParser:
             if source is not None and (self.sources is None or source in self.sources):
                 self._parse_table_class(class_node, source)
 
+        # Synthesize link entities from module-level Core Table(...) association
+        # tables referenced by relationship(secondary=...) (#34).
+        self._parse_core_association_tables()
+
         # Third pass: apply exclude patterns
         self._apply_exclude_patterns()
 
@@ -230,9 +234,6 @@ class ASTDatabaseParser:
         if not table_name:
             table_name = self._to_snake_case(class_node.name)
 
-        # Check if link table
-        is_link_table = "Link" in class_node.name
-
         # Get base classes
         base_classes: List[str] = []
         for base in class_node.bases:
@@ -242,7 +243,6 @@ class ASTDatabaseParser:
         entity = EntityInfo(
             name=class_node.name,
             table_name=table_name,
-            is_link_table=is_link_table,
             base_classes=base_classes,
             source=source,
         )
@@ -259,8 +259,121 @@ class ASTDatabaseParser:
         entity.fields = list(fields_dict.values())
         entity.relationships = list(relationships_dict.values())
 
+        # Detect join tables structurally: an entity whose columns are exactly
+        # two foreign keys, both part of the primary key, is an association
+        # table regardless of its class name (#35).
+        entity.is_link_table = self._is_structural_link_table(entity.fields)
+
         self.entities[class_node.name] = entity
 
+    @staticmethod
+    def _is_structural_link_table(fields: List[FieldInfo]) -> bool:
+        """Return True if fields describe a join table: exactly two columns,
+        both foreign keys and both part of the primary key."""
+        if len(fields) != 2:
+            return False
+        return all(f.is_foreign_key and f.is_primary_key for f in fields)
+
+    def _parse_core_association_tables(self) -> None:
+        """Synthesize link entities from module-level Core ``Table(...)`` assignments.
+
+        ``relationship(secondary=Table(...))`` points at a SQLAlchemy Core table
+        rather than a mapped class. Only class definitions become entities in the
+        normal passes, so such association tables - and their M:N - would be lost.
+        Parse module-level ``name = Table("t", metadata, Column(...), ...)``
+        assignments that are structurally association tables (exactly two FK
+        columns, both part of the primary key) and add them as link entities (#34).
+        """
+        if self.sources is not None and "sqlalchemy" not in self.sources:
+            return
+
+        for tree in self.file_trees.values():
+            for node in tree.body:
+                if not isinstance(node, ast.Assign):
+                    continue
+                if len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name):
+                    continue
+                if not self._is_call_to(node.value, "Table"):
+                    continue
+
+                var_name = node.targets[0].id
+                entity = self._build_core_table_entity(var_name, node.value)
+                if entity is not None and entity.name not in self.entities:
+                    self.entities[entity.name] = entity
+
+    def _build_core_table_entity(self, var_name: str, call: ast.Call) -> EntityInfo | None:
+        """Build a link EntityInfo from a Core ``Table(...)`` call, or None if it
+        is not structurally an association table."""
+        # Table name is the first positional string arg; fall back to variable name.
+        table_name = var_name
+        if (
+            call.args
+            and isinstance(call.args[0], ast.Constant)
+            and isinstance(call.args[0].value, str)
+        ):
+            table_name = call.args[0].value
+
+        fields: List[FieldInfo] = []
+        for arg in call.args:
+            if self._is_call_to(arg, "Column"):
+                field = self._parse_core_column(arg)
+                if field is not None:
+                    fields.append(field)
+
+        if not self._is_structural_link_table(fields):
+            return None
+
+        entity = EntityInfo(
+            name=var_name,
+            table_name=table_name,
+            base_classes=[],
+            source="sqlalchemy",
+        )
+        entity.fields = fields
+        entity.is_link_table = True
+        return entity
+
+    def _parse_core_column(self, call: ast.Call) -> FieldInfo | None:
+        """Parse a Core ``Column("name", <Type>, ForeignKey(...), primary_key=...)``."""
+        if not call.args or not isinstance(call.args[0], ast.Constant):
+            return None
+        col_name = str(call.args[0].value)
+
+        is_primary_key = False
+        for keyword in call.keywords:
+            if keyword.arg == "primary_key" and isinstance(keyword.value, ast.Constant):
+                is_primary_key = bool(keyword.value.value)
+
+        fk_target = self._extract_foreign_key_arg(call)
+
+        # An optional positional column type (e.g. Column("id", Integer, ...)).
+        type_str = ""
+        for arg in call.args[1:]:
+            if isinstance(arg, ast.Name):
+                type_str = arg.id
+                break
+            if isinstance(arg, ast.Attribute):
+                type_str = arg.attr
+                break
+
+        return FieldInfo(
+            name=col_name,
+            type_str=type_str,
+            is_primary_key=is_primary_key,
+            is_foreign_key=fk_target is not None,
+            foreign_table=fk_target,
+        )
+
+    @staticmethod
+    def _is_call_to(value: ast.expr, func_name: str) -> TypeGuard[ast.Call]:
+        """Check whether an expression is a call to ``func_name`` (Name or attribute)."""
+        if not isinstance(value, ast.Call):
+            return False
+        func = value.func
+        return (isinstance(func, ast.Name) and func.id == func_name) or (
+            isinstance(func, ast.Attribute) and func.attr == func_name
+        )
+
     def _collect_fields_recursive(
         self, class_node: ast.ClassDef, visited: set[str], model_kind: str
     ) -> Tuple[Dict[str, FieldInfo], Dict[str, Tuple[str, str, str]]]: