feat(moonapi): sub-dependencies in the DI container.

A dependency can now depend on another. Provider factories are handed the request
Scope, so a factory resolves its own dependencies through it — FastAPI's nested
Depends, where Depends(a) itself declares Depends(b). provide_using registers a
scope-aware factory; provide stays a leaf that ignores the scope, so existing
wiring is unchanged.

Sub-dependencies share the request's one-shot cache and unwind LIFO with the rest
(a sub-dependency built during its dependent is torn down after it), and a cycle is
broken with None rather than looping — the resolving key is tracked while its
factory runs. 122 tests on all backends; the scope-sharing is mutation-checked
(handing the factory a fresh scope breaks both sharing and cycle detection).

Signed-off-by: 林晨 (Leo Cheng) <chengkelfan@qq.com>

Author: Lfan-ke

di.mbt

@@ -7,25 +7,38 @@
 // that type; for several, `V` is a user-defined sum type wrapping them — the
 // exhaustive, type-safe stand-in for Python's dynamic `Any` (cf. axum's typemap
 // + downcast, Go's `interface{}` + type assertion). Everything else — the
-// registry, request-scoped one-shot resolution, `yield`-style teardown, and
-// `dependency_overrides` — is modelled faithfully.
+// registry, request-scoped one-shot resolution, sub-dependencies (a factory
+// resolving others through the scope, with cycle detection), `yield`-style
+// teardown, and `dependency_overrides` — is modelled faithfully.
 
 ///|
 /// A provider: a keyed factory that builds a request-scoped dependency value,
 /// with an optional teardown run after the handler (FastAPI's `yield`
 /// dependencies, whose post-`yield` body is cleanup). The `factory` runs at most
-/// once per request scope; the `teardown` receives the produced value.
+/// once per request scope; the `teardown` receives the produced value. The factory
+/// is handed the `Scope` so it can resolve *sub-dependencies* through it — FastAPI's
+/// `Depends(a)` where `a` itself declares `Depends(b)`.
 pub(all) struct Provider[V] {
-  factory : () -> V
+  factory : (Scope[V]) -> V
   teardown : (V) -> Unit
 }
 
 ///|
-/// Build a provider. `teardown` defaults to a no-op — the common "plain value,
-/// nothing to release" case.
+/// Build a leaf provider whose factory needs nothing else. `teardown` defaults to
+/// a no-op — the common "plain value, nothing to release" case.
 pub fn[V] Provider::new(
   factory : () -> V,
   teardown? : (V) -> Unit = _v => (),
+) -> Provider[V] {
+  { factory: _scope => factory(), teardown }
+}
+
+///|
+/// Build a provider whose factory resolves other dependencies through the request
+/// `Scope` it is handed — the sub-dependency case (FastAPI's nested `Depends`).
+pub fn[V] Provider::scoped(
+  factory : (Scope[V]) -> V,
+  teardown? : (V) -> Unit = _v => (),
 ) -> Provider[V] {
   { factory, teardown }
 }
@@ -59,6 +72,20 @@ pub fn[V] Container::provide(
   self
 }
 
+///|
+/// Register a base provider whose factory resolves sub-dependencies through the
+/// request scope it is handed (FastAPI's nested `Depends`). Otherwise like
+/// `provide`.
+pub fn[V] Container::provide_using(
+  self : Container[V],
+  key : String,
+  factory : (Scope[V]) -> V,
+  teardown? : (V) -> Unit = _v => (),
+) -> Container[V] {
+  self.providers[key] = Provider::scoped(factory, teardown~)
+  self
+}
+
 ///|
 /// Register a dependency override for `key` — FastAPI's
 /// `app.dependency_overrides[dep] = fake`. Takes precedence over the base
@@ -105,13 +132,14 @@ fn[V] Container::resolve(self : Container[V], key : String) -> Provider[V]? {
 pub struct Scope[V] {
   container : Container[V]
   cache : Map[String, V]
+  building : Map[String, Bool]
   teardowns : Array[() -> Unit]
 }
 
 ///|
 /// Open a fresh request scope over this container.
 pub fn[V] Container::open_scope(self : Container[V]) -> Scope[V] {
-  { container: self, cache: Map([]), teardowns: [] }
+  { container: self, cache: Map([]), building: Map([]), teardowns: [] }
 }
 
 ///|
@@ -122,17 +150,25 @@ pub fn[V] Container::open_scope(self : Container[V]) -> Scope[V] {
 pub fn[V] Scope::get(self : Scope[V], key : String) -> V? {
   match self.cache.get(key) {
     Some(v) => Some(v)
-    None =>
+    None => {
+      // A key already mid-build has been re-entered: a circular dependency.
+      // Break it with `None` rather than looping (FastAPI raises here).
+      if self.building.get(key) is Some(_) {
+        return None
+      }
       match self.container.resolve(key) {
         None => None
         Some(prov) => {
-          let v = (prov.factory)()
+          self.building[key] = true
+          let v = (prov.factory)(self)
+          self.building.remove(key)
           self.cache[key] = v
           let td = prov.teardown
           self.teardowns.push(() => td(v))
           Some(v)
         }
       }
+    }
   }
 }
 

di_wbtest.mbt

@@ -97,6 +97,63 @@ test "DI: a dependency is built once per request scope (cached)" {
   assert_eq(log.length(), 1)
 }
 
+///|
+test "DI: a dependency resolves a sub-dependency through the scope, LIFO teardown" {
+  let log : Array[String] = []
+  let c : Container[Dep] = Container::new()
+  c.provide(
+    "prefix",
+    () => {
+      log.push("build prefix")
+      Greeting("Hi")
+    },
+    teardown=_v => log.push("td prefix"),
+  )
+  |> ignore
+  c.provide_using(
+    "full",
+    scope => {
+      log.push("build full")
+      let p = match scope.get("prefix") {
+        Some(Greeting(s)) => s
+        _ => "?"
+      }
+      Greeting(p + ", there")
+    },
+    teardown=_v => log.push("td full"),
+  )
+  |> ignore
+  let scope = c.open_scope()
+  // Resolving "full" pulls in "prefix" through the scope.
+  assert_eq(scope.get("full") == Some(Greeting("Hi, there")), true)
+  // "prefix" was built once during "full"; asking again returns the cache.
+  assert_eq(scope.get("prefix") == Some(Greeting("Hi")), true)
+  scope.close()
+  // prefix built while full resolved (before full); teardown LIFO -> full, then prefix.
+  assert_eq(log == ["build full", "build prefix", "td full", "td prefix"], true)
+}
+
+///|
+test "DI: a circular sub-dependency breaks with None instead of looping" {
+  let c : Container[Dep] = Container::new()
+  c.provide_using("a", scope => {
+    let _ = scope.get("b")
+    Greeting("a")
+  })
+  |> ignore
+  c.provide_using("b", scope => {
+    let _ = scope.get("a")
+    Greeting("b")
+  })
+  |> ignore
+  let scope = c.open_scope()
+  // get(a) -> builds b -> b asks for a (mid-build) -> None breaks the cycle,
+  // so both still resolve without looping.
+  assert_eq(scope.get("a") == Some(Greeting("a")), true)
+  assert_eq(scope.get("b") == Some(Greeting("b")), true)
+  scope.close()
+}
+
 ///|
 test "DI: dependency_overrides shadow the base provider, then restore" {
   let c : Container[Dep] = Container::new()