feat: explicit injection context in inheritance helpers

Author: bebrasmell

.vscode/symbols.json

@@ -387,14 +387,16 @@ function injectAsync<T>(
   options?: {
     withCache?: boolean;
     overrides?: Provider[];
+    injector?: iInjector;
   }
 ): () => Promise<T | T[]>
 ```
 
-| Option      | Type         | Default | Description                                |
-| ----------- | ------------ | ------- | ------------------------------------------ |
-| `withCache` | `boolean`    | `true`  | Cache the resolved instance                |
-| `overrides` | `Provider[]` | `[]`    | Additional providers for the sub-container |
+| Option      | Type         | Default     | Description                                |
+| ----------- | ------------ | ----------- | ------------------------------------------ |
+| `withCache` | `boolean`    | `true`      | Cache the resolved instance                |
+| `overrides` | `Provider[]` | `[]`        | Additional providers for the sub-container |
+| `injector`  | `iInjector`  | `undefined` | Explicit injector to use instead of context|
 
 ```typescript
 private readonly getAnalytics = injectAsync(
@@ -417,6 +419,7 @@ function injectGroupAsync(
   options?: {
     withCache?: boolean;
     overrides?: Provider[];
+    injector?: iInjector;
   }
 ): () => Promise<iInjector>
 ```
@@ -442,6 +445,7 @@ function injectEntryAsync<T>(
   options?: {
     withCache?: boolean;
     overrides?: Provider[];
+    injector?: iInjector;
   }
 ): () => Promise<T | T[]>
 ```

docs/API.md

@@ -7,6 +7,7 @@ This guide covers advanced dependency injection patterns using `injectAsync`, `i
 - [🔗 Async Injection \& Sub-Containers](#-async-injection--sub-containers)
   - [Table of contents](#table-of-contents)
   - [Overview](#overview)
+    - [Explicit Injector Context](#explicit-injector-context)
   - [injectAsync](#injectasync)
     - [Basic usage](#basic-usage)
     - [Use cases](#use-cases)
@@ -55,6 +56,20 @@ All utilities support:
 - ✅ Full type inference
 - ✅ Dependency overrides
 - ✅ Parent container access
+- ✅ Optional explicit injector context
+
+### Explicit Injector Context
+
+By default, `injectAsync` inherits from the injector of the current context. You can manually specify a parent injector using the `injector` option. This is useful when creating factories outside of the injection context or when you want to use a specific injector instance.
+
+```typescript
+const getService = injectAsync(
+  async () => MyService,
+  { injector: myParentInjector }
+);
+
+const service = await getService();
+```
 
 ## injectAsync
 

docs/ASYNC_INJECTION.md

@@ -14,12 +14,20 @@ interface iInjectionOptions {
    * @default true
    */
   withCache?: boolean;
+
   /**
    * Overrides to provide to the sub-container
    * These will be provided in addition to the main injection
    * @default []
    */
   overrides?: Provider[];
+
+  /**
+   * Allows to use the function with specified injector outside of Injection Context.
+   * By default, the injector is obtained from the current injection context.
+   * @default undefined
+   */
+  injector?: iInjector;
 }
 
 /**
@@ -37,7 +45,7 @@ export function injectGroupAsync(
   fn: MaybeAsyncFactory<Provider[]>,
   opts?: iInjectionOptions,
 ): () => Promise<iInjector> {
-  const { container: parent } = nodeInject(Injector);
+  const { container: parent } = opts?.injector ?? nodeInject(Injector);
   const factory = async () => {
     const providers = await fn();
 
@@ -88,7 +96,7 @@ export function injectAsync<T>(
   fn: MaybeAsyncFactory<Token<T>>,
   opts?: iInjectionOptions,
 ): () => Promise<T | T[]> {
-  const { container: parent } = nodeInject(Injector);
+  const { container: parent } = opts?.injector ?? nodeInject(Injector);
   const factory = (async () => {
     const token = await fn();
     const tempContainer = new NodeContainer({ parent });
@@ -143,7 +151,7 @@ export function injectEntryAsync<T>(
   fn: MaybeAsyncFactory<iEntrypointConfig<Token<T>>>,
   opts?: iInjectionOptions,
 ): () => Promise<T | T[]> {
-  const { container: parent } = nodeInject(Injector);
+  const { container: parent } = opts?.injector ?? nodeInject(Injector);
   const factory = (async () => {
     const { entrypoint, providers } = await fn();