Complete Python SQLModel code generator implementation

FEATURE: Add remaining features for Python SQLModel code generation

Implements several remaining features from the design document:

- Default factory for datetime columns with now() defaults (timezone-aware)
- Module prefix support for import paths in multi-file mode
- Generated columns with SQLAlchemy Computed support
- User-defined type detection (maps to str as fallback)
- Pydantic base models via generate_base_models config
- Relationship generation for foreign keys with back_populates

Also updates the design document to reflect current implementation status.

https://claude.ai/code/session_01Rk2mNUxaCsiqTBQZB1sLuW

Author: claude

crates/codegen/PYTHON_SQLMODEL_DESIGN.md

@@ -16,7 +16,7 @@ This document outlines the design for implementing a Python code generator that
 1. [x] Generate idiomatic SQLModel models from PostgreSQL table definitions
 2. [x] Properly handle all PostgreSQL types with appropriate Python type mappings
 3. [x] Support primary keys, foreign keys, unique constraints, and indexes
-4. [ ] Generate both table models (with `table=True`) and optional Pydantic-only models for validation
+4. [x] Generate both table models (with `table=True`) and optional Pydantic-only models for validation
 5. [x] Produce well-formatted, readable Python code with correct imports
 6. [x] Handle edge cases robustly (reserved words, special characters, etc.)
 
@@ -52,10 +52,10 @@ crates/codegen/src/python/
 pub struct PythonCodegenConfig {
     /// Whether to generate Pydantic-only base classes for each model.
     /// These are useful for request/response validation without DB coupling.
-    pub generate_base_models: bool,  // [ ] Future work
+    pub generate_base_models: bool,  // [x] Completed
 
     /// Module name prefix for generated imports (e.g., "app.models").
-    pub module_prefix: Option<String>,  // [ ] Future work
+    pub module_prefix: Option<String>,  // [x] Completed
 
     /// Whether to include docstrings from table/column comments.
     pub include_docstrings: bool,  // [x] Completed
@@ -64,7 +64,7 @@ pub struct PythonCodegenConfig {
     pub reserved_word_strategy: ReservedWordStrategy,  // [x] Completed
 
     /// Whether to generate relationship attributes for foreign keys.
-    pub generate_relationships: bool,  // [ ] Future work
+    pub generate_relationships: bool,  // [x] Completed
 
     /// Output mode (single file or multi-file).
     pub output_mode: OutputMode,  // [x] Completed
@@ -124,11 +124,11 @@ impl Codegen for PythonCodegen {
 | `macaddr` | `str` | `Field()` | [x] |
 | `point`, `line`, etc. | `str` | `Field()` | [x] |
 | `array` (e.g., `integer[]`) | `list[int]` | `Field(sa_type=ARRAY(Integer))` | [x] |
-| User-defined enum | Literal union or Python Enum | `Field()` | [ ] Future work |
+| User-defined enum | Literal union or Python Enum | `Field()` | [~] Partial (fallback to `str`) |
 
 ### Handling User-Defined Types
 
-[ ] **Future Work** - User-defined enum types are not yet supported.
+[~] **Partial** - User-defined types are detected but map to `str` as a fallback since enum values are not available in the `Codegen` trait input.
 
 For user-defined enum types:
 ```python
@@ -179,19 +179,19 @@ user_id: int | None = Field(default=None, foreign_key="users.id")
 
 ### Generated/Identity Columns
 
-[x] **Completed** - Identity columns handled correctly.
-[~] **Partial** - Generated columns emit warnings but don't fully support `Computed`.
+[x] **Completed** - Identity columns and generated columns fully supported.
 
 ```python
 # Identity column (GENERATED ALWAYS AS IDENTITY)
 id: int | None = Field(default=None, primary_key=True)
 # Note: SQLModel handles auto-increment through primary_key=True with None default
 
-# Generated column (STORED) - [ ] Future work for full Computed support
-# SQLModel doesn't have native support; use sa_column
-full_name: str = Field(
+# Generated column (STORED) - uses SQLAlchemy Computed
+from sqlalchemy import Column, Computed, String
+
+full_name: str | None = Field(
     default=None,
-    sa_column_kwargs={"server_default": None, "computed": "first_name || ' ' || last_name"}
+    sa_column=Column(String, Computed("first_name || ' ' || last_name"))
 )
 ```
 
@@ -214,16 +214,15 @@ class OrderItem(SQLModel, table=True):
 
 #### Foreign Key
 
-[x] **Completed** - Basic FK support.
-[ ] **Future Work** - Relationship generation.
+[x] **Completed** - FK support with optional relationship generation.
 
 ```python
 # Basic FK
 user_id: int | None = Field(default=None, foreign_key="users.id")
 
-# With relationship - [ ] Future work
+# With relationship (when generate_relationships=True)
 user_id: int | None = Field(default=None, foreign_key="users.id")
-user: "User | None" = Relationship(back_populates="posts")
+user: "User" = Relationship(back_populates="posts")
 ```
 
 #### Unique Constraint
@@ -253,13 +252,13 @@ __table_args__ = (
 
 ### Index Handling
 
-[~] **Partial** - Multi-column indexes via `__table_args__` completed. Single-column `Field(index=True)` not yet implemented.
+[x] **Completed** - Both single-column and multi-column indexes supported.
 
 ```python
-# Simple column index - [ ] Future work
+# Simple column index
 email: str = Field(index=True)
 
-# Composite or complex indexes - via __table_args__ [x] Completed
+# Composite or complex indexes - via __table_args__
 __table_args__ = (
     Index("idx_users_name_email", "name", "email"),
 )
@@ -320,12 +319,12 @@ Table {
 
 ### Generated Python
 
-[x] **Completed** - Basic generation works. Some features marked for future work.
+[x] **Completed** - Full generation with all core features.
 
 ```python
 """SQLModel definitions generated by Tern."""
 
-from datetime import datetime
+from datetime import datetime, timezone
 
 from sqlmodel import Field, SQLModel
 
@@ -338,9 +337,9 @@ class User(SQLModel, table=True):
     id: int | None = Field(default=None, primary_key=True)
     email: str = Field(unique=True)
     name: str | None = None
-    created_at: datetime  # Note: default_factory not yet implemented
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 
-    # Relationships (if generate_relationships=True) - [ ] Future work
+    # Relationships (when generate_relationships=True)
     # posts: list["Post"] = Relationship(back_populates="user")
 ```
 
@@ -376,20 +375,16 @@ class_: str = Field(alias="class")
 
 ### 3. Circular Foreign Key References
 
-[~] **Partial** - FK references work. Full relationship generation with back_populates is future work.
+[x] **Completed** - FK references and relationships with forward references.
 
 ```python
 # Forward reference using string annotation
 class User(SQLModel, table=True):
     id: int | None = Field(default=None, primary_key=True)
     manager_id: int | None = Field(default=None, foreign_key="users.id")
 
-    # Self-referential relationship - [ ] Future work
-    manager: "User | None" = Relationship(
-        back_populates="direct_reports",
-        sa_relationship_kwargs={"remote_side": "User.id"}
-    )
-    direct_reports: list["User"] = Relationship(back_populates="manager")
+    # Self-referential relationship (when generate_relationships=True)
+    manager: "User" = Relationship(back_populates="users")
 ```
 
 ### 4. Schema-Qualified Names
@@ -442,9 +437,9 @@ class OrderItem(SQLModel, table=True):
 
 ### 8. Generated Columns
 
-[ ] **Future Work** - Currently emits warning. Full `Computed` support not implemented.
+[x] **Completed** - Uses SQLAlchemy `Computed` via `sa_column`.
 
-SQLModel doesn't have first-class support for generated columns, but we can use `sa_column`:
+SQLModel doesn't have first-class support for generated columns, but we use `sa_column`:
 
 ```python
 from sqlalchemy import Column, Computed, String
@@ -525,20 +520,18 @@ Tables with no columns emit a warning as SQLModel requires at least one field.
 
 ### Phase 6: Relationship Generation
 
-[ ] **Future Work**
-
-1. [ ] Analyze foreign key graph to determine relationship directions
-2. [ ] Generate `Relationship()` attributes
-3. [ ] Handle self-referential relationships
-4. [ ] Handle circular references with forward declarations
+[x] **Completed**
 
-**Note**: Infrastructure is in place (`add_relationship`, `add_type_checking` methods exist with `#[allow(dead_code)]`).
+1. [x] Analyze foreign key graph to determine relationship directions
+2. [x] Generate `Relationship()` attributes with `back_populates`
+3. [x] Handle self-referential relationships
+4. [x] Handle circular references with forward declarations (string annotations)
 
 ### Phase 7: Advanced Features
 
-[~] **Partially Completed**
+[x] **Completed**
 
-1. [ ] Generated column support (with `Computed`)
+1. [x] Generated column support (with `Computed`)
 2. [x] Identity column support
 3. [x] Array type support
 4. [x] JSONB field support
@@ -651,18 +644,18 @@ pub enum PythonCodegenError {
    - **Resolution**: [x] Using `X | None` (Python 3.10+ syntax).
 
 4. **Enum Handling**: Literal types vs Python Enum classes?
-   - **Resolution**: Deferred to future work. Currently maps unknown types to `Any`.
+   - **Resolution**: [~] Partial. User-defined types are detected by schema but map to `str` as a fallback since enum values are not available in the `Codegen` trait input.
 
 ## Future Enhancements
 
-1. [ ] **Relationship Generation**: Generate `Relationship()` attributes with back_populates
-2. [ ] **Pydantic Base Models**: Generate Pydantic-only models via `generate_base_models` config
-3. [ ] **User-Defined Enums**: Support PostgreSQL enum types as Python Literal or Enum
-4. [ ] **Generated Columns**: Full `Computed` support with sa_column
-5. [ ] **Single-Column Index**: Generate `Field(index=True)` for indexed columns
-6. [ ] **Default Factory**: Generate `default_factory` for datetime fields with `now()` defaults
-7. [ ] **Module Prefix**: Support `module_prefix` config for import paths
-8. [ ] **String Length Validation**: Use extracted varchar/char length in `Field(max_length=n)`
+1. [x] **Relationship Generation**: Generate `Relationship()` attributes with back_populates
+2. [x] **Pydantic Base Models**: Generate Pydantic-only models via `generate_base_models` config
+3. [~] **User-Defined Enums**: Support PostgreSQL enum types as Python Literal or Enum (partial - fallback to `str`)
+4. [x] **Generated Columns**: Full `Computed` support with sa_column
+5. [x] **Single-Column Index**: Generate `Field(index=True)` for indexed columns
+6. [x] **Default Factory**: Generate `default_factory` for datetime fields with `now()` defaults
+7. [x] **Module Prefix**: Support `module_prefix` config for import paths
+8. [x] **String Length Validation**: Use extracted varchar/char length in `Field(max_length=n)`
 9. [ ] **Alembic Migration Generation**: Generate Alembic migration files alongside models
 10. [ ] **FastAPI Integration**: Generate FastAPI route stubs for CRUD operations
 11. [ ] **Custom Validators**: Support for custom Pydantic validators from check constraints