Resolve injectable types within DynProvider::with_ctx closures using FactoryCtx.
npx skills add https://github.com/jymchng/injectable --skill factory-ctx
Please help me install this Agent Skill. Skill: factory-ctx Source: https://github.com/jymchng/injectable/tree/main/skills/factory-ctx Command: npx skills add https://github.com/jymchng/injectable --skill factory-ctx
The Skill addresses the need for scoped resolution of injectable types within dynamic provider contexts, ensuring that dependencies are resolved in a safe and efficient manner without bypassing the singleton cache.
DynProvider::with_ctx closures.FactoryCtx is a useful tool.To utilize FactoryCtx, include the following in your Skill code:
let container = Container::builder()
.register(DynProvider::with_ctx(|ctx| async move {
// Resolve AppConfig via FactoryCtx
let cfg: Inject<AppConfig> = ctx.extract().await?;
// Further operations...
}))
.build().await?;
High-intent search queries and answers about installing and using this skill.
You resolve injectable types within dynamic provider contexts by using FactoryCtx, which ensures safe dependency management without bypassing the singleton cache during scoped resolution.
Scope-safe dependency injection ensures dependencies resolve within their intended scope. You need it when dynamic provider factories must resolve injectable types without affecting the singleton cache.
You use `ctx.extract().await` inside the `DynProvider::with_ctx` closure to resolve injectable types like AppConfig safely within the dynamic provider's scoped context.
Yes, scoped resolution supports both singleton and transient dependencies. FactoryCtx provides scoped access to these injectable types within dynamic provider contexts in Rust injection frameworks.
Dynamic providers bypass the singleton cache without scoped resolution. FactoryCtx prevents this by ensuring singleton dependencies resolve within their intended scope during dependency management.
choyinyConfigure dependency injection for Angular v20+ applications.
jymchngInitialize complex Rust types with constructor injection and async support.
jymchngGuide cloning, destructuring, and singleton assertions for Rust's Inject<T> wrapper.
jymchngAutomates Rust struct dependency injection via #[injectable] and Container builder.