Merge pull request #49 from tomsch420/main

One to many relationships are now done via association tables. I added a testcase that shows why the old way wont work always.

Author: tomsch420

src/krrood/ormatic/dao.py

@@ -11,7 +11,7 @@
 import sqlalchemy.inspection
 import sqlalchemy.orm
 from sqlalchemy import Column
-from sqlalchemy.orm import MANYTOONE, ONETOMANY, RelationshipProperty
+from sqlalchemy.orm import MANYTOONE, MANYTOMANY, ONETOMANY, RelationshipProperty
 from typing_extensions import (
     Type,
     get_args,
@@ -581,7 +581,7 @@ def get_relationships_from(
                     relationship=relationship,
                     state=state,
                 )
-            elif relationship.direction == ONETOMANY:
+            elif relationship.direction in (ONETOMANY, MANYTOMANY):
                 self._extract_collection_relationship(
                     obj=obj,
                     relationship=relationship,
@@ -727,7 +727,7 @@ def _collect_relationship_kwargs(
                 if is_circular:
                     circular_refs[relationship.key] = value
                 rel_kwargs[relationship.key] = parsed
-            elif relationship.direction == ONETOMANY:
+            elif relationship.direction in (ONETOMANY, MANYTOMANY):
                 parsed_list, circular_list = state.parse_collection(value)
                 if circular_list:
                     circular_refs[relationship.key] = circular_list

src/krrood/ormatic/ormatic.py

@@ -13,7 +13,7 @@
 from .dao import AlternativeMapping
 from .sqlalchemy_generator import SQLAlchemyGenerator
 from .utils import InheritanceStrategy, module_and_class_name
-from .wrapped_table import WrappedTable
+from .wrapped_table import WrappedTable, AssociationTable
 from ..class_diagrams.class_diagram import (
     ClassDiagram,
     ClassRelation,
@@ -87,6 +87,11 @@ class ORMatic:
     The wrapped tables instances for the SQLAlchemy conversion.
     """
 
+    association_tables: List[AssociationTable] = field(default_factory=list, init=False)
+    """
+    List of association tables for many-to-many relationships.
+    """
+
     def __post_init__(self):
         self.type_mappings[Type] = TypeType
         self.imported_modules.add(Type.__module__)

src/krrood/ormatic/templates/sqlalchemy_model.py.jinja

@@ -1,7 +1,7 @@
 # Generated by ORMatic
 
 from __future__ import annotations
-from sqlalchemy import Column, ForeignKey, Integer, String, Float, Boolean, DateTime, Enum, JSON
+from sqlalchemy import Column, ForeignKey, Integer, String, Float, Boolean, DateTime, Enum, JSON, Table
 from sqlalchemy.orm import relationship, Mapped, mapped_column, DeclarativeBase
 
 {% for import in ormatic.imported_modules %}
@@ -20,6 +20,17 @@ class Base(DeclarativeBase):
     }
 
 
+# Association tables for many-to-many relationships
+{% for assoc_table in ormatic.association_tables %}
+{{ assoc_table.name }} = Table(
+    '{{ assoc_table.name }}',
+    Base.metadata,
+    Column('{{ assoc_table.left_foreign_key }}', ForeignKey('{{ assoc_table.left_primary_key }}')),
+    Column('{{ assoc_table.right_foreign_key }}', ForeignKey('{{ assoc_table.right_primary_key }}')),
+)
+{% endfor %}
+
+
 {% for table in ormatic.wrapped_tables.values() %}
 class {{ table.tablename }}({{ table.base_class_name }}, DataAccessObject[{{ table.wrapped_clazz.clazz.__module__ }}.{{ table.wrapped_clazz.clazz.__name__ }}]):
 

src/krrood/ormatic/wrapped_table.py

@@ -61,6 +61,48 @@ def __str__(self) -> str:
             return f"{self.name}: {self.type}"
 
 
+@dataclass
+class AssociationTable:
+    """
+    Represents an association table for many-to-many relationships in SQLAlchemy.
+    """
+
+    name: str
+    """
+    The name of the association table.
+    """
+
+    left_table_name: str
+    """
+    The name of the left (source) table.
+    """
+
+    left_foreign_key: str
+    """
+    The foreign key column name for the left table.
+    """
+
+    left_primary_key: str
+    """
+    The full primary key reference for the left table (e.g., 'TableName.primary_key').
+    """
+
+    right_table_name: str
+    """
+    The name of the right (target) table.
+    """
+
+    right_foreign_key: str
+    """
+    The foreign key column name for the right table.
+    """
+
+    right_primary_key: str
+    """
+    The full primary key reference for the right table (e.g., 'TableName.primary_key').
+    """
+
+
 @dataclass
 class WrappedTable:
     """
@@ -520,32 +562,42 @@ def create_one_to_one_relationship(self, wrapped_field: WrappedField):
 
     def create_one_to_many_relationship(self, wrapped_field: WrappedField):
         """
-        Creates a one-to-many relationship mapping for the given wrapped field.
-        The target side of the wrapped field gets a foreign key to this table with a unique name.
-        This table gets a relationship that joins the target table with the foreign key.
+        Creates a many-to-many relationship mapping for the given wrapped field using an association table.
+        This allows multiple instances of the source table to reference the same instances of the target table.
 
-        :param wrapped_field: The field for the one-to-many relationship.
+        :param wrapped_field: The field for the many-to-many relationship.
         """
 
         # get the target table
         target_wrapped_table = self.get_table_of_wrapped_field(wrapped_field)
 
-        # create a foreign key to this on the remote side
-        fk_name = f"{self.tablename.lower()}_{wrapped_field.field.name}{self.ormatic.foreign_key_postfix}"
-        fk_type = (
-            f"Mapped[{module_and_class_name(Optional)}[{module_and_class_name(int)}]]"
-        )
-        fk_column_constructor = f"mapped_column(ForeignKey('{self.full_primary_key_name}', use_alter=True), nullable=True, use_existing_column=True)"
-        target_wrapped_table.foreign_keys.append(
-            ColumnConstructor(fk_name, fk_type, fk_column_constructor)
+        # create association table name
+        association_table_name = f"{self.tablename.lower()}_{wrapped_field.field.name}_association"
+
+        # create foreign key names for the association table
+        left_fk_name = f"{self.tablename.lower()}{self.ormatic.foreign_key_postfix}"
+        right_fk_name = f"{target_wrapped_table.tablename.lower()}{self.ormatic.foreign_key_postfix}"
+
+        # create association table metadata
+        association_table = AssociationTable(
+            name=association_table_name,
+            left_table_name=self.tablename,
+            left_foreign_key=left_fk_name,
+            left_primary_key=self.full_primary_key_name,
+            right_table_name=target_wrapped_table.tablename,
+            right_foreign_key=right_fk_name,
+            right_primary_key=target_wrapped_table.full_primary_key_name,
         )
 
-        # create a relationship with a list to collect the other side
+        # add association table to ORMatic
+        self.ormatic.association_tables.append(association_table)
+
+        # create a relationship with a list using the association table
         rel_name = f"{wrapped_field.field.name}"
         rel_type = (
             f"Mapped[{module_and_class_name(List)}[{target_wrapped_table.tablename}]]"
         )
-        rel_constructor = f"relationship('{target_wrapped_table.tablename}', foreign_keys='[{target_wrapped_table.tablename}.{fk_name}]', post_update=True)"
+        rel_constructor = f"relationship('{target_wrapped_table.tablename}', secondary='{association_table_name}', cascade='save-update, merge')"
         self.relationships.append(
             ColumnConstructor(rel_name, rel_type, rel_constructor)
         )