model-generator-kit 0.1.2__tar.gz → 0.1.4__tar.gz

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-generator-kit
-Version: 0.1.2
+Version: 0.1.4
 Summary: One-shot bootstrap generator for database models, API models, routes, and tests
 Author-email: nuncaeslupus <imarcos@gmail.com>
 License: MIT
@@ -140,4 +140,4 @@ Define specifications once in JSON. Generate production-ready scaffolds. Then ma
 
 ---
 
-**Model Generator** | Bootstrap Tool for API Backends | v0.1.2
+**Model Generator** | Bootstrap Tool for API Backends | v0.1.4

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/README.md

@@ -104,4 +104,4 @@ Define specifications once in JSON. Generate production-ready scaffolds. Then ma
 
 ---
 
-**Model Generator** | Bootstrap Tool for API Backends | v0.1.2
+**Model Generator** | Bootstrap Tool for API Backends | v0.1.4

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model-generator-kit"
-version = "0.1.2"
+version = "0.1.4"
 description = "One-shot bootstrap generator for database models, API models, routes, and tests"
 readme = "README.md"
 license = {text = "MIT"}

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator/__init__.py

@@ -3,4 +3,4 @@
 # Single source of truth is pyproject.toml's [project].version. `make
 # version-sync` propagates that value here; `make check-version-sync` (run in
 # CI) fails the build if they drift. Do not edit by hand.
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator/stacks/python-fastapi/templates/api/request.py.j2

@@ -57,11 +57,13 @@ This module contains:
 {% endif %}
 {#- Check for financial/counter fields with constraints needing validators -#}
 {% if not field.api_exclude_create | default(false) or not field.api_exclude_update | default(false) %}
-{% if field.type == 'financial' and field.constraints is defined %}
-{% for c in field.constraints %}
-{% if c.type in ['non_negative', 'non_negative_or_null'] and 'validate_non_negative_decimal' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_non_negative_decimal') %}{% endif %}
-{% if c.type in ['positive', 'positive_or_null'] and 'validate_positive_decimal' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_positive_decimal') %}{% endif %}
-{% endfor %}
+{% if field.type == 'financial' %}
+{#- Choose validator by declared constraint: non-negative when constrained, signed otherwise -#}
+{% set ctypes = (field.constraints | map(attribute='type') | list) if (field.constraints is defined and field.constraints) else [] %}
+{% if 'non_negative' in ctypes or 'non_negative_or_null' in ctypes %}{% set fin_validator = 'validate_non_negative_decimal' %}
+{% elif 'positive' in ctypes or 'positive_or_null' in ctypes %}{% set fin_validator = 'validate_positive_decimal' %}
+{% else %}{% set fin_validator = 'validate_decimal' %}{% endif %}
+{% if fin_validator not in ns.needs_validators %}{% set _ = ns.needs_validators.append(fin_validator) %}{% endif %}
 {% elif field.type == 'percentage' %}
 {% if 'validate_percentage' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_percentage') %}{% endif %}
 {% elif field.type == 'counter' and field.constraints is defined %}
@@ -208,7 +210,7 @@ class Create{{ entity_name }}Request(BaseModel):
 {% elif field.type == 'text' and db_name == 'username' %}
                 "{{ field_name }}": "john_doe",
 {% elif field.type == 'text' and 'password' in db_name.lower() %}
-                "{{ field_name }}": "SecureP@ssw0rd!",
+                "{{ field_name }}": "your-password-here",
 {% elif field.type == 'text' and 'name' in db_name.lower() %}
                 "{{ field_name }}": "{{ db_name.replace('_', ' ').title() }}",
 {% elif field.type == 'text' %}
@@ -271,14 +273,13 @@ class Create{{ entity_name }}Request(BaseModel):
 {#- Collect constraint-driven validators (financial, percentage, counter) -#}
 {% for item in create_fields %}
 {% set field = item.field %}
-{% if field.type == 'financial' and field.constraints is defined %}
-{% for c in field.constraints %}
-{% if c.type in ['non_negative', 'non_negative_or_null'] %}
-{% set _ = field_validators.append({'name': item.name, 'validator': 'validate_non_negative_decimal'}) %}
-{% elif c.type in ['positive', 'positive_or_null'] %}
-{% set _ = field_validators.append({'name': item.name, 'validator': 'validate_positive_decimal'}) %}
-{% endif %}
-{% endfor %}
+{% if field.type == 'financial' %}
+{#- Choose validator by declared constraint: non-negative when constrained, signed otherwise -#}
+{% set ctypes = (field.constraints | map(attribute='type') | list) if (field.constraints is defined and field.constraints) else [] %}
+{% if 'non_negative' in ctypes or 'non_negative_or_null' in ctypes %}{% set fin_validator = 'validate_non_negative_decimal' %}
+{% elif 'positive' in ctypes or 'positive_or_null' in ctypes %}{% set fin_validator = 'validate_positive_decimal' %}
+{% else %}{% set fin_validator = 'validate_decimal' %}{% endif %}
+{% set _ = field_validators.append({'name': item.name, 'validator': fin_validator}) %}
 {% elif field.type == 'percentage' %}
 {% set _ = field_validators.append({'name': item.name, 'validator': 'validate_percentage'}) %}
 {% elif field.type == 'counter' and field.constraints is defined %}
@@ -416,14 +417,13 @@ class Update{{ entity_name }}Request(BaseModel):
 {% set update_validators = [] %}
 {% for item in update_fields %}
 {% set field = item.field %}
-{% if field.type == 'financial' and field.constraints is defined %}
-{% for c in field.constraints %}
-{% if c.type in ['non_negative', 'non_negative_or_null'] %}
-{% set _ = update_validators.append({'name': item.name, 'validator': 'validate_non_negative_decimal'}) %}
-{% elif c.type in ['positive', 'positive_or_null'] %}
-{% set _ = update_validators.append({'name': item.name, 'validator': 'validate_positive_decimal'}) %}
-{% endif %}
-{% endfor %}
+{% if field.type == 'financial' %}
+{#- Choose validator by declared constraint: non-negative when constrained, signed otherwise -#}
+{% set ctypes = (field.constraints | map(attribute='type') | list) if (field.constraints is defined and field.constraints) else [] %}
+{% if 'non_negative' in ctypes or 'non_negative_or_null' in ctypes %}{% set fin_validator = 'validate_non_negative_decimal' %}
+{% elif 'positive' in ctypes or 'positive_or_null' in ctypes %}{% set fin_validator = 'validate_positive_decimal' %}
+{% else %}{% set fin_validator = 'validate_decimal' %}{% endif %}
+{% set _ = update_validators.append({'name': item.name, 'validator': fin_validator}) %}
 {% elif field.type == 'percentage' %}
 {% set _ = update_validators.append({'name': item.name, 'validator': 'validate_percentage'}) %}
 {% elif field.type == 'counter' and field.constraints is defined %}

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator/stacks/python-fastapi/templates/api/response.py.j2

@@ -26,7 +26,14 @@ This module contains:
 {% if not field.api_exclude_response | default(false) %}
 {% if field.type in ['json_object', 'json_array'] %}{% set ns.has_any = true %}{% endif %}
 {% if field.type == 'enum' and field.enum_name not in ns.enum_imports %}{% set _ = ns.enum_imports.append(field.enum_name) %}{% endif %}
-{% if field.type == 'financial' and 'validate_non_negative_decimal' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_non_negative_decimal') %}{% endif %}
+{% if field.type == 'financial' %}
+{#- Choose validator by declared constraint: non-negative when constrained, signed otherwise -#}
+{% set ctypes = (field.constraints | map(attribute='type') | list) if (field.constraints is defined and field.constraints) else [] %}
+{% if 'non_negative' in ctypes or 'non_negative_or_null' in ctypes %}{% set fin_validator = 'validate_non_negative_decimal' %}
+{% elif 'positive' in ctypes or 'positive_or_null' in ctypes %}{% set fin_validator = 'validate_positive_decimal' %}
+{% else %}{% set fin_validator = 'validate_decimal' %}{% endif %}
+{% if fin_validator not in ns.needs_validators %}{% set _ = ns.needs_validators.append(fin_validator) %}{% endif %}
+{% endif %}
 {% if field.type == 'percentage' and 'validate_percentage' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_percentage') %}{% endif %}
 {% if field.type == 'counter' and 'validate_non_negative_int' not in ns.needs_validators %}{% set _ = ns.needs_validators.append('validate_non_negative_int') %}{% endif %}
 {% endif %}
@@ -173,7 +180,12 @@ class {{ entity_name }}Response(BaseModel):
 {% for field_name, field in entity.fields.items() %}
 {% if not field.api_exclude_response | default(false) %}
 {% if field.type == 'financial' %}
-{% set _ = validated_fields.append({'name': field_name, 'validator': 'validate_non_negative_decimal'}) %}
+{#- Choose validator by declared constraint: non-negative when constrained, signed otherwise -#}
+{% set ctypes = (field.constraints | map(attribute='type') | list) if (field.constraints is defined and field.constraints) else [] %}
+{% if 'non_negative' in ctypes or 'non_negative_or_null' in ctypes %}{% set fin_validator = 'validate_non_negative_decimal' %}
+{% elif 'positive' in ctypes or 'positive_or_null' in ctypes %}{% set fin_validator = 'validate_positive_decimal' %}
+{% else %}{% set fin_validator = 'validate_decimal' %}{% endif %}
+{% set _ = validated_fields.append({'name': field_name, 'validator': fin_validator}) %}
 {% elif field.type == 'percentage' %}
 {% set _ = validated_fields.append({'name': field_name, 'validator': 'validate_percentage'}) %}
 {% elif field.type == 'counter' %}

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator/stacks/python-fastapi/templates/infrastructure/validators.py.j2

@@ -23,6 +23,23 @@ from typing import Any
 {{ section_divider('DECIMAL VALIDATORS') }}
 
 
+def validate_decimal(value: Any) -> str | None:
+    """Validate that a value is a well-formed decimal (sign-agnostic).
+
+    Accepts negative, zero, and positive values. Use this for signed
+    financial fields (e.g. PnL, returns) that may legitimately be negative.
+    """
+    if value is None:
+        return value
+    try:
+        decimal_value = Decimal(str(value))
+    except InvalidOperation:
+        raise ValueError("Invalid decimal value") from None
+    if not decimal_value.is_finite():
+        raise ValueError("Value must be a finite decimal")
+    return str(value)
+
+
 def validate_non_negative_decimal(value: Any) -> str | None:
     """Validate that a decimal value is non-negative (>= 0)."""
     if value is None:

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator/stacks/python-fastapi/templates/migrations/env.py.j2

@@ -10,6 +10,7 @@
 {{ generated_marker() }}
 """Alembic environment configuration."""
 from logging.config import fileConfig
+from typing import Any
 
 from sqlalchemy import engine_from_config
 from sqlalchemy import pool
@@ -32,6 +33,63 @@ if config.config_file_name is not None:
 from {{ config.paths.database_models | path_to_import }}.base import Base
 target_metadata = Base.metadata
 
+# Project custom SQLAlchemy types live here. Autogenerate must import them into
+# the migrations it writes (see render_item below), otherwise the generated
+# migration references e.g. PortableUuid() without an import and fails to load.
+_CUSTOM_TYPE_MODULE = "{{ config.paths.database_models.rsplit('/', 1)[0] | path_to_import }}.types"
+_CUSTOM_TYPE_NAMES = ("PortableNumeric", "PortableUuid")
+
+# Async drivers map to their sync equivalents. Alembic runs migrations
+# synchronously, so an async DATABASE_URL (e.g. postgresql+asyncpg://) must be
+# coerced to a sync driver before an Engine is built.
+_ASYNC_TO_SYNC_DRIVERS = {
+    "+asyncpg": "+psycopg2",
+    "+aiosqlite": "",
+    "+aiomysql": "+pymysql",
+    "+asyncmy": "+pymysql",
+    "+aioodbc": "+pyodbc",
+}
+
+
+def _coerce_sync_driver(url: str) -> str:
+    """Return ``url`` with any known async driver in the *scheme* swapped for a
+    sync one. Only the scheme (before "://") is touched, so a credential or
+    database name that happens to contain a driver substring is never mangled.
+    """
+    scheme, sep, rest = url.partition("://")
+    if not sep:
+        return url
+    for async_driver, sync_driver in _ASYNC_TO_SYNC_DRIVERS.items():
+        if scheme.endswith(async_driver):
+            scheme = scheme[: -len(async_driver)] + sync_driver
+            break
+    return scheme + sep + rest
+
+
+def render_item(type_: str, obj: Any, autogen_context: Any) -> str | bool:
+    """Render the project's custom column types with their import.
+
+    Without this, autogenerate emits ``PortableUuid()`` / ``PortableNumeric()``
+    in the migration body but never imports them, so the migration raises
+    ``NameError`` on load. Returning ``False`` falls back to Alembic's default
+    rendering for everything else.
+    """
+    if type_ == "type" and type(obj).__name__ in _CUSTOM_TYPE_NAMES:
+        cls = type(obj).__name__
+        autogen_context.imports.add(f"from {_CUSTOM_TYPE_MODULE} import {cls}")
+        if cls == "PortableNumeric":
+            args = [
+                f"{name}={value}"
+                for name, value in (
+                    ("precision", obj.precision),
+                    ("scale", obj.scale),
+                )
+                if value is not None
+            ]
+            return f"{cls}({', '.join(args)})"
+        return f"{cls}()"
+    return False
+
 # other values from the config, defined by the needs of env.py,
 # can be acquired:
 # my_important_option = config.get_main_option("my_important_option")
@@ -60,7 +118,7 @@ def get_url() -> str:
             "alembic.ini, must be set"
         )
         raise RuntimeError(msg)
-    return url
+    return _coerce_sync_driver(url)
 
 
 def run_migrations_offline() -> None:
@@ -83,6 +141,7 @@ def run_migrations_offline() -> None:
         dialect_opts={"paramstyle": "named"},
         compare_type=True,
         compare_server_default=True,
+        render_item=render_item,
     )
 
     with context.begin_transaction():
@@ -113,6 +172,7 @@ def run_migrations_online() -> None:
             target_metadata=target_metadata,
             compare_type=True,
             compare_server_default=True,
+            render_item=render_item,
         )
 
         with context.begin_transaction():

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/src/model_generator_kit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-generator-kit
-Version: 0.1.2
+Version: 0.1.4
 Summary: One-shot bootstrap generator for database models, API models, routes, and tests
 Author-email: nuncaeslupus <imarcos@gmail.com>
 License: MIT
@@ -140,4 +140,4 @@ Define specifications once in JSON. Generate production-ready scaffolds. Then ma
 
 ---
 
-**Model Generator** | Bootstrap Tool for API Backends | v0.1.2
+**Model Generator** | Bootstrap Tool for API Backends | v0.1.4

{model_generator_kit-0.1.2 → model_generator_kit-0.1.4}/tests/test_generators.py

@@ -1105,6 +1105,223 @@ class TestApiModelsGeneratorPerEntity:
         assert "class UpdateAuthorRequest(BaseModel):" in author_req
         assert "CreatePostRequest" not in author_req
 
+    def test_password_example_is_not_a_secret(
+        self, project_env_per_entity: Any
+    ) -> None:
+        """The OpenAPI example for a password field must be a non-secret
+        placeholder so secret scanners (GitGuardian) don't flag generated repos."""
+        project_root, config, env = project_env_per_entity
+        model = {
+            "domain": "accounts",
+            "entities": {
+                "User": {
+                    "table": "users",
+                    "fields": {
+                        "id": {
+                            "type": "uuid",
+                            "primary_key": True,
+                            "auto_generate": True,
+                        },
+                        "password": {"type": "text", "required": True},
+                    },
+                }
+            },
+        }
+        result = generate_api_models(model, config, env, project_root)
+        assert isinstance(result, list)
+        content = next(
+            r["content"] for r in result if r["path"].name == "user_requests.py"
+        )
+        assert "SecureP@ssw0rd!" not in content
+        assert '"password": "your-password-here"' in content
+
+
+@pytest.fixture
+def financial_model() -> dict[str, Any]:
+    """Single entity exercising signed vs constrained financial fields.
+
+    - unrealized_pnl: no constraint  -> signed -> validate_decimal
+    - balance:        non_negative   -> validate_non_negative_decimal
+    - deposit:        positive       -> validate_positive_decimal
+    """
+    return {
+        "domain": "ledger",
+        "description": "Ledger domain with signed and constrained money",
+        "entities": {
+            "Account": {
+                "table": "accounts",
+                "description": "Trading account",
+                "fields": {
+                    "id": {
+                        "type": "uuid",
+                        "primary_key": True,
+                        "auto_generate": True,
+                    },
+                    "unrealized_pnl": {
+                        "type": "financial",
+                        "required": True,
+                    },
+                    "balance": {
+                        "type": "financial",
+                        "required": True,
+                        "constraints": [{"type": "non_negative"}],
+                    },
+                    "deposit": {
+                        "type": "financial",
+                        "required": True,
+                        "constraints": [{"type": "positive"}],
+                    },
+                },
+                "timestamps": {"created": True, "updated": True},
+            },
+        },
+    }
+
+
+class TestFinancialValidatorSelection:
+    """Signed financial fields must not be forced non-negative.
+
+    Regression: the response/request templates hardcoded
+    validate_non_negative_decimal for every financial field, so any
+    legitimately negative value (PnL, returns) failed validation.
+    """
+
+    def _content(self, model: dict[str, Any], env_fixture: Any, suffix: str) -> str:
+        project_root, config, env = env_fixture
+        result = generate_api_models(model, config, env, project_root)
+        assert isinstance(result, list)
+        content = next(r["content"] for r in result if r["path"].name.endswith(suffix))
+        assert isinstance(content, str)
+        return content
+
+    def test_response_signed_financial_uses_validate_decimal(
+        self, financial_model: dict[str, Any], project_env_per_entity: Any
+    ) -> None:
+        content = self._content(
+            financial_model, project_env_per_entity, "account_response.py"
+        )
+        # Unconstrained financial -> signed validator
+        assert (
+            '_validate_unrealized_pnl = field_validator("unrealized_pnl")'
+            "(validate_decimal)" in content
+        )
+        # Constrained financial -> stays non-negative / positive
+        assert (
+            '_validate_balance = field_validator("balance")'
+            "(validate_non_negative_decimal)" in content
+        )
+        assert (
+            '_validate_deposit = field_validator("deposit")'
+            "(validate_positive_decimal)" in content
+        )
+
+    def test_response_imports_match_validators_used(
+        self, financial_model: dict[str, Any], project_env_per_entity: Any
+    ) -> None:
+        content = self._content(
+            financial_model, project_env_per_entity, "account_response.py"
+        )
+        import_line = next(
+            line
+            for line in content.splitlines()
+            if line.startswith("from") and "validators import" in line
+        )
+        assert "validate_decimal" in import_line
+        assert "validate_non_negative_decimal" in import_line
+        assert "validate_positive_decimal" in import_line
+
+    def test_request_signed_financial_uses_validate_decimal(
+        self, financial_model: dict[str, Any], project_env_per_entity: Any
+    ) -> None:
+        content = self._content(
+            financial_model, project_env_per_entity, "account_requests.py"
+        )
+        assert (
+            '_validate_unrealized_pnl = field_validator("unrealized_pnl")'
+            "(validate_decimal)" in content
+        )
+        assert (
+            '_validate_balance = field_validator("balance")'
+            "(validate_non_negative_decimal)" in content
+        )
+        assert (
+            '_validate_deposit = field_validator("deposit")'
+            "(validate_positive_decimal)" in content
+        )
+
+    def test_request_imports_match_validators_used(
+        self, financial_model: dict[str, Any], project_env_per_entity: Any
+    ) -> None:
+        content = self._content(
+            financial_model, project_env_per_entity, "account_requests.py"
+        )
+        import_line = next(
+            line
+            for line in content.splitlines()
+            if line.startswith("from") and "validators import" in line
+        )
+        assert "validate_decimal" in import_line
+        assert "validate_non_negative_decimal" in import_line
+        assert "validate_positive_decimal" in import_line
+
+    def test_validators_module_defines_validate_decimal(
+        self, project_env_per_entity: Any
+    ) -> None:
+        project_root, config, env = project_env_per_entity
+        result = generate_validators(config, env, project_root)
+        assert result is not None
+        assert "def validate_decimal(value: Any) -> str | None:" in result["content"]
+
+    def test_validate_decimal_rejects_non_finite(
+        self, project_env_per_entity: Any
+    ) -> None:
+        """The emitted validate_decimal must reject NaN/Infinity, not just
+        malformed strings (financial fields cannot store non-finite values)."""
+        project_root, config, env = project_env_per_entity
+        result = generate_validators(config, env, project_root)
+        assert result is not None
+        ns: dict[str, Any] = {}
+        exec(result["content"], ns)
+        validate_decimal = ns["validate_decimal"]
+        # Signed finite values pass.
+        assert validate_decimal("-12.5") == "-12.5"
+        assert validate_decimal(None) is None
+        # Non-finite values are rejected.
+        for bad in ("NaN", "Infinity", "-Infinity", "sNaN"):
+            with pytest.raises(ValueError):
+                validate_decimal(bad)
+        with pytest.raises(ValueError):
+            validate_decimal("not-a-number")
+
+    def test_empty_constraints_fall_back_to_signed(
+        self, project_env_per_entity: Any
+    ) -> None:
+        """A financial field with an empty (falsy) `constraints` list falls
+        back to the signed default rather than crashing on the `map` filter."""
+        model = {
+            "domain": "ledger",
+            "entities": {
+                "Account": {
+                    "table": "accounts",
+                    "fields": {
+                        "id": {
+                            "type": "uuid",
+                            "primary_key": True,
+                            "auto_generate": True,
+                        },
+                        "pnl": {
+                            "type": "financial",
+                            "required": True,
+                            "constraints": [],
+                        },
+                    },
+                }
+            },
+        }
+        for suffix in ("account_response.py", "account_requests.py"):
+            content = self._content(model, project_env_per_entity, suffix)
+            assert '_validate_pnl = field_validator("pnl")(validate_decimal)' in content
+
 
 class TestGenerateApiInitPerEntity:
     """Per-entity api __init__.py emission."""
@@ -2858,6 +3075,81 @@ class TestMigrationGenerator:
         # config.paths.database_models is used in the import path
         assert "src.database.models" in env_py["content"]
 
+    def _env_py(self, minimal_model: dict[str, Any], project_env: Any) -> str:
+        project_root, config, env = project_env
+        result = generate_migration_init(minimal_model, config, env, project_root)
+        assert isinstance(result, list)
+        env_py = next(
+            r for r in result if r["path"] == project_root / "alembic" / "env.py"
+        )
+        content = env_py["content"]
+        assert isinstance(content, str)
+        return content
+
+    def test_env_py_is_valid_python(
+        self, minimal_model: dict[str, Any], project_env: Any
+    ) -> None:
+        """The rendered env.py must parse — guards the new helper blocks."""
+        import ast
+
+        ast.parse(self._env_py(minimal_model, project_env))
+
+    def test_env_py_coerces_async_drivers_to_sync(
+        self, minimal_model: dict[str, Any], project_env: Any
+    ) -> None:
+        """Alembic runs sync, so get_url() must coerce async drivers."""
+        content = self._env_py(minimal_model, project_env)
+        assert "def _coerce_sync_driver(url: str) -> str:" in content
+        assert '"+asyncpg": "+psycopg2",' in content
+        assert '"+aiosqlite": "",' in content
+        # get_url returns the coerced URL, not the raw one.
+        assert "return _coerce_sync_driver(url)" in content
+        # Only the scheme is rewritten, so credentials/db names are never mangled.
+        assert 'scheme, sep, rest = url.partition("://")' in content
+        assert "scheme.endswith(async_driver)" in content
+
+    def test_coerce_sync_driver_behaviour(
+        self, minimal_model: dict[str, Any], project_env: Any
+    ) -> None:
+        """Exercise the generated _coerce_sync_driver in isolation (executing
+        the whole module would run migrations)."""
+        import ast
+
+        content = self._env_py(minimal_model, project_env)
+        tree = ast.parse(content)
+        wanted = {"_ASYNC_TO_SYNC_DRIVERS", "_coerce_sync_driver"}
+        nodes: list[ast.stmt] = [
+            n
+            for n in tree.body
+            if (isinstance(n, ast.FunctionDef) and n.name in wanted)
+            or (
+                isinstance(n, ast.Assign)
+                and any(getattr(t, "id", None) in wanted for t in n.targets)
+            )
+        ]
+        ns: dict[str, Any] = {}
+        exec(compile(ast.Module(body=nodes, type_ignores=[]), "<env>", "exec"), ns)
+        coerce = ns["_coerce_sync_driver"]
+        assert (
+            coerce("postgresql+asyncpg://u:p@h/db") == "postgresql+psycopg2://u:p@h/db"
+        )
+        assert coerce("sqlite+aiosqlite:///x.db") == "sqlite:///x.db"
+        # A driver substring inside credentials must NOT be rewritten.
+        assert coerce("postgresql://u:+asyncpg@h/db") == "postgresql://u:+asyncpg@h/db"
+        # Already-sync URLs pass through untouched.
+        assert coerce("postgresql://u:p@h/db") == "postgresql://u:p@h/db"
+
+    def test_env_py_renders_custom_types_with_import(
+        self, minimal_model: dict[str, Any], project_env: Any
+    ) -> None:
+        """render_item must be wired into both configure() calls and import
+        the project's custom column types into generated migrations."""
+        content = self._env_py(minimal_model, project_env)
+        assert "def render_item(type_: str, obj: Any, autogen_context: Any)" in content
+        assert '_CUSTOM_TYPE_MODULE = "src.database.types"' in content
+        # Wired into offline and online configure() calls.
+        assert content.count("render_item=render_item,") == 2
+
     def test_custom_migrations_path(
         self, minimal_model: dict[str, Any], project_env: Any
     ) -> None: