plain.postgres 0.112.0__tar.gz → 0.113.0__tar.gz

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.112.0
+Version: 0.113.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause
@@ -941,6 +941,7 @@ Values are encrypted using Fernet (AES-128-CBC + HMAC-SHA256) with a key derived
 
 - **No lookups** — encrypted values are non-deterministic (same plaintext produces different ciphertext each time), so filtering on encrypted fields doesn't work. Only `isnull` lookups are supported.
 - **No indexes or constraints** — encrypted fields cannot be used in indexes or unique constraints. Preflight checks will catch this.
+- **Only `default=""`** — on `EncryptedTextField` (paired with `required=False`), the empty string is stored as plaintext `''`, so it's the one value expressible as a column `DEFAULT` (declare it to add the field to a populated table). Any other default would need ciphertext, which is non-deterministic. `EncryptedJSONField` accepts no default at all — even `{}` serializes to text that would need ciphertext; use `allow_null=True`.
 
 **Key rotation:**
 
@@ -1492,9 +1493,9 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain migrations create` to create a migration.
 
-If the field is required (no `default=` and not `allow_null=True`), the autodetector refuses to generate the migration, since there's no value to seed existing rows with. You have two options:
+If the field has no `default=` and isn't `allow_null=True`, the autodetector refuses to generate the migration, since there's no value to seed existing rows with — `required=False` alone is not enough (it only affects Python-side validation, not the column). You have two options:
 
-1. Declare a `default=` on the field so the new column has a value for existing rows.
+1. Declare a `default=` on the field so the new column has a value for existing rows. For an optional string field the idiom is `required=False, default=""` (for `BinaryField`, `default=b""`).
 2. Add the field with `allow_null=True`, scaffold a data migration with `plain migrations create --empty --name backfill_<field>` to populate existing rows, then remove `allow_null=True` from the field — convergence applies `NOT NULL` on the next `postgres sync`.
 
 #### How do I make an existing column `NOT NULL`?

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/CHANGELOG.md

@@ -1,6 +1,24 @@
 # plain-postgres changelog
 
-## [0.112.0](https://github.com/dropseed/plain/releases/plain-postgres@0.112.0) (2026-07-21)
+## [0.113.0](https://github.com/dropseed/plain/releases/plain-postgres@0.113.0) (2026-08-02)
+
+### What's changed
+
+- **`QuerySet.extra()` has been removed**, along with all of its supporting machinery (`extra_select`, `extra_tables`, `extra_order_by`, `ExtraWhere`). Use `annotate()` with `RawSQL` or other expressions instead. ([3fed0b32f1](https://github.com/dropseed/plain/commit/3fed0b32f1))
+- **`FilteredRelation` has been removed** — it's no longer importable from `plain.postgres` or usable in `annotate()`. Express conditional joins with `Q` filters or subqueries instead. ([434f57852f](https://github.com/dropseed/plain/commit/434f57852f))
+- **`QuerySet.alias()` and logical XOR have been removed** — `Q(...) ^ Q(...)` and `queryset ^ queryset` are no longer supported. Use `annotate()` in place of `alias()`, and compose AND/OR/NOT in place of XOR. ([c12cf81af4](https://github.com/dropseed/plain/commit/c12cf81af4))
+- **Encrypted and binary fields now accept their empty value as a declared `default=`.** `EncryptedTextField` (now a `TextField` subclass) accepts exactly `default=""` and `BinaryField` accepts exactly `default=b""`, each paired with `required=False` — the empty value is stored as plaintext so it's the one default expressible as a column `DEFAULT`, which is what lets the field be added to a populated table. `default=None` requires `allow_null=True` + `required=False`. The `types.pyi` stub overloads encode the same coupling. ([2a86968e5a](https://github.com/dropseed/plain/commit/2a86968e5a))
+- **The migration autodetector no longer waves through `required=False` fields with no declared default.** Adding a non-nullable field without a `default=` now refuses at `plain migrations create` time with a field-accurate remedy (previously these could generate an `AddField` that failed at apply time on any populated table). The optional-string idiom is `required=False, default=""`. ([2a86968e5a](https://github.com/dropseed/plain/commit/2a86968e5a))
+- **`EncryptedJSONField` is now a `JSONField` subclass** and `EncryptedTextField` a `TextField` subclass, instead of parallel `ColumnField` implementations — behavior like max_length validation and JSON encoding now comes from the real base classes. The encrypted lookup surface is still just `exact`/`isnull`, and JSON key transforms are blocked (they'd operate on ciphertext). `EncryptedJSONField` accepts no `default=` at all — even `{}` would need ciphertext; use `allow_null=True`. ([5153ceb106](https://github.com/dropseed/plain/commit/5153ceb106), [2a86968e5a](https://github.com/dropseed/plain/commit/2a86968e5a))
+- Model forms no longer prefill a `BinaryField`'s `b""` default as a text input's initial value (it rendered as the literal `b''`), and encrypted fields now map to form fields through the regular `TextField`/`JSONField` branches. ([2a86968e5a](https://github.com/dropseed/plain/commit/2a86968e5a))
+- M2M prefetches now expose the through-table join column via `annotate(RawSQL(...))` instead of the removed `extra()`, and internal path-info plumbing lost its `filtered_relation` threading. ([3fed0b32f1](https://github.com/dropseed/plain/commit/3fed0b32f1), [434f57852f](https://github.com/dropseed/plain/commit/434f57852f))
+
+### Upgrade instructions
+
+- Replace `QuerySet.extra()` calls: `extra(select=...)` becomes `annotate(name=RawSQL("...", []))`, `extra(where=...)` becomes `filter()` with expressions or `RawSQL`, and `extra(order_by=...)` becomes `order_by()` on an annotation.
+- Replace `FilteredRelation` annotations with filtered subqueries or `Q` conditions, and `QuerySet.alias()` with `annotate()`.
+- Replace `Q(a) ^ Q(b)` / `qs1 ^ qs2` with explicit AND/OR logic: `(Q(a) | Q(b)) & ~(Q(a) & Q(b))`.
+- If `plain migrations create` now refuses a field it previously accepted, follow the error's remedy: declare `required=False, default=""` (or `default=b""` / an appropriate literal) so existing rows get a value, or add it with `allow_null=True` plus a backfill data migration.(https://github.com/dropseed/plain/releases/plain-postgres@0.112.0) (2026-07-21)
 
 ### What's changed
 

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/README.md

@@ -928,6 +928,7 @@ Values are encrypted using Fernet (AES-128-CBC + HMAC-SHA256) with a key derived
 
 - **No lookups** — encrypted values are non-deterministic (same plaintext produces different ciphertext each time), so filtering on encrypted fields doesn't work. Only `isnull` lookups are supported.
 - **No indexes or constraints** — encrypted fields cannot be used in indexes or unique constraints. Preflight checks will catch this.
+- **Only `default=""`** — on `EncryptedTextField` (paired with `required=False`), the empty string is stored as plaintext `''`, so it's the one value expressible as a column `DEFAULT` (declare it to add the field to a populated table). Any other default would need ciphertext, which is non-deterministic. `EncryptedJSONField` accepts no default at all — even `{}` serializes to text that would need ciphertext; use `allow_null=True`.
 
 **Key rotation:**
 
@@ -1479,9 +1480,9 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain migrations create` to create a migration.
 
-If the field is required (no `default=` and not `allow_null=True`), the autodetector refuses to generate the migration, since there's no value to seed existing rows with. You have two options:
+If the field has no `default=` and isn't `allow_null=True`, the autodetector refuses to generate the migration, since there's no value to seed existing rows with — `required=False` alone is not enough (it only affects Python-side validation, not the column). You have two options:
 
-1. Declare a `default=` on the field so the new column has a value for existing rows.
+1. Declare a `default=` on the field so the new column has a value for existing rows. For an optional string field the idiom is `required=False, default=""` (for `BinaryField`, `default=b""`).
 2. Add the field with `allow_null=True`, scaffold a data migration with `plain migrations create --empty --name backfill_<field>` to populate existing rows, then remove `allow_null=True` from the field — convergence applies `NOT NULL` on the next `postgres sync`.
 
 #### How do I make an existing column `NOT NULL`?

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/agents/.claude/rules/plain-postgres.md

@@ -79,7 +79,7 @@ Run `uv run plain docs postgres` for full patterns with code examples.
 - Indexes: `{table}_{column(s)}_idx`
 - Constraints: `{table}_{column(s)}_{type}` (e.g., `_unique`, `_check`)
 - Choose `on_delete` deliberately: CASCADE for owned children, RESTRICT for referenced data, SET_NULL for optional references
-- No `allow_null` on string fields — use `default=""`
+- No `allow_null` on string fields — use `default=""`. Optional string fields are `required=False, default=""` — the declared default is what lets the column be added to a populated table (`required=False` alone only affects Python-side validation)
 
 Run `uv run plain docs postgres` for full patterns with code examples.
 

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/cli/sync.py

@@ -7,6 +7,7 @@ import click
 from plain.runtime import settings
 
 from ..convergence import execute_plan, plan_convergence
+from ..db import get_connection
 from .decorators import cli_schema_lock, database_management_command
 
 
@@ -112,7 +113,6 @@ def _create_migrations() -> None:
 
 
 def _migrate() -> None:
-    from ..db import get_connection
     from ..migrations.executor import MigrationExecutor
 
     click.secho("Applying migrations...", bold=True)

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/expressions.py

@@ -163,9 +163,7 @@ class Combinable:
     def bitrightshift(self, other: Any) -> CombinedExpression:
         return self._combine(other, self.BITRIGHTSHIFT, False)
 
-    def __xor__(self, other: Any) -> Q:
-        if getattr(self, "conditional", False) and getattr(other, "conditional", False):
-            return Q(self) ^ Q(other)
+    def __xor__(self, other: Any) -> None:
         raise NotImplementedError(
             "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
         )
@@ -431,8 +429,8 @@ class BaseExpression:
     def get_lookup(self, lookup: str) -> type[Lookup] | None:
         return self.output_field.get_lookup(lookup)
 
-    def get_transform(self, name: str) -> type[Transform] | None:
-        return self.output_field.get_transform(name)  # ty: ignore[invalid-return-type]
+    def get_transform(self, name: str) -> Callable[..., Transform] | None:
+        return self.output_field.get_transform(name)
 
     def relabeled_clone(self, change_map: dict[str, str]) -> Self:
         clone = self.copy()

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/fields/base.py

@@ -516,8 +516,8 @@ class Field[T](RegisterLookupMixin):
         return self.get_db_prep_value(value, connection=connection, prepared=False)
 
     # Empty-value fallback used by ColumnField.get_default for the
-    # not-null + not-required + empty_strings_allowed case (Python-side
-    # Model() construction). BinaryField overrides with b"".
+    # not-null + empty_strings_allowed case (Python-side Model()
+    # construction). BinaryField overrides with b"".
     _default_empty_value: Any = ""
 
     def has_default(self) -> bool:
@@ -666,6 +666,15 @@ class DefaultableField[T](ColumnField[T]):
 
     non_migration_attrs = (*ColumnField.non_migration_attrs, "default")
 
+    # Subclasses whose __init__ deliberately doesn't take default=
+    # (EncryptedJSONField) set this False so callers like the autodetector's
+    # error guidance don't suggest a kwarg that would raise.
+    accepts_default = True
+
+    # Subclasses set this when their only expressible column DEFAULT is the
+    # class's `_default_empty_value` ("" / b"").
+    only_empty_default = False
+
     def __init__(
         self,
         *,
@@ -674,22 +683,48 @@ class DefaultableField[T](ColumnField[T]):
         allow_null: bool = False,
         validators: Sequence[Callable[..., Any]] = (),
     ):
-        if default is not NOT_PROVIDED and callable(default):
-            raise TypeError(
-                f"{type(self).__name__}(default=...) must be a static literal. "
-                f"For empty collections pass default={{}} or default=[]; for "
-                f"per-row generation use a DB-side expression "
-                f"(create_now=True, generate=True, RandomStringField)."
-            )
-        if default is not NOT_PROVIDED and isinstance(default, str) and "\\" in default:
-            # psycopg quotes backslash-bearing strings with `E'...'` escape
-            # syntax, but pg_get_expr returns the stored DEFAULT as a standard
-            # `'...'` literal — the two forms don't compare lexically, so
-            # convergence would flag spurious drift on every sync. Reject at
-            # declaration time rather than ship a sync that never converges.
-            raise ValueError(
-                f"{type(self).__name__}(default=...) must not contain a backslash."
-            )
+        if default is not NOT_PROVIDED:
+            if callable(default):
+                raise TypeError(
+                    f"{type(self).__name__}(default=...) must be a static literal. "
+                    f"For empty collections pass default={{}} or default=[]; for "
+                    f"per-row generation use a DB-side expression "
+                    f"(create_now=True, generate=True, RandomStringField)."
+                )
+            if isinstance(default, str) and "\\" in default:
+                # psycopg quotes backslash-bearing strings with `E'...'` escape
+                # syntax, but pg_get_expr returns the stored DEFAULT as a standard
+                # `'...'` literal — the two forms don't compare lexically, so
+                # convergence would flag spurious drift on every sync. Reject at
+                # declaration time rather than ship a sync that never converges.
+                raise ValueError(
+                    f"{type(self).__name__}(default=...) must not contain a backslash."
+                )
+            if self.only_empty_default:
+                empty = self._default_empty_value
+                if default is None:
+                    if not allow_null or required:
+                        raise ValueError(
+                            f"{type(self).__name__} with default=None must also "
+                            f"set allow_null=True and required=False — the "
+                            f"column must accept NULL, and required=True would "
+                            f"reject the defaulted None on every save."
+                        )
+                # `type()` (not isinstance/==) so bytearray()/memoryview(b"")
+                # can't slip through — they compare equal to b"" but don't
+                # deepcopy or serialize like it.
+                elif type(default) is not type(empty) or default != empty:
+                    raise ValueError(
+                        f"{type(self).__name__} only supports default={empty!r} — "
+                        f"the empty value, used to backfill existing rows when "
+                        f"the field is added to a populated table."
+                    )
+                elif required:
+                    raise ValueError(
+                        f"{type(self).__name__} with default={empty!r} must also "
+                        f"set required=False — the default fills the field with "
+                        f"an empty value that required=True then rejects."
+                    )
         self.default = default
         super().__init__(
             required=required,

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/fields/binary.py

@@ -8,7 +8,7 @@ import psycopg
 
 from plain.validators import MaxLengthValidator
 
-from .base import ColumnField
+from .base import NOT_PROVIDED, DefaultableField
 
 if TYPE_CHECKING:
     from plain.postgres.connection import DatabaseConnection
@@ -17,10 +17,11 @@ if TYPE_CHECKING:
 
 class BinaryField[
     T: (bytes | memoryview, bytes | memoryview | None) = bytes | memoryview
-](ColumnField[T]):
+](DefaultableField[T]):
     db_type_sql = "bytea"
     empty_values = [None, b""]
     _default_empty_value = b""
+    only_empty_default = True
 
     def __init__(
         self,
@@ -28,14 +29,14 @@ class BinaryField[
         max_length: int | None = None,
         required: bool = True,
         allow_null: bool = False,
+        default: Any = NOT_PROVIDED,
         validators: Sequence[Callable[..., Any]] = (),
     ):
-        # `default` is intentionally not accepted: a str default on a bytes
-        # field is a type mismatch.
         self.max_length = max_length
         super().__init__(
             required=required,
             allow_null=allow_null,
+            default=default,
             validators=validators,
         )
         if self.max_length is not None:

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/fields/encrypted.py

@@ -16,11 +16,14 @@ except ImportError:
     hashes = None  # ty: ignore[invalid-assignment]
     PBKDF2HMAC = None  # ty: ignore[invalid-assignment]
 
-from plain import exceptions, preflight
+from plain import preflight
+from plain.postgres.lookups import Exact, IsNull
 from plain.runtime import settings
 from plain.utils.encoding import force_bytes
 
-from .base import ColumnField
+from .base import NOT_PROVIDED
+from .json import JSONField
+from .text import TextField
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
@@ -104,19 +107,12 @@ def _decrypt(value: str) -> str:
         )
 
 
-# isnull is obviously needed. exact is required so that `filter(field=None)`
-# works — the ORM resolves "exact" first and then rewrites None to isnull.
-# Exact lookups on non-None values will silently return no results (since
-# ciphertext is non-deterministic), but blocking exact entirely would break
-# the None/isnull path.
-_ALLOWED_LOOKUPS = {"isnull", "exact"}
-
-
 class EncryptedFieldMixin:
     """Shared behavior for all encrypted fields.
 
-    Blocks lookups (except isnull and exact) since encrypted values are non-deterministic.
-    Errors at preflight if the field is used in indexes or unique constraints.
+    Owns the lookup surface (isnull and exact only — ciphertext is
+    non-deterministic) and the preflight that blocks indexes and unique
+    constraints.
 
     Must be used with Field as a co-base class.
     """
@@ -125,17 +121,32 @@ class EncryptedFieldMixin:
     name: str
     model: Any
 
-    def get_lookup(self, lookup_name: str) -> type[Lookup] | None:
-        if lookup_name not in _ALLOWED_LOOKUPS:
-            return None
-        get_lookup = getattr(super(), "get_lookup")
-        return get_lookup(lookup_name)
-
-    def get_transform(
-        self, lookup_name: str
-    ) -> type[Transform] | Callable[..., Any] | None:
+    # The complete lookup surface, replacing the base field's registry.
+    # isnull is obviously needed. exact is required so that `filter(field=None)`
+    # works — the ORM resolves "exact" first and then rewrites None to isnull.
+    # Exact lookups on non-None values will silently return no results (since
+    # ciphertext is non-deterministic), but blocking exact entirely would break
+    # the None/isnull path. The base classes are named directly — inheriting
+    # the concrete field's registrations would leak specialized lookups like
+    # JSONField's JSONExact, which compares against the jsonb 'null' literal
+    # and defeats the None→isnull rewrite. get_lookup()/get_transform() and
+    # registry consumers (e.g. unsupported-lookup error suggestions) all
+    # resolve through this one dict. A classmethod so both class-level and
+    # instance-level callers work.
+    @classmethod
+    def get_lookups(cls) -> dict[str, type[Lookup | Transform]]:
+        return {"exact": Exact, "isnull": IsNull}
+
+    def get_transform(self, name: str) -> Callable[..., Transform] | None:
+        # JSONField's get_transform falls back to KeyTransformFactory for any
+        # name — key transforms would operate on ciphertext, so block them.
         return None
 
+    def preflight(self, **kwargs: Any) -> list[PreflightResult]:
+        errors: list[PreflightResult] = super().preflight(**kwargs)  # ty: ignore[unresolved-attribute]
+        errors.extend(self._check_encrypted_constraints())
+        return errors
+
     def _check_encrypted_constraints(self) -> list[PreflightResult]:
         errors: list[PreflightResult] = []
         if not hasattr(self, "model"):
@@ -178,20 +189,21 @@ class EncryptedFieldMixin:
         return errors
 
 
-class EncryptedTextField[T: (str, str | None) = str](
-    EncryptedFieldMixin, ColumnField[T]
-):
-    """A text field that encrypts its value before storing in the database.
+class EncryptedTextField[T: (str, str | None) = str](EncryptedFieldMixin, TextField[T]):
+    """A TextField that encrypts its value before storing in the database.
 
     Values are encrypted using Fernet (AES-128-CBC + HMAC-SHA256) with a key
     derived from SECRET_KEY. The database column is always ``text`` regardless
     of max_length, since ciphertext length is unpredictable.
 
     max_length is enforced on the plaintext value (validation), not on the
-    ciphertext stored in the database.
+    ciphertext stored in the database. Only ``default=""`` (with
+    ``required=False``) is accepted — empty strings are stored as plaintext
+    ``''``, so the empty value is the one default expressible as a column
+    DEFAULT; anything else would need ciphertext, which is non-deterministic.
     """
 
-    db_type_sql = "text"
+    only_empty_default = True
 
     def __init__(
         self,
@@ -199,40 +211,20 @@ class EncryptedTextField[T: (str, str | None) = str](
         max_length: int | None = None,
         required: bool = True,
         allow_null: bool = False,
+        default: Any = NOT_PROVIDED,
         validators: Sequence[Callable[..., Any]] = (),
     ):
-        # `default` is intentionally not accepted: Fernet encryption is
-        # non-deterministic, so a literal column DEFAULT cannot be expressed.
-        self.max_length = max_length
+        # Deliberately narrower than TextField: no `choices` — exact lookups
+        # on ciphertext are non-deterministic, so choice-based filtering would
+        # silently match nothing.
         super().__init__(
+            max_length=max_length,
             required=required,
             allow_null=allow_null,
+            default=default,
             validators=validators,
         )
 
-    def to_python(self, value: Any) -> str | None:
-        if isinstance(value, str) or value is None:
-            return value
-        return str(value)
-
-    def validate(self, value: Any, model_instance: Any) -> None:
-        super().validate(value, model_instance)
-        if (
-            self.max_length is not None
-            and value is not None
-            and len(value) > self.max_length
-        ):
-            raise exceptions.ValidationError(
-                f"Ensure this value has at most {self.max_length} characters (it has {len(value)}).",
-                code="max_length",
-            )
-
-    def get_prep_value(self, value: Any) -> Any:
-        value = super().get_prep_value(value)
-        if value is None:
-            return value
-        return self.to_python(value)
-
     def get_db_prep_value(
         self, value: Any, connection: DatabaseConnection, prepared: bool = False
     ) -> Any:
@@ -248,19 +240,8 @@ class EncryptedTextField[T: (str, str | None) = str](
             return value
         return _decrypt(value)
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
-        name, path, args, kwargs = super().deconstruct()
-        if self.max_length is not None:
-            kwargs["max_length"] = self.max_length
-        return name, path, args, kwargs
 
-    def preflight(self, **kwargs: Any) -> list[PreflightResult]:
-        errors = super().preflight(**kwargs)
-        errors.extend(self._check_encrypted_constraints())
-        return errors
-
-
-class EncryptedJSONField(EncryptedFieldMixin, ColumnField):
+class EncryptedJSONField(EncryptedFieldMixin, JSONField):
     """A JSONField that encrypts its serialized value before storing in the database.
 
     The JSON value is serialized to a string, encrypted, and stored as text.
@@ -268,7 +249,7 @@ class EncryptedJSONField(EncryptedFieldMixin, ColumnField):
     """
 
     db_type_sql = "text"
-    empty_strings_allowed = False
+    accepts_default = False
 
     def __init__(
         self,
@@ -279,47 +260,23 @@ class EncryptedJSONField(EncryptedFieldMixin, ColumnField):
         allow_null: bool = False,
         validators: Sequence[Callable[..., Any]] = (),
     ):
-        # `default` is intentionally not accepted: Fernet encryption is
-        # non-deterministic, so a literal column DEFAULT cannot be expressed.
-        if encoder and not callable(encoder):
-            raise ValueError("The encoder parameter must be a callable object.")
-        if decoder and not callable(decoder):
-            raise ValueError("The decoder parameter must be a callable object.")
-        self.encoder = encoder
-        self.decoder = decoder
+        # Deliberately narrower than JSONField: no `default` — there is no
+        # empty plaintext value (even {} serializes to text that would need
+        # ciphertext, which is non-deterministic), so no literal column
+        # DEFAULT can be expressed.
         super().__init__(
+            encoder=encoder,
+            decoder=decoder,
             required=required,
             allow_null=allow_null,
             validators=validators,
         )
 
-    def deconstruct(self) -> tuple[str | None, str, list[Any], dict[str, Any]]:
-        name, path, args, kwargs = super().deconstruct()
-        if self.encoder is not None:
-            kwargs["encoder"] = self.encoder
-        if self.decoder is not None:
-            kwargs["decoder"] = self.decoder
-        return name, path, args, kwargs
-
-    def validate(self, value: Any, model_instance: Any) -> None:
-        super().validate(value, model_instance)
-        try:
-            json.dumps(value, cls=self.encoder)
-        except TypeError:
-            raise exceptions.ValidationError(
-                "Value must be valid JSON.",
-                code="invalid",
-                params={"value": value},
-            )
-
-    def get_db_prep_value(
-        self, value: Any, connection: DatabaseConnection, prepared: bool = False
-    ) -> Any:
-        value = super().get_db_prep_value(value, connection, prepared)
+    def adapt_json_db_value(self, value: Any) -> Any:
+        # jsonb adaptation would emit jsonb — this column stores ciphertext.
         if value is None:
             return value
-        json_str = json.dumps(value, cls=self.encoder)
-        return _encrypt(json_str)
+        return _encrypt(json.dumps(value, cls=self.encoder))
 
     def from_db_value(
         self, value: Any, expression: Any, connection: DatabaseConnection
@@ -334,8 +291,3 @@ class EncryptedJSONField(EncryptedFieldMixin, ColumnField):
                 "Encrypted field contains data that is not valid JSON. "
                 "The stored value may be corrupt."
             )
-
-    def preflight(self, **kwargs: Any) -> list[PreflightResult]:
-        errors = super().preflight(**kwargs)
-        errors.extend(self._check_encrypted_constraints())
-        return errors

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/fields/json.py

@@ -83,6 +83,15 @@ class JSONField(DefaultableField):
             value = value.value
         elif hasattr(value, "as_sql"):
             return value
+        return self.adapt_json_db_value(value)
+
+    def adapt_json_db_value(self, value: Any) -> Any:
+        """Adapt a plain JSON value for this field's column — the one step
+        subclasses with a different column type (EncryptedJSONField) replace.
+
+        May receive None (get_db_prep_save short-circuits it, but other
+        get_db_prep_value callers don't): here it adapts to jsonb null;
+        EncryptedJSONField maps it to SQL NULL."""
         return adapt_json_value(value, self.encoder)
 
     def get_db_prep_save(self, value: Any, connection: DatabaseConnection) -> Any:
@@ -90,14 +99,12 @@ class JSONField(DefaultableField):
             return value
         return self.get_db_prep_value(value, connection)
 
-    def get_transform(
-        self, lookup_name: str
-    ) -> type[Transform] | Callable[..., Any] | None:
+    def get_transform(self, name: str) -> Callable[..., Transform] | None:
         # Always returns a transform (never None in practice)
-        transform = super().get_transform(lookup_name)
+        transform = super().get_transform(name)
         if transform:
             return transform
-        return KeyTransformFactory(lookup_name)
+        return KeyTransformFactory(name)
 
     def validate(self, value: Any, model_instance: Any) -> None:
         super().validate(value, model_instance)

{plain_postgres-0.112.0 → plain_postgres-0.113.0}/plain/postgres/fields/related.py

@@ -390,7 +390,8 @@ class ForeignKeyField(ColumnField, RelatedField):
             return (self.target_field.column, self.column)
         return (self.column, self.target_field.column)
 
-    def get_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
+    @cached_property
+    def path_infos(self) -> list[PathInfo]:
         """Get path from this field to the related model."""
         meta = self.remote_field.model._model_meta
         from_meta = self.model._model_meta
@@ -402,15 +403,11 @@ class ForeignKeyField(ColumnField, RelatedField):
                 join_field=self,
                 m2m=False,
                 direct=True,
-                filtered_relation=filtered_relation,
             )
         ]
 
     @cached_property
-    def path_infos(self) -> list[PathInfo]:
-        return self.get_path_info()
-
-    def get_reverse_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
+    def reverse_path_infos(self) -> list[PathInfo]:
         """Get path from the related model to this field's model."""
         meta = self.model._model_meta
         from_meta = self.remote_field.model._model_meta
@@ -423,14 +420,9 @@ class ForeignKeyField(ColumnField, RelatedField):
                 # The reverse of a foreign key always fans out to many rows.
                 m2m=True,
                 direct=False,
-                filtered_relation=filtered_relation,
             )
         ]
 
-    @cached_property
-    def reverse_path_infos(self) -> list[PathInfo]:
-        return self.get_reverse_path_info()
-
     def contribute_to_class(self, cls: type[Model], name: str) -> None:
         super().contribute_to_class(cls, name)
         setattr(cls, name, ForwardForeignKeyDescriptor(self))
@@ -870,9 +862,7 @@ class ManyToManyField(RelatedField):
 
         return name, path, args, kwargs
 
-    def _get_path_info(
-        self, direct: bool = False, filtered_relation: Any = None
-    ) -> list[PathInfo]:
+    def _get_path_info(self, direct: bool = False) -> list[PathInfo]:
         """Called by both direct and indirect m2m traversal."""
         int_model = self.remote_field.through
         # M2M through model fields are always ForeignKey
@@ -886,32 +876,20 @@ class ManyToManyField(RelatedField):
         )
         if direct:
             join1infos = linkfield1.reverse_path_infos
-            if filtered_relation:
-                join2infos = linkfield2.get_path_info(filtered_relation)
-            else:
-                join2infos = linkfield2.path_infos
+            join2infos = linkfield2.path_infos
         else:
             join1infos = linkfield2.reverse_path_infos
-            if filtered_relation:
-                join2infos = linkfield1.get_path_info(filtered_relation)
-            else:
-                join2infos = linkfield1.path_infos
+            join2infos = linkfield1.path_infos
 
         return [*join1infos, *join2infos]
 
-    def get_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
-        return self._get_path_info(direct=True, filtered_relation=filtered_relation)
-
     @cached_property
     def path_infos(self) -> list[PathInfo]:
-        return self.get_path_info()
-
-    def get_reverse_path_info(self, filtered_relation: Any = None) -> list[PathInfo]:
-        return self._get_path_info(direct=False, filtered_relation=filtered_relation)
+        return self._get_path_info(direct=True)
 
     @cached_property
     def reverse_path_infos(self) -> list[PathInfo]:
-        return self.get_reverse_path_info()
+        return self._get_path_info(direct=False)
 
     def _get_m2m_db_table(self) -> str:
         """