decorator-dependency-injection 1.0.5 → 1.0.6

package/README.md

@@ -353,6 +353,51 @@ import {clearContainer} from 'decorator-dependency-injection';
 clearContainer(); // Removes all registered singletons, factories, and mocks
 ```
 
+### Resolving Dependencies Without Decorators
+
+The `resolve` function allows non-class code (plain functions, modules, callbacks, etc.) to retrieve instances from the DI container:
+
+```javascript
+import {Singleton, Factory, resolve} from 'decorator-dependency-injection';
+
+@Singleton()
+class UserService {
+  getUser(id) {
+    return { id, name: 'John' }
+  }
+}
+
+@Factory()
+class Logger {
+  constructor(prefix) {
+    this.prefix = prefix
+  }
+  log(msg) {
+    console.log(`[${this.prefix}] ${msg}`)
+  }
+}
+
+// Use in plain functions
+function handleRequest(req) {
+  const userService = resolve(UserService)
+  return userService.getUser(req.userId)
+}
+
+// Use with factory parameters
+function createLogger(moduleName) {
+  return resolve(Logger, moduleName)
+}
+
+// Use with named registrations
+const db = resolve('databaseConnection')
+```
+
+This is useful when:
+- Integrating with frameworks that don't support decorators
+- Writing utility functions that need DI access
+- Bridging between decorator-based and non-decorator code
+- Testing or debugging the container directly
+
 ### Validation Helpers
 
 The library provides utilities to validate registrations at runtime, which is useful for catching configuration 
@@ -529,4 +574,5 @@ npm test
 - 1.0.2 - Added proxy option to @Mock decorator
 - 1.0.3 - Added @InjectLazy decorator
 - 1.0.4 - Added Container abstraction, clearContainer(), TypeScript definitions, improved proxy support
-- 1.0.5 - Added private field and accessor support for @Inject and @InjectLazy, debug mode, validation helpers
+- 1.0.5 - Added private field and accessor support for @Inject and @InjectLazy, debug mode, validation helpers
+- 1.0.6 - Added resolve() function for non-decorator code

package/index.d.ts

@@ -60,6 +60,12 @@ export declare class Container {
    */
   has<T>(clazzOrName: InjectionToken<T>): boolean
 
+  /**
+   * Resolve and return an instance by class or name.
+   * This allows non-decorator code to retrieve instances from the container.
+   */
+  resolve<T>(clazzOrName: InjectionToken<T>, ...params: any[]): T
+
   /**
    * Get or create an instance based on the context.
    */
@@ -217,6 +223,29 @@ export declare function isRegistered<T>(clazzOrName: InjectionToken<T>): boolean
  */
 export declare function validateRegistrations<T extends InjectionToken[]>(...tokens: T): void
 
+/**
+ * Resolve and return an instance by class or name.
+ * This allows non-decorator code (plain functions, modules, etc.) to retrieve
+ * instances from the DI container.
+ *
+ * @param clazzOrName The class or name to resolve
+ * @param params Optional parameters to pass to the constructor
+ * @returns The resolved instance
+ * @throws Error if the class or name is not registered
+ *
+ * @example
+ * // In a plain function:
+ * function handleRequest(req: Request) {
+ *   const userService = resolve(UserService)
+ *   return userService.getUser(req.userId)
+ * }
+ *
+ * @example
+ * // With a named registration:
+ * const db = resolve<Database>('database')
+ */
+export declare function resolve<T>(clazzOrName: InjectionToken<T>, ...params: any[]): T
+
 /**
  * Create a proxy that delegates to the mock first, then falls back to the original.
  * This is an internal utility but exported for advanced use cases.

package/index.js

@@ -313,6 +313,33 @@ export function validateRegistrations(...tokens) {
   }
 }
 
+/**
+ * Resolve and return an instance by class or name.
+ * This allows non-decorator code (plain functions, modules, etc.) to retrieve
+ * instances from the DI container.
+ *
+ * @template T
+ * @param {string|Function} clazzOrName The class or name to resolve
+ * @param {...*} params Parameters to pass to the constructor
+ * @returns {T} The resolved instance
+ * @throws {Error} If the class or name is not registered
+ * @example
+ * // In a plain function:
+ * function handleRequest(req) {
+ *   const userService = resolve(UserService)
+ *   return userService.getUser(req.userId)
+ * }
+ * @example
+ * // With a named registration:
+ * const db = resolve('database')
+ * @example
+ * // With factory parameters:
+ * const logger = resolve(Logger, 'my-module')
+ */
+export function resolve(clazzOrName, ...params) {
+  return defaultContainer.resolve(clazzOrName, ...params)
+}
+
 // Export Container class for advanced use cases (e.g., isolated containers)
 export {Container}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decorator-dependency-injection",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "A simple library for dependency injection using decorators",
   "author": "Ravi Gairola <mallox@pyxzl.net>",
   "license": "Apache-2.0",

package/src/Container.js

@@ -106,6 +106,20 @@ export class Container {
     return this.#instances.has(clazzOrName)
   }
 
+  /**
+   * Resolve and return an instance by class or name.
+   * This allows non-decorator code to retrieve instances from the container.
+   * @template T
+   * @param {string|Function} clazzOrName The class or name to resolve
+   * @param {...*} params Parameters to pass to the constructor
+   * @returns {T} The resolved instance
+   * @throws {Error} If the class or name is not registered
+   */
+  resolve(clazzOrName, ...params) {
+    const instanceContext = this.getContext(clazzOrName)
+    return this.getInstance(instanceContext, params)
+  }
+
   /**
    * Get or create an instance based on the context.
    * @param {InstanceContext} instanceContext The instance context