Struct Forgettable 

pub struct Forgettable<T>(/* private fields */);

Wrapper for event fields containing data that can be forgotten (e.g., for GDPR).

This is an opaque struct — internal state is private so callers cannot pattern-match to extract the raw value. Use Forgettable::value() to get a ForgettableRef that derefs to T but does not implement Serialize, preventing accidental re-serialization of personal data.

Serde Behavior

• Both set and forgotten values serialize as null to prevent data leakage when events are serialized to secondary stores.
• Deserializing null produces a forgotten value, non-null produces a set value.
• Real values are extracted via [__extract_payload_value] before serde runs, and stored in the forgettable payloads table.

JSON Schema

With the json-schema feature enabled, Forgettable<T> implements schemars::JsonSchema by delegating to Option<T>, matching the value-or-null serialized shape — no field-level #[schemars(with = ...)] is needed on containing types.

Repository Guard

An event type with Forgettable<T> fields must be backed by a repository that enables forgettable in #[es_repo(...)]; otherwise the payloads are never scrubbed. The repository derive cannot see the event’s forgettable-ness at macro time, so for a repository that omits the flag it emits a const assertion on the event’s inherent HAS_FORGETTABLE_FIELDS. This is that assertion verbatim, and it fails to compile because the event is forgettable:

use es_entity::*;
use serde::{Deserialize, Serialize};

es_entity::entity_id! { UserId }

#[derive(EsEvent, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[es_event(id = "UserId")]
pub enum UserEvent {
    Initialized { id: UserId, name: Forgettable<String> },
}

const _: () = assert!(
    !UserEvent::HAS_FORGETTABLE_FIELDS,
    "event type has Forgettable fields but this repo does not enable `forgettable`; add `forgettable` to #[es_repo(...)]"
);

Example

use es_entity::Forgettable;

let name: Forgettable<String> = Forgettable::new("Alice".to_string());
assert_eq!(&*name.value().unwrap(), "Alice");

let forgotten: Forgettable<String> = Forgettable::forgotten();
assert!(forgotten.value().is_none());

Implementations

impl<T> Forgettable<T>

pub fn new(value: T) -> Self

Creates a new Forgettable containing the given value.

pub fn forgotten() -> Self

Creates a forgotten (empty) Forgettable.

pub fn value(&self) -> Option<ForgettableRef<'_, T>>

Returns a ForgettableRef wrapping the inner value, or None if forgotten.

ForgettableRef implements Deref<Target = T> but not Serialize, so you can read the value but cannot accidentally serialize it.

pub fn is_set(&self) -> bool

Returns true if the value is present.

pub fn is_forgotten(&self) -> bool

Returns true if the value has been forgotten.

Trait Implementations

impl<T: Clone> Clone for Forgettable<T>

fn clone(&self) -> Forgettable<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Forgettable<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Forgettable<T>

fn default() -> Self

Returns a forgotten (empty) Forgettable.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Forgettable<T>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Eq> Eq for Forgettable<T>

impl<T> From<T> for Forgettable<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Forgettable<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Forgettable<T>

fn eq(&self, other: &Forgettable<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: Serialize> Serialize for Forgettable<T>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: PartialEq> StructuralPartialEq for Forgettable<T>