Struct AttributeMap 

pub struct AttributeMap<T> { /* private fields */ }

Defines keyed durable values sharing one Attribute name.

Each instance identifies an independent stored value and lock. Add the map definition once to crate::PersistenceSchema, then pass an instance on each access. Slash is prohibited in instance keys because it is a reserved character.

Implementations

impl<T> AttributeMap<T>

pub fn new(name: impl Into<String>) -> Self

Defines an unindexed Attribute map with a stable name.

Slash is prohibited because it is a reserved character.

pub fn indexed(self, index: AttributeIndex) -> Self

Enables search indexing for every instance using the selected index type.

pub fn sync_to_attribute_store(self) -> Self

Enables asynchronous latest-state projection for every AttributeMap instance.

Each instance maps by its physical Attribute name. The Flow must select a server-configured stores with FlowConfig::attribute_store_names. Deletions project SQL NULL, and projection failures never roll back Flow Attribute writes.

pub fn hard_delete_on_null(self) -> Self

where T: 'static,

Stores every instance’s values only in the Dex blob store and permanently deletes an instance’s stored value when that instance is deleted or set to null.

Use this option for keyed short-lived secrets, such as one API key per tenant. Each instance has its own stored value. Dex never writes instance values into Flow history. Self::delete and a write whose value encodes to null permanently delete the instance’s stored value. The instance then reads as absent. Handlers and Attribute reads receive values inline. The SDK never stores them in the local BlobCache.

Only string and object values, including bytes, are supported. Numeric and Boolean values are rejected. This option cannot be combined with Self::indexed or Self::sync_to_attribute_store. Client::wait_for_attribute_map_instance_match rejects it before it contacts Dex. Action and Action permission conditions cannot read it. Writes require a Server with an enabled blob store and protocol version 3 or later. Each instance key keeps one stored copy, and later writes overwrite it in place.

Supported values, restrictions, Server requirements, and limitations are otherwise the same as for Attribute::hard_delete_on_null. Read that method before storing secrets.

Examples

use dex_sdk::{AttributeMap, Context, HandlerResult, PersistenceSchema, StartFlowOptions};
use std::sync::LazyLock;

static TENANT_API_KEYS: LazyLock<AttributeMap<String>> =
    LazyLock::new(|| AttributeMap::new("tenant-api-keys").hard_delete_on_null());

let schema = PersistenceSchema::new().attribute_map(&TENANT_API_KEYS);
let options = StartFlowOptions::new().initial_attribute_map(
    &TENANT_API_KEYS,
    "tenant-1",
    "key-1".to_owned(),
);

// The Step or RPC must load the instance before reading it.
fn revoke_tenant_api_key(context: &mut Context, tenant: &str) -> HandlerResult<()> {
    if TENANT_API_KEYS.get(context, tenant)?.is_some() {
        TENANT_API_KEYS.delete(context, tenant)?;
    }
    Ok(())
}

pub fn load(&self, instance: impl Into<String>) -> AttributeMapLoad

Selects one slash-free map instance for loading into a handler Context.

The instance remains readable for the handler even when it is absent; absence is returned as None. Load the map definition when the RPC must enumerate every instance.

pub fn get(&self, context: &Context, instance: &str) -> HandlerResult<Option<T>>

where T: Value,

Reads one instance, returning Ok(None) when it is absent.

Errors

Returns HandlerError when the payload cannot be decoded.

pub fn get_required( &self, context: &Context, instance: &str, ) -> HandlerResult<T>

where T: Value,

Reads one instance and treats absence as an error.

Errors

Returns HandlerError when the instance is missing or cannot be decoded.

pub fn set( &self, context: &mut Context, instance: &str, value: T, ) -> HandlerResult<()>

where T: Value,

Stages one instance value for durable persistence.

Errors

Returns HandlerError when the value cannot be encoded or indexed.

pub fn delete(&self, context: &mut Context, instance: &str) -> HandlerResult<()>

Stages deletion of one instance; missing instances are valid.

pub fn map_size(&self, context: &Context) -> HandlerResult<usize>

Returns the effective number of instances, including buffered writes.

pub fn all_instance_keys(&self, context: &Context) -> HandlerResult<Vec<String>>

Returns decoded effective instance keys in ascending string order.

pub fn lock(&self, instance: impl Into<String>) -> AttributeLock

Creates a lock request scoped to one map instance.

Trait Implementations

impl<T> Clone for AttributeMap<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.