fastsmtp 0.6.0__py3-none-any.whl

fastsmtp/__init__.py

@@ -0,0 +1,3 @@
+"""FastSMTP - SMTP-to-Webhook Relay Server."""
+
+__version__ = "0.6.0"

fastsmtp/alembic/env.py

@@ -0,0 +1,69 @@
+"""Alembic migration environment."""
+
+import asyncio
+from logging.config import fileConfig
+
+from alembic import context
+from fastsmtp.config import DatabaseSettings
+from fastsmtp.db.models import Base
+from sqlalchemy import pool
+from sqlalchemy.ext.asyncio import async_engine_from_config
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+# Only the URL is needed here. Loading the full Settings would demand a root
+# API key and apply the S3 cross-field rules, none of which a migration run
+# uses -- a one-off Job given just the database URL must be able to run.
+config.set_main_option("sqlalchemy.url", DatabaseSettings().database_dsn)
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection) -> None:
+    """Run migrations with the given connection."""
+    context.configure(connection=connection, target_metadata=target_metadata)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_async_migrations() -> None:
+    """Run migrations in 'online' mode with async engine."""
+    connectable = async_engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    asyncio.run(run_async_migrations())
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

fastsmtp/alembic/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

fastsmtp/alembic/versions/001_initial_schema.py

@@ -0,0 +1,271 @@
+"""Initial schema.
+
+Revision ID: 001
+Revises:
+Create Date: 2025-01-07
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "001"
+down_revision: str | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Users table
+    op.create_table(
+        "users",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("username", sa.String(255), nullable=False),
+        sa.Column("email", sa.String(255), nullable=True),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("is_superuser", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("username"),
+    )
+    op.create_index("ix_users_username", "users", ["username"])
+
+    # API Keys table
+    op.create_table(
+        "api_keys",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("user_id", sa.Uuid(), nullable=False),
+        sa.Column("key_hash", sa.String(255), nullable=False),
+        sa.Column("key_salt", sa.String(128), nullable=True),
+        sa.Column("key_prefix", sa.String(20), nullable=False),
+        sa.Column("name", sa.String(255), nullable=False),
+        sa.Column("scopes", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("last_used_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_api_keys_user_id", "api_keys", ["user_id"])
+    op.create_index("ix_api_keys_key_hash", "api_keys", ["key_hash"])
+
+    # Domains table
+    op.create_table(
+        "domains",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("domain_name", sa.String(255), nullable=False),
+        sa.Column("is_enabled", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("verify_dkim", sa.Boolean(), nullable=True),
+        sa.Column("verify_spf", sa.Boolean(), nullable=True),
+        sa.Column("reject_dkim_fail", sa.Boolean(), nullable=True),
+        sa.Column("reject_spf_fail", sa.Boolean(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("domain_name"),
+    )
+    op.create_index("ix_domains_domain_name", "domains", ["domain_name"])
+
+    # Domain Members table
+    op.create_table(
+        "domain_members",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("user_id", sa.Uuid(), nullable=False),
+        sa.Column("domain_id", sa.Uuid(), nullable=False),
+        sa.Column("role", sa.String(50), nullable=False, server_default=sa.text("'member'")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["domain_id"], ["domains.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("user_id", "domain_id", name="uq_domain_member"),
+    )
+    op.create_index("ix_domain_members_user_domain", "domain_members", ["user_id", "domain_id"])
+
+    # Recipients table
+    op.create_table(
+        "recipients",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("domain_id", sa.Uuid(), nullable=False),
+        sa.Column("local_part", sa.String(255), nullable=True),
+        sa.Column("webhook_url", sa.Text(), nullable=False),
+        sa.Column("webhook_headers", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column("is_enabled", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["domain_id"], ["domains.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("domain_id", "local_part", name="uq_recipient_local_part"),
+    )
+    op.create_index("ix_recipients_domain_id", "recipients", ["domain_id"])
+    op.create_index("ix_recipients_domain_local", "recipients", ["domain_id", "local_part"])
+
+    # RuleSets table
+    op.create_table(
+        "rulesets",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("domain_id", sa.Uuid(), nullable=False),
+        sa.Column("name", sa.String(255), nullable=False),
+        sa.Column("priority", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("stop_on_match", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("is_enabled", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["domain_id"], ["domains.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("domain_id", "name", name="uq_ruleset_name"),
+    )
+    op.create_index("ix_rulesets_domain_id", "rulesets", ["domain_id"])
+    op.create_index("ix_rulesets_domain_priority", "rulesets", ["domain_id", "priority"])
+
+    # Rules table
+    op.create_table(
+        "rules",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("ruleset_id", sa.Uuid(), nullable=False),
+        sa.Column("order", sa.Integer(), nullable=False),
+        sa.Column("field", sa.String(100), nullable=False),
+        sa.Column("operator", sa.String(50), nullable=False),
+        sa.Column("value", sa.Text(), nullable=False),
+        sa.Column("case_sensitive", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("action", sa.String(50), nullable=False, server_default=sa.text("'forward'")),
+        sa.Column("webhook_url_override", sa.Text(), nullable=True),
+        sa.Column("add_tags", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["ruleset_id"], ["rulesets.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_rules_ruleset_id", "rules", ["ruleset_id"])
+    op.create_index("ix_rules_ruleset_order", "rules", ["ruleset_id", "order"])
+
+    # Delivery Log table
+    op.create_table(
+        "delivery_log",
+        sa.Column("id", sa.Uuid(), nullable=False),
+        sa.Column("domain_id", sa.Uuid(), nullable=True),
+        sa.Column("message_id", sa.String(255), nullable=False),
+        sa.Column("recipient_id", sa.Uuid(), nullable=True),
+        sa.Column("webhook_url", sa.Text(), nullable=False),
+        sa.Column("payload_hash", sa.String(64), nullable=False),
+        sa.Column("status", sa.String(50), nullable=False),
+        sa.Column("attempts", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("next_retry_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("last_error", sa.Text(), nullable=True),
+        sa.Column("last_status_code", sa.Integer(), nullable=True),
+        sa.Column("instance_id", sa.String(50), nullable=False),
+        sa.Column("delivered_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("payload", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+        sa.Column("dkim_result", sa.String(50), nullable=True),
+        sa.Column("spf_result", sa.String(50), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.ForeignKeyConstraint(["domain_id"], ["domains.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["recipient_id"], ["recipients.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_delivery_log_domain_id", "delivery_log", ["domain_id"])
+    op.create_index("ix_delivery_log_message_id", "delivery_log", ["message_id"])
+    op.create_index("ix_delivery_log_status", "delivery_log", ["status"])
+    op.create_index("ix_delivery_log_next_retry_at", "delivery_log", ["next_retry_at"])
+    op.create_index("ix_delivery_log_status_retry", "delivery_log", ["status", "next_retry_at"])
+    op.create_index("ix_delivery_log_domain_created", "delivery_log", ["domain_id", "created_at"])
+
+
+def downgrade() -> None:
+    # Drop tables in reverse order (respecting foreign key dependencies)
+    op.drop_table("delivery_log")
+    op.drop_table("rules")
+    op.drop_table("rulesets")
+    op.drop_table("recipients")
+    op.drop_table("domain_members")
+    op.drop_table("domains")
+    op.drop_table("api_keys")
+    op.drop_table("users")

fastsmtp/alembic/versions/002_add_delivery_log_indexes.py

@@ -0,0 +1,30 @@
+"""Add delivery log indexes.
+
+Revision ID: 002
+Revises: 001
+Create Date: 2025-01-07
+
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "002"
+down_revision: str | None = "001"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Add indexes for delivery_log table
+    op.create_index("ix_delivery_log_instance_id", "delivery_log", ["instance_id"])
+    op.create_index("ix_delivery_log_delivered_at", "delivery_log", ["delivered_at"])
+    op.create_index("ix_delivery_log_cleanup", "delivery_log", ["created_at", "status"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_delivery_log_cleanup", "delivery_log")
+    op.drop_index("ix_delivery_log_delivered_at", "delivery_log")
+    op.drop_index("ix_delivery_log_instance_id", "delivery_log")

fastsmtp/alembic/versions/003_add_soft_delete_columns.py

@@ -0,0 +1,66 @@
+"""Add soft delete columns to key models.
+
+Revision ID: 003
+Revises: 002
+Create Date: 2025-01-07
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "003"
+down_revision: str | None = "002"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # Add deleted_at column to users table
+    op.add_column(
+        "users",
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_index("ix_users_deleted_at", "users", ["deleted_at"])
+
+    # Add deleted_at column to api_keys table
+    op.add_column(
+        "api_keys",
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_index("ix_api_keys_deleted_at", "api_keys", ["deleted_at"])
+
+    # Add deleted_at column to domains table
+    op.add_column(
+        "domains",
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_index("ix_domains_deleted_at", "domains", ["deleted_at"])
+
+    # Add deleted_at column to recipients table
+    op.add_column(
+        "recipients",
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.create_index("ix_recipients_deleted_at", "recipients", ["deleted_at"])
+
+
+def downgrade() -> None:
+    # Remove deleted_at from recipients
+    op.drop_index("ix_recipients_deleted_at", "recipients")
+    op.drop_column("recipients", "deleted_at")
+
+    # Remove deleted_at from domains
+    op.drop_index("ix_domains_deleted_at", "domains")
+    op.drop_column("domains", "deleted_at")
+
+    # Remove deleted_at from api_keys
+    op.drop_index("ix_api_keys_deleted_at", "api_keys")
+    op.drop_column("api_keys", "deleted_at")
+
+    # Remove deleted_at from users
+    op.drop_index("ix_users_deleted_at", "users")
+    op.drop_column("users", "deleted_at")

fastsmtp/alembic/versions/004_add_raw_message_preservation.py

@@ -0,0 +1,45 @@
+"""Add raw message preservation flags to domains and rules.
+
+Revision ID: 004
+Revises: 003
+Create Date: 2026-08-22
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "004"
+down_revision: str | None = "003"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # NULL = inherit the global preserve_raw_message setting
+    op.add_column(
+        "domains",
+        sa.Column("preserve_raw_message", sa.Boolean(), nullable=True),
+    )
+
+    # Orthogonal to Rule.action: a rule may preserve the raw message and still drop it.
+    # Added with a server default so existing rows backfill, then dropped so the
+    # application default is the only source of truth.
+    op.add_column(
+        "rules",
+        sa.Column(
+            "preserve_raw",
+            sa.Boolean(),
+            nullable=False,
+            server_default=sa.false(),
+        ),
+    )
+    op.alter_column("rules", "preserve_raw", server_default=None)
+
+
+def downgrade() -> None:
+    op.drop_column("rules", "preserve_raw")
+    op.drop_column("domains", "preserve_raw_message")

fastsmtp/alembic/versions/005_align_schema_with_models.py

@@ -0,0 +1,90 @@
+"""Align the migrated schema with the models.
+
+Revision ID: 005
+Revises: 004
+Create Date: 2026-08-23
+
+Three differences between what the chain builds and what the models declare,
+all dating from 001 and all invisible until tests/test_migrations.py started
+diffing the two (the rest of the suite builds its schema from the models with
+Base.metadata.create_all, so migrated databases were never compared):
+
+1. Four JSONB columns were created nullable although the models declare them
+   NOT NULL (``scopes``, ``webhook_headers``, ``add_tags``, ``payload``).
+2. ``users.username`` and ``domains.domain_name`` got a UNIQUE constraint plus a
+   separate non-unique index, where ``mapped_column(unique=True, index=True)``
+   declares a single unique index. The redundant index is dropped here.
+3. ``ix_recipients_domain_catchall`` was never created, so a migrated database
+   accepted two catch-all recipients for the same domain - the partial unique
+   index is the only thing enforcing that, because PostgreSQL lets
+   ``uq_recipient_local_part`` hold any number of NULL ``local_part`` rows.
+
+The chain has been PostgreSQL-specific since 001 (it creates ``postgresql.JSONB``
+columns), so the partial index is expressed with dialect-specific WHERE clauses
+exactly as the model does.
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "005"
+down_revision: str | None = "004"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+# (table, column, value to backfill NULLs with) for columns the models declare
+# non-optional - Mapped[list[str]] and Mapped[dict], never Mapped[... | None].
+NOT_NULL_JSONB: tuple[tuple[str, str, str], ...] = (
+    ("api_keys", "scopes", "'[]'::jsonb"),
+    ("recipients", "webhook_headers", "'{}'::jsonb"),
+    ("rules", "add_tags", "'[]'::jsonb"),
+    ("delivery_log", "payload", "'{}'::jsonb"),
+)
+
+JSONB_TYPE = postgresql.JSONB(astext_type=sa.Text())
+
+# Auto-generated PostgreSQL names for the inline UNIQUE constraints in 001.
+UNIQUE_TO_INDEX: tuple[tuple[str, str, str, str], ...] = (
+    ("users", "username", "users_username_key", "ix_users_username"),
+    ("domains", "domain_name", "domains_domain_name_key", "ix_domains_domain_name"),
+)
+
+
+def upgrade() -> None:
+    for table, column, empty in NOT_NULL_JSONB:
+        op.execute(f"UPDATE {table} SET {column} = {empty} WHERE {column} IS NULL")
+        op.alter_column(table, column, existing_type=JSONB_TYPE, nullable=False)
+
+    for table, column, constraint, index in UNIQUE_TO_INDEX:
+        op.drop_constraint(constraint, table, type_="unique")
+        op.drop_index(index, table_name=table)
+        op.create_index(index, table, [column], unique=True)
+
+    # Fails if a domain already has two catch-all recipients. That is a data
+    # error the application has always rejected; deduplicating here would delete
+    # a recipient silently, so it is left to be resolved deliberately.
+    op.create_index(
+        "ix_recipients_domain_catchall",
+        "recipients",
+        ["domain_id"],
+        unique=True,
+        postgresql_where=sa.text("local_part IS NULL"),
+        sqlite_where=sa.text("local_part IS NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_recipients_domain_catchall", table_name="recipients")
+
+    for table, column, constraint, index in UNIQUE_TO_INDEX:
+        op.drop_index(index, table_name=table)
+        op.create_index(index, table, [column])
+        op.create_unique_constraint(constraint, table, [column])
+
+    for table, column, _empty in NOT_NULL_JSONB:
+        op.alter_column(table, column, existing_type=JSONB_TYPE, nullable=True)

fastsmtp/alembic/versions/006_exclude_soft_deleted_from_catchall.py

@@ -0,0 +1,56 @@
+"""Exclude soft-deleted recipients from the catch-all unique index.
+
+Revision ID: 006
+Revises: 005
+Create Date: 2026-08-23
+
+``ix_recipients_domain_catchall`` guarantees at most one catch-all recipient
+per domain, but its predicate (``local_part IS NULL``) also counted
+soft-deleted rows. ``Recipient`` uses ``SoftDeleteMixin``, so a deleted
+catch-all stays in the table with ``deleted_at`` set - and kept blocking the
+creation of its replacement, turning the routine delete-then-recreate admin
+operation into a unique violation. The predicate now also requires
+``deleted_at IS NULL``, matching the model.
+
+The upgrade cannot fail on existing data: every set of rows that satisfied the
+old, broader predicate satisfies the narrower one. The downgrade can - a live
+catch-all plus a tombstoned one for the same domain is valid under this
+revision but violates the old index. As with 005, failing loudly is deliberate;
+deduplicating here would silently delete a recipient.
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "006"
+down_revision: str | None = "005"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.drop_index("ix_recipients_domain_catchall", table_name="recipients")
+    op.create_index(
+        "ix_recipients_domain_catchall",
+        "recipients",
+        ["domain_id"],
+        unique=True,
+        postgresql_where=sa.text("local_part IS NULL AND deleted_at IS NULL"),
+        sqlite_where=sa.text("local_part IS NULL AND deleted_at IS NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_recipients_domain_catchall", table_name="recipients")
+    op.create_index(
+        "ix_recipients_domain_catchall",
+        "recipients",
+        ["domain_id"],
+        unique=True,
+        postgresql_where=sa.text("local_part IS NULL"),
+        sqlite_where=sa.text("local_part IS NULL"),
+    )