nest_core

Core dependency injection and module system for Nest Dart - a NestJS-inspired framework for Dart applications.

Features

🏗️ Modular Architecture - Organize code into reusable, self-contained modules
💉 Dependency Injection - Type-safe service resolution with access control
🔄 Lifecycle Management - Module initialization and cleanup hooks
🔒 Export Control - Services are private by default, must be explicitly exported
⚡ Performance - Minimal overhead with compile-time safety

Installation

Add nest_core to your pubspec.yaml:

dependencies:
  nest_core: ^0.1.1

Quick Start

1. Create a Service

class LoggerService {
  void log(String message) {
    print('[LOG] ${DateTime.now()}: $message');
  }
}

2. Create a Module

import 'package:nest_core/nest_core.dart';

class CoreModule extends Module {
  @override
  Future<void> providers(Locator locator) async {
    locator.registerSingleton<LoggerService>(LoggerService());
  }
  
  @override
  List<Type> get exports => [LoggerService];
}

3. Initialize Application

void main() async {
  final container = ApplicationContainer();
  await container.registerModule(CoreModule());
  
  final logger = container.get<LoggerService>();
  logger.log('Application started!');
}

Core Concepts

ApplicationContainer

The central container that manages modules and services:

final container = ApplicationContainer();
await container.registerModule(AppModule());

// Get services
final userService = container.get<UserService>();

// Check if ready
if (container.isReady) {
  print('Container initialized');
}

Module System

Modules group related services and define dependencies:

class UserModule extends Module {
  @override
  List<Module> get imports => [CoreModule()];
  
  @override
  Future<void> providers(Locator locator) async {
    locator.registerSingleton<UserService>(
      UserService(locator.get<LoggerService>()),
    );
  }
  
  @override
  List<Type> get exports => [UserService];
}

Service Registration

Multiple registration patterns:

// Singleton (created once)
locator.registerSingleton<UserService>(UserService());

// Factory (new instance each time)
locator.registerFactory<UserService>(() => UserService());

// Lazy Singleton (created on first access)
locator.registerLazySingleton<UserService>(() => UserService());

Async Providers

Support for services requiring async initialization:

class DatabaseModule extends Module {
  @override
  Future<void> providers(Locator locator) async {
    // Async service initialization
    final prefs = await SharedPreferences.getInstance();
    locator.registerSingleton<SharedPreferences>(prefs);
    
    // Use async-initialized services
    locator.registerSingleton<ConfigService>(
      ConfigService(locator.get<SharedPreferences>()),
    );
  }
  
  @override
  List<Type> get exports => [SharedPreferences, ConfigService];
}

Lifecycle Hooks

Initialize and cleanup resources:

class DatabaseModule extends Module {
  @override
  Future<void> onModuleInit(Locator locator, ModuleContext context) async {
    final db = locator.get<DatabaseService>();
    await db.connect();
  }
  
  @override
  Future<void> onModuleDestroy(Locator locator, ModuleContext context) async {
    final db = locator.get<DatabaseService>();
    await db.disconnect();
  }
}

Platform Integrations

nest_flutter - Flutter integration with widget support
nest_frog - Dart Frog backend integration

Documentation

Contributing

We welcome contributions! Please see our Contributing Guide for details.

License

This project is licensed under the MIT License - see the LICENSE file for details.