Struct Bindings 

pub struct Bindings { /* private fields */ }

App-facing entry point for accessing bindings configured via ALIEN_*_BINDING environment variables.

Construction is synchronous and only validates each configured binding’s JSON shape (see BindingsProvider::from_env_deferred); the deployment platform, cloud client configuration, and each binding’s backing client are resolved lazily, on first use. A first operation against a binding that is not configured reports BINDING_NOT_CONFIGURED before any platform resolution, so a zero-environment process still constructs and fails cleanly.

Examples

This is the canonical usage for a Container/Daemon-shaped app (a long-running resident process that only needs bindings, with no Worker event handlers):

use alien_bindings::Bindings;
use object_store::{path::Path, PutPayload};

let bindings = Bindings::from_env()?;

let storage = bindings.storage("files").await?;
storage
    .put(&Path::from("greeting.txt"), PutPayload::from_static(b"hello"))
    .await?;

Implementations

impl Bindings

pub fn from_env() -> Result<Self>

Sync-constructs Bindings from the current process environment.

pub fn from_env_map(env: HashMap<String, String>) -> Result<Self>

Sync-constructs Bindings from an explicit environment map instead of the process environment.

This is public for embedders that resolve bindings from a caller-supplied map rather than std::env — notably the napi addon, which merges std::env::vars() with per-call overrides before constructing Bindings. It is also what from_env delegates to and what this module’s tests use to inject ALIEN_*_BINDING variables (avoiding process-global state that’s unsafe to share across parallel tests).

pub async fn storage(&self, binding_name: &str) -> Result<Arc<dyn Storage>>

Loads the object storage binding named binding_name.

The returned handle checks credential freshness before each operation. Native credentials and fresh minted credentials remain cached; a minted provider inside its refresh window is re-minted once under the shared resolver’s single-flight guard.

pub async fn kv(&self, binding_name: &str) -> Result<Arc<dyn Kv>>

Loads a key-value binding that refreshes minted credentials before use.

pub async fn queue(&self, binding_name: &str) -> Result<BoundQueue>

Loads a queue binding that refreshes minted credentials before use.

pub async fn vault(&self, binding_name: &str) -> Result<Arc<dyn Vault>>

Loads a vault binding that refreshes minted credentials before use.

pub async fn container(&self, binding_name: &str) -> Result<Arc<dyn Container>>

Loads a linked container for read-only service discovery.

pub async fn postgres(&self, binding_name: &str) -> Result<Arc<dyn Postgres>>

Loads the connection details for a linked Postgres database.

Unlike the other kinds this returns no operations — Postgres has no gRPC service and every backend speaks the same wire protocol, so the handle carries connection details and the application connects with its own driver.

The Local and External backends carry their password inline in the binding environment variable, so their handle is resolved once and then cached.

The three cloud backends carry only a locator for their password and read it from the cloud secret store on every call — their handle is never cached. There is no refreshing wrapper, so a handle keeps the password that was current when it was created and calling this again is what picks up a rotated one. Each call is therefore one secret-store read: hold the returned handle for the lifetime of a connection pool rather than calling this per query.

Trait Implementations

impl Debug for Bindings

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

Formats the value using the given formatter.