Projects sharing features with Dependency Injection

Implementation of a bulletproof node.js API 🛡️

QFramework is a Unity game architecture framework designed to separate presentation, system, and data logic. It implements a layered software architecture to manage complex game states and provides a game engine utility library to reduce boilerplate code. The framework is centered on the Command Query Responsibility Segregation pattern, which separates data modification commands from data retrieval queries. It utilizes a dependency injection container to manage the lifecycles and resolution of singletons and modular components, alongside an event-driven system for state synchronization to pre

This is a dependency injection framework and inversion of control container for Python. It decouples object creation from business logic by managing how services and their dependencies are assembled, delivered, and linked within an application. The framework is distinguished by its ability to perform automated component wiring, using import hooks and decorators to inject dependencies into functions and classes across different modules. It supports non-blocking flows through an asynchronous dependency resolver and manages the initialization and shutdown sequences of shared external resources a

This project is a reference Kotlin Android application template and a set of sample implementations demonstrating Clean Architecture principles. It provides a structural design that isolates core business rules from the user interface and data sources into distinct, layered modules. The implementation focuses on the Model-View-ViewModel (MVVM) pattern to decouple UI logic from data models. It utilizes a dependency injection framework to automate object creation and manage component lifecycles, while employing a repository pattern to abstract data requests across memory, disk, and cloud source

This project is a Swift iOS architecture template that implements the Clean Architecture pattern. It organizes software into distinct layers to decouple business rules from external frameworks, user interfaces, and infrastructure to improve testability and maintenance. The template incorporates Domain Driven Design to isolate core business logic and utilizes a modular application structure to divide features into independent modules. It employs the Coordinator pattern to remove routing logic from view controllers and a dependency injection framework to ensure components remain independent and

Litestar is a high-performance Python ASGI web framework designed for building asynchronous APIs and web services. It functions as a type-safe toolkit that leverages Python type hints to provide automatic request validation and response serialization, while natively generating interactive API documentation based on the OpenAPI specification. The framework is distinguished by its integrated dependency injection system, which manages shared resources and resolves complex nested service chains directly within request handlers. It further organizes API development through class-based controllers

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

Autofac is a dependency injection framework and inversion of control container for .NET. It functions as a component registration engine that decouples class implementations from their dependencies by injecting required services via constructors or properties. The project includes an assembly scanning library to automatically discover and register components within compiled binaries based on specific type criteria. It provides a service lifetime manager to control object memory duration using singletons, instance-per-dependency, or isolated request scopes. The framework covers a broad range

Koin is a dependency injection framework for Kotlin applications that manages object lifetimes and resolves dependencies through a lightweight container. It functions as a multiplatform library, allowing shared object definitions and resource bindings to be reused across different target platforms and source sets. The framework provides a system for resolving dependencies directly within user interface components to decouple business logic from view implementations. It includes a compile-time dependency validator that analyzes dependency graphs during the build process to detect missing bindi

Guice is a Java dependency injection framework and component container. It automates object wiring by mapping interfaces to implementations via a central injector, removing the need for manual factory patterns and constructor calls. The framework provides specialized support for aspect-oriented programming, allowing for the interception and modification of method execution to implement shared cross-cutting concerns. It also functions as a persistence manager to coordinate transaction boundaries and manage the lifecycle of entity managers within a dependency-injected environment. Its core cap

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

Fx is a dependency injection framework and application lifecycle manager for Go. It functions as a component model container that automates the instantiation and connection of components by analyzing constructor parameters and return values to resolve complex dependency graphs. The framework distinguishes itself through module-based component bundling, which encapsulates related constructors into reusable units to manage visibility and logic. It provides advanced resolution capabilities, including mapping concrete types to interfaces for decoupling, resolving dependency ambiguities via unique

ASP.NET Core is a unified, cross-platform framework designed for building scalable web applications and services. It provides a comprehensive environment for constructing server-side rendered applications, real-time communication services, and interactive web components using C# and .NET. The framework distinguishes itself through a modular architecture that centers on a built-in dependency injection container, which manages service lifecycles and component modularity to improve testability. It utilizes a middleware pipeline to process requests and employs policy-based authorization to secure

Small-Spring is a simplified Java implementation of the Spring framework designed to study the internal architecture of inversion of control containers and dependency injection frameworks. It functions as a bean container that manages object lifecycles and resolves dependencies through automated instantiation and property injection. The project implements a mechanism for intercepting method calls using dynamic proxies to support aspect-oriented programming. It separates cross-cutting concerns from business logic by wrapping target objects to modify method executions. The system covers compon

LoopBack Next is a Node.js API framework used for building REST and multi-protocol APIs. It functions as an OpenAPI server implementation that can either generate machine-readable specifications from code or produce implementation controllers and models from existing specifications. The framework distinguishes itself through a central dependency injection container and a repository-pattern data access layer. This architecture decouples application logic from component construction and persistent storage, allowing for a pluggable system where data sources and business logic are isolated throug

TypeDI is a TypeScript dependency injection container and inversion of control tool. It functions as a centralized registry and service locator that manages object instantiation and decouples component dependencies using type inference and decorators. The project provides scoped dependency management to isolate service instances within specific contexts, preventing data leakage between different execution flows. It supports flexible service resolution through the use of type-safe tokens and the ability to map unique identifiers or class constructors to specific service instances. The contain

mini-spring is a Java dependency injection framework and inversion of control container. It manages the full lifecycle of beans, including instantiation, property population, and scope management, while providing a system for automating the wiring of components. The project implements a Java AOP framework that uses dynamic proxies to intercept method calls for cross-cutting logic. It also functions as a Java component scanner to automatically discover and register managed objects via annotations and as a Java event bus to decouple components through a publish-subscribe multicast system. The

Inject is a dependency injection library for Go that manages object lifecycles and wires application components by automating the provision of dependencies. It functions as a reflection-based container that maps specific values to their corresponding types, enabling the automatic retrieval and injection of objects into application logic. The library distinguishes itself through its ability to perform automatic function invocation, where it inspects function signatures at runtime to resolve and provide required arguments from a central registry. It also supports struct field injection, which p

tiny-spring is a Java inversion of control container and aspect-oriented programming framework. It provides a system for managing object lifecycles and dependency injection to decouple application components. The project features a bytecode proxy generator that enables method interception and behavioral modification for classes that do not implement interfaces. It uses pointcut expressions to match specific classes and methods for the execution of cross-cutting logic via dynamic proxies. The framework manages singleton components and resolves object dependencies using lazy initialization. Ap

This project is a shared technical specification and standard interface for dependency injection containers in PHP. It defines a common set of interfaces for retrieving services and dependencies, ensuring that different container implementations remain interoperable across the PHP ecosystem. By establishing a standardized API for dependency retrieval, the project allows developers to create libraries that function with any compliant container. This prevents vendor lock-in and enables different container implementations to be swapped without requiring changes to the application code. The spec

Martini is a web framework for the Go programming language that provides a toolkit for building web applications. It functions as a routing engine and an HTTP middleware pipeline to map network requests to specific handler functions. The framework is distinguished by its dependency injection system, which automatically resolves and provides requested service types as arguments to handler functions. This allows for the decoupling of business logic from infrastructure by matching requested types against a registry of available services. The project covers a broad range of web capabilities, inc

This project serves as a technical educational resource and software implementation example focused on dependency injection architecture and containerized application packaging. It provides a centralized framework for managing the lifecycle and configuration of application components, allowing objects to receive their dependencies from a registry rather than creating them internally. The project distinguishes itself by offering a type-safe service resolution mechanism that uses language-level information to map abstract interfaces to concrete implementations. By utilizing an inversion of cont

Ember.js is a structured JavaScript web framework designed for building scalable web applications. It utilizes a Model-View-Controller architectural pattern and incorporates a component-based UI library, a dependency injection framework, and a client-side routing engine. The framework distinguishes itself through a centralized registry for passing shared services across components and routes, alongside a routing system that maps URLs directly to templates and data models to manage navigation. Its broader capabilities include reactive state synchronization and computation memoization for UI p

This is a TypeScript web framework and Node.js backend framework used to build web applications and API servers. It serves as a server-side application toolkit providing a structured environment for managing HTTP routing, request parsing, and application configuration. The framework features a dependency injection container to deliver required objects between application components, decoupling internal logic. It includes built-in tools for server-side data security, such as cryptographic drivers for hashing sensitive data and encrypting application data at rest. The project covers broad capa

GetX is a comprehensive state management framework for Flutter that provides a toolkit for managing application state, dependency injection, and routing without requiring build context. It serves as a core architectural system for reactive state management, navigation, service location, and multi-language theme support. The project is distinguished by its ability to handle context-free navigation and the use of observable variables that automatically trigger user interface updates. It features a dependency injection container with lazy loading and automated memory management, alongside a rout

This project is a collection of reference implementations demonstrating recommended patterns for organizing code and managing data flow in Android applications. It provides structural examples of layered architecture, separating code into presentation, domain, and data layers to decouple business logic from data sources. The repository includes specific samples for implementing declarative user interfaces that automatically update their visual state based on underlying data changes. It further demonstrates how to manage object lifetimes and component dependencies to reduce boilerplate and sim