Struct BindingsProvider 

pub struct BindingsProvider { /* private fields */ }

Direct platform-specific bindings provider. Routes to appropriate platform implementations based on binding configuration.

Caches loaded bindings by name. Each load_* call creates cloud clients (HTTP connection pools, token caches) which are expensive to initialize. Since the binding configuration is immutable for the provider’s lifetime, the same binding name always produces the same client — so we cache on first load.

Postgres has different caching semantics because cloud handles contain a resolved password. Its dedicated runtime owns that policy and its secret-store clients.

Implementations

impl BindingsProvider

pub fn new( client_config: ClientConfig, bindings: HashMap<String, Value>, ) -> Result<Self>

Creates a new BindingsProvider with explicit credentials and bindings.

This is the base constructor used by all other convenience constructors.

pub fn client_config(&self) -> &ClientConfig

The workload’s resolved cloud credentials (native/projected identity or Alien-minted short-lived credentials). Consumers that need to authorize a request themselves — the AI gateway signs upstream model calls with this — read it here rather than going through a per-resource binding.

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

Creates a BindingsProvider from environment variables (for runtime use).

This parses the platform from ALIEN_DEPLOYMENT_TYPE, loads ClientConfig from environment, and extracts all ALIEN_*_BINDING environment variables.

pub fn from_env_lazy( env: HashMap<String, String>, ) -> Result<LazyEnvBindingsProvider>

Creates an environment-backed provider without resolving cloud client configuration yet.

Startup still validates the platform and binding JSON, but credentials are loaded only if application code asks for a binding or runtime-owned startup secrets need to be fetched.

pub fn from_env_deferred( env: HashMap<String, String>, ) -> Result<LazyEnvBindingsProvider>

Creates an environment-backed provider that defers all platform and cloud-client-config resolution to the first use of a configured binding.

This is the app-facing (napi / crate::Bindings) path. Its contract: constructing with zero environment must succeed, and the first operation against a binding that has no ALIEN_<NAME>_BINDING must report ErrorData::BindingNotConfigured before any platform or credential resolution — a missing binding is an application error, not a deployment misconfiguration. Binding JSON is still parsed here, so malformed config fails fast at construction.

Contrast with Self::from_env_lazy, which eagerly validates the deployment platform so long-running runtime processes fail fast at startup.

pub fn from_stack_state( stack_state: &StackState, client_config: ClientConfig, ) -> Result<Self>

Pattern 1: Creates a BindingsProvider from stack state and client config.

Convenience helper that extracts bindings from stack state’s remote_binding_params. Only resources with remote_access: true will have binding params available.

When to use: You already have ClientConfig and StackState.

Example use cases:

• alien-deployment (has credentials from RemoteAccessResolver)
• Platform API backend (has stack state from DB)

Trait Implementations

impl BindingsProviderApi for BindingsProvider

fn load_storage<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Storage>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Storage implementation.

fn load_build<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Build>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Build implementation.

fn load_artifact_registry<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ArtifactRegistry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds an ArtifactRegistry implementation.

fn load_vault<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Vault>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Vault implementation.

fn load_kv<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Kv>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a KV implementation.

fn load_postgres<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Postgres>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Postgres implementation.

fn load_queue<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Queue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Queue implementation.

fn load_worker<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Worker>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Worker implementation.

fn load_container<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Container>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a Container implementation.

fn load_service_account<'life0, 'life1, 'async_trait>( &'life0 self, binding_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ServiceAccount>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a binding identifier, builds a ServiceAccount implementation.

fn resolve_runtime_only_binding_env<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _binding_name: &'life1 str, _resource_type: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<HashMap<String, String>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Runtime-only binding env vars (a local Postgres connection with its password, a local BYO-key AI binding) for the given resource — re-resolved on every (re)start so the secret reaches the worker process but is never written to persisted worker metadata. The resource type routes resolution to the right local source. Default None: cloud providers carry a secret locator (not a raw secret) and use the normal persisted path.

impl Clone for BindingsProvider

fn clone(&self) -> BindingsProvider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BindingsProvider

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

Formats the value using the given formatter.