Use Cases

Step 1: Write Your Code

repositories/IUserRepository.ts

export interface IUserRepository {
  findById(id: string): Promise<User | null>;
  save(user: User): Promise<void>;
}

// repositories/UserRepository.ts
export class UserRepository implements IUserRepository {
  async findById(id: string) { /* ... */ }
  async save(user: User) { /* ... */ }
}

// use-cases/CreateUserUseCase.ts
// ✅ No interface needed - direct class
export class CreateUserUseCase {
  constructor(
    private userRepository: IUserRepository,
    private emailService: IEmailService
  ) {}
  async execute(name: string, email: string) { /* ... */ }
}

// use-cases/UserController.ts
// ✅ No interface needed - direct class
export class UserController {
  constructor(
    private createUserUseCase: CreateUserUseCase,
    private getUserUseCase: GetUserUseCase
  ) {}
  async createUser(name: string, email: string) { /* ... */ }
}

Step 2: Generate Container

npx @notjustcoders/ioc-arise generate

Step 3: Generated Code

container.gen.d.ts:

export interface ContainerRegistry {
  'IUserRepository': IUserRepository;
  'IEmailService': IEmailService;
  'CreateUserUseCase': CreateUserUseCase;
  'GetUserUseCase': GetUserUseCase;
  'UserController': UserController;
}

container.gen.ts:

import { Container, Lifecycle } from '@notjustcoders/di-container';
import type { ContainerRegistry } from './container.gen.d';
import { UserRepository } from './repositories/UserRepository';
import { CreateUserUseCase } from './use-cases/CreateUserUseCase';
import { UserController } from './use-cases/UserController';

export const container = new Container<ContainerRegistry>();

// Interface-based (string token)
container.register('IUserRepository', {
  useClass: UserRepository,
  lifecycle: Lifecycle.Singleton
});

// Direct class (no interface)
container.register(CreateUserUseCase, {
  useClass: CreateUserUseCase,
  dependencies: ['IUserRepository', 'IEmailService'],
  lifecycle: Lifecycle.Singleton
});

container.register(UserController, {
  useClass: UserController,
  dependencies: [CreateUserUseCase, GetUserUseCase],
  lifecycle: Lifecycle.Singleton
});

Step 4: Use It

import { container } from './container.gen';

// Resolve by interface (string token)
const userRepo = container.resolve('IUserRepository');
//    ^? IUserRepository

// Resolve by class (direct)
const controller = container.resolve(UserController);
//    ^? UserController

await controller.createUser('John Doe', 'john@example.com');