IoC Arise

Get Started in 3 Simple Steps

1. Create Your Interfaces and Classes

   Organize your TypeScript interfaces and classes with proper dependency injection patterns:

   • Directorysrc/

     • Directoryuser/

       • Directoryinterfaces/

         • IUserService.ts
         • IUserRepository.ts
       • Directoryservices/

         • UserService.ts
         • UserRepository.ts
     • Directorytodo/

       • Directoryinterfaces/

         • ITodoService.ts
         • ITodoRepository.ts
       • Directoryservices/

         • TodoService.ts
         • TodoRepository.ts

   Each service class uses constructor injection for its dependencies:

   export class UserService implements IUserService {
     constructor(private userRepository: IUserRepository) {}
   }
   export class TodoService implements ITodoService {
     constructor(
       private todoRepository: ITodoRepository,
       private userRepository: IUserRepository
     ) {}
   }

2. Configure Your IoC Modules

   Create an ioc.config.json file to define your dependency injection modules:

   {
     "source": ".",
     "modules": {
       "UserModule": [
         "user/**"
       ],
       "TodoModule": [
         "todo/**"
       ]
     }
   }

3. Generate Your Container

   Run the IoC Arise command to automatically generate your type-safe container:

   npx @notjustcoders/ioc-arise generate

   This generates a type-safe container with all dependencies automatically resolved:

   // container.gen.ts (generated)
   import { createUserModuleContainer } from './UserModule.gen';
   import { createTodoModuleContainer } from './TodoModule.gen';
   
   const userModuleContainer = createUserModuleContainer();
   const todoModuleContainer = createTodoModuleContainer(userModuleContainer);
   
   export const container = {
     userModule: userModuleContainer,
     todoModule: todoModuleContainer
   };
   
   export type Container = typeof container;

   Then use your generated container in your application:

   import { container } from './container.gen';
   
   // Get fully resolved instances with all dependencies injected
   const userService = container.userModule.UserService;
   const user = await userService.createUser('John Doe', 'john@example.com');
   
   const todoService = container.todoModule.TodoService;
   const todo = await todoService.createTodo('Learn IoC Arise', user.id);

🚀 Zero Configuration

No decorators, annotations, or manual wiring required. Write pure TypeScript classes and interfaces - IoC Arise automatically discovers and wires your dependencies.

🔒 100% Type Safe

Generated containers are fully typed with compile-time validation. Get IntelliSense autocompletion and catch dependency errors before runtime.

⚡ Blazing Fast

Powered by AST-grep (built with Rust) for lightning-fast AST parsing and analysis. Generates optimized dependency containers in milliseconds with zero runtime overhead.

🎯 Smart Dependency Analysis

Automatically detects circular dependencies, missing implementations, and provides clear error messages with suggested fixes.

🏗️ Modular Architecture

Organize code into logical modules with cross-module dependency support. Perfect for microservices and large-scale applications.

🔄 Zero Coupling

Your business logic stays clean and framework-agnostic. No vendor lock-in - remove IoC Arise anytime without code changes.