Open-source alternatives to Typescript Ddd Example

This project is a full-stack forum platform built with TypeScript that serves as a reference architecture for implementing domain-driven design and clean architecture patterns. It provides a structured environment for community discussion, enabling users to register, authenticate, and engage in moderated conversations across organized topic categories. The platform distinguishes itself by strictly separating core business logic from infrastructure concerns. By utilizing a layered hexagonal architecture and the repository pattern, the codebase isolates business rules from external frameworks a

This project is a TypeScript-based architectural framework designed to implement domain-driven design and hexagonal architecture in enterprise applications. It provides a structured boilerplate that isolates core business logic from infrastructure concerns, ensuring that domain entities, use cases, and external technology adapters remain decoupled and maintainable. The framework distinguishes itself by enforcing strict architectural boundaries and dependency inversion, preventing unauthorized access to core logic from external layers. It utilizes a command-query responsibility segregation pat

This project is a reference implementation of domain-driven design patterns and a sample of command query responsibility segregation. It provides a collection of event-driven microservices that demonstrate the practical application of architectural principles for structuring complex software systems. The implementation separates read and write models through an event journal and organizes services into bounded contexts to maintain clear functional boundaries. It coordinates business logic by dispatching and consuming domain events to synchronize different modules. The project covers a range

This project is a framework for implementing event sourcing and command query responsibility segregation within containerized microservices. It provides a structured approach to managing business state as a sequence of immutable events, ensuring a reliable audit trail and the ability to reconstruct system state at any point in time. The framework distinguishes itself by enforcing a clear separation between data modification and data retrieval paths. By utilizing event-driven data synchronization, it allows for the asynchronous updating of materialized views and read models, ensuring that quer

This project serves as a reference implementation for applying clean architecture principles within a C# environment. It demonstrates how to structure enterprise applications by organizing code into concentric, independent layers that isolate core business logic from external infrastructure, frameworks, and database concerns. The codebase illustrates the application of domain-driven design to center software logic around business entities and rules. It utilizes interface-based decoupling and dependency inversion to ensure that high-level policies remain unaware of low-level implementation det

This project is a collection of software engineering principles and architectural design patterns designed to minimize the mental effort required to understand and maintain source code. It serves as a guide for implementing clean code methodologies and architectural simplification to reduce the overall cognitive load on developers. The framework emphasizes aligning module boundaries and ubiquitous language with business stakeholders to prevent architectural ripple effects. It advocates for balancing service granularity to avoid the overhead of distributed monoliths and suggests favoring objec

This project is a .NET Clean Architecture template designed to separate domain logic from infrastructure and web frameworks. It provides a project structure for C# applications and a React Redux frontend, creating a testable backend focused on maintainability. The implementation centers on Domain Driven Design, modeling core business domains using entities and value objects to manage complex requirements. It utilizes a decoupled architecture to ensure that business logic remains independent of external frameworks and database technologies. The project covers full stack application bootstrapp

This project is a reference implementation for structuring Java applications using clean architecture and domain-driven design principles. It provides a template for organizing code into concentric layers, ensuring that core business rules and domain entities remain entirely independent of external frameworks, databases, and delivery mechanisms. The architecture relies on the dependency inversion principle to decouple business logic from infrastructure. By defining abstract interfaces for data access and external services, the system allows for the replacement of underlying technologies witho

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

Rails Event Store is a library for implementing event sourcing and command query responsibility segregation patterns within Ruby applications. It functions as a framework for capturing all application state changes as an immutable sequence of events, providing a permanent and verifiable history of system operations. The library provides a messaging infrastructure that decouples business logic by broadcasting domain events through a central bus. This architecture allows for the execution of handlers either immediately or asynchronously, ensuring that heavy processing tasks do not block the pri

This project is an ASP.NET Core solution template and boilerplate that implements a clean architecture pattern for building enterprise applications and web API backends. It provides a standardized project scaffold designed to separate business logic from infrastructure and user interfaces to ensure high testability and low coupling. The project features a database agnostic structure that allows for switching persistence providers without altering core business logic. It includes a command line tool for enterprise application bootstrapping, enabling the automated generation of project structur

This project provides a structured template for building enterprise applications using a modular monolith architecture. It demonstrates how to organize complex business logic into independent, domain-specific modules that remain contained within a single deployment unit. The architecture enforces strict boundaries between components to minimize coupling and complexity. It utilizes domain-driven design principles to map software components directly to real-world business concepts, ensuring that logic remains independent of infrastructure concerns. Communication between these isolated modules i

This project is a Java microservices reference implementation that demonstrates the application of structural design patterns for distributed systems. It consists of a suite of containerized services and infrastructure dependencies designed to showcase how to coordinate multiple independent services into a functional system. The implementation focuses on several advanced architectural patterns, including a centralized API gateway for routing and aggregating responses, Command Query Responsibility Segregation to separate read and write operations, and event sourcing to persist the state of bus

This project provides a structured boilerplate for building Go web applications based on clean architecture principles. It serves as a template for organizing codebases to ensure that core business logic remains isolated from external frameworks, database layers, and delivery mechanisms. The implementation prioritizes domain-driven design by centering the application around pure business entities that contain no references to infrastructure concerns. It utilizes layered dependency inversion and interface-based port adaptation to decouple the internal logic from external dependencies, allowing

Util is a comprehensive development framework for .NET designed to implement layered architectures and domain driven design. It provides a toolkit of base classes and tools for building full stack applications, specifically focusing on the creation of backend admin frameworks and management interfaces. The project distinguishes itself through a boilerplate generator that produces the necessary types and classes to standardize repetitive architectural patterns. It also includes a micro-frontend orchestrator that enables the splitting of large frontend modules into independent projects for sepa

EventBus is a publish-subscribe messaging library designed to facilitate decoupled communication between components in Java applications. It functions as a central hub where producers dispatch events that are routed to subscribers based on the class type of the payload. By using annotation-based markers, the system maps event handlers to specific data types, allowing different parts of an application to exchange information without requiring direct references between classes. The library distinguishes itself through a focus on performance and execution control. It utilizes a compile-time inde

Inngest is a durable execution framework and event-driven automation engine designed to orchestrate background workflows. It enables developers to build resilient, stateful processes by memoizing function steps, ensuring that long-running tasks can automatically resume from the last successful operation after failures, timeouts, or infrastructure restarts. The platform distinguishes itself through its event-driven architecture, which uses a schema-validated bus to trigger functions and coordinate complex, multi-step logic. It employs an onion-model middleware approach for cross-cutting concer

This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations. The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates

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

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

COLA is a core architectural toolkit for Java applications designed around domain-driven design and a clean, object-oriented layered architecture. It provides a framework for managing project structures, implementing domain-driven entity modeling, and organizing enterprise application architecture to decouple business logic from technical dependencies. The project features a pluggable logic extension system that allows for the addition of new functionality through defined extension points without modifying the core codebase. It also includes a project bootstrapping toolkit and an integration

This project is a reference implementation and architectural sample of Domain-Driven Design. It serves as a codebase demonstrating how to align software design with a specific business domain to manage complex business logic. The implementation functions as a reporting system that receives and processes data via JSON payloads. It utilizes a structured domain model to define and automate business workflows and handle state changes. The architecture partitions the system into distinct application and domain layers, utilizing aggregate roots for consistency and the repository pattern for data a

This project is a Domain-Driven Design framework and strategic design methodology. It provides a structured workflow for translating business knowledge into technical implementations, guiding the decomposition of complex business domains into manageable software models. The methodology focuses on strategic domain decomposition, identifying core domains to inform build-versus-buy decisions, and defining bounded contexts to establish system responsibilities. It employs collaborative visual techniques to build a shared mental model of the problem domain between technical and non-technical team m

This project is a clean architecture reference implementation and modular project template for Android development. It provides a structural blueprint designed to isolate business logic from external frameworks and user interfaces. The template emphasizes a modular approach to organize code into independent modules, which is intended to improve build times and long-term project scalability. It demonstrates the application of domain-driven design to keep core business rules and entities independent from the underlying platform. The implementation covers several key architectural patterns, inc

eShopOnContainers is a .NET microservices reference application designed to demonstrate cloud-native architecture patterns. It serves as a sample distributed system that implements domain-driven design and utilizes containerized services. The project is developed as a cross-platform sample compatible with Windows, Linux, and macOS. It utilizes Docker for containerized application deployment and supports orchestration via Azure Kubernetes Service to manage the scaling and availability of its services. The system covers microservices architecture design, asynchronous service communication, and

This project is a microservice framework for building scalable backend systems in Go. It provides an architecture for distributed systems with integrated support for service discovery, load balancing, and fault-tolerance mechanisms. The framework distinguishes itself through a domain-driven layered architecture and a remote-first configuration system that synchronizes settings between remote stores and local files with automatic failover. It implements a high-performance communication model using gRPC for unary and streaming data exchange, as well as real-time notification systems for managin

Prompt patterns is a framework for organizing AI-driven system design through structured prompt engineering and domain-driven development methodologies. It provides a library of standardized interaction strategies designed to improve the consistency, accuracy, and logical reasoning of large language model outputs. By applying these patterns, users can translate complex business scenarios into structured domain models and technical specifications. The project distinguishes itself by integrating domain-driven design principles directly into the prompting workflow. It utilizes techniques such as