Dragée

Dragee is a solution for clean software design. It is the ultimate tool for software crafters seeking clarity and precision in their work. Dragée is designed from scratch with usability and extensability at its core.

Ready to fix your architecture?

Dragée is easy to install and only relies on your knowledge of the codebase. Run it once and Dragée will keep track of updates at every build. Once Dragée has done its magic, results can be exploited as a map of improvements for your architecture project.

1. Install Dragée

Dragée is easy to setup and easy to install. Install Dragée CLI and update your project's dependancy with Dragée's. Dragée is currently available on Maven but can also be installed in a project using Gradle.
```
npx install dragee
```
For Java, see the installation steps
2. Annotate your code

Who knows best your codebase than you? Dragée relies on easy-to-add annotations on your code to provide a result you can trust. The annotations are self-explanory and easy to import in every part of your application code.
```
package org.payment.basket.model;
import io.dragee.annotation.ddd.DDD;

@DDD.ValueObject
public record BasketId(String value) {
    public static BasketId of(String value) {
        return new BasketId(value);
    }
}
```
3. Run Dragée

Once Dragée is up and running, access useful modelizations and reports on your architecture’s codebase health. Its CLI is modular so only what’s needed is downloaded on a local registry.
```
dragee draw && dragee report
```

Dragée asserts

Asserters are modules responsible for asserting that the code base is strictfully following one or several rules. The rules are based on the chosen architecture asserter (DDD, hexagonal architecture, etc.). Dragée is shipped with asserters for several architectures but you can build your own if you need it.

asserter-generator: The asserter-generator is our template engine that allows to create other asserters. If the existing rules or asserters are not valid for the codebase, a custom asserter can be created using Dragée’s CLI. Dragée is customizable so that you can create your own asserters

ddd-asserter: The ddd-asserter module is focused on validating tactical patterns of DDD in your code base. It checks that the interactions between DDD patterns (aggregates, entities, domain events, repositories etc.) are respected inside the bounded contexts you defined.

hexagonal-asserter: The hexagonal-asserter module ensures that the codebase is strictfully following the hexagonal architecture by looking at declared ports and adapters, keeping relations between infrastructure and domain safe so that you can manage changes without tainting the business logic.

Dragée draws

A grapher in Dragée is a tool that generates diagrams such as graphs or charts. It processes a list of Dragee objects from the annotations in your codebase and generates diagrams in Markdown. By converting complex code structures into understandable diagrams, a grapher aids in documenting code architecture, troubleshooting and assessing code quality.

grapher-generator: grapher-generator lets developers define custom graphing rules, gaining precise control over depicting relationships and dependencies. This tool helps transform codebases into clear diagrams, improving documentation and enhancing project structure understanding.

ddd-grapher: The ddd-grapher module allows to visualize interactions between tactical patterns, dependancies direction and control at a glance if aggregates are cohesives, events are well ordered, well named and so on. Moreover, you can easily see if the ubiquitous language is well shared and used among the codebase.

hexagonal-grapher: The hexagonal-grapher module give a quick visual representation to ensure that your domain is rightfully at the centre of your architecture, infrastructure outside of it. Additionally, it inspects ports and adapters to confirm in a flash taht ports are the gateway to the core and adapters the gateway for external technical part.

Dragée is a strong, open-sourced and modular architecture linter and grapher

Self-documentation

Annotating your codebase to provide Dragée the needed informations will also improve your codebase documentation. As an added benefit, tagging your code will allows it to scream what it is or what it does.

Carefully versioned

The modules around Dragée are carefully built, tested, and deployed using Dagger with containerization for isolation and caching for faster and more robust modules updates

Modularity at its core

Dragée is designed to take what it needs to accomplish its task. Modules can be easily added by developers to enhance the existing features or add new ones.

Nice defaults with an easy way to extend the configuration

DDD & Hexagonal architecture

Dragée is shipped with nice defaults to lint and modelize your DDD or clean architecture codebase. Plug it, run it and fix bad patterns in your existing code.

C4 & Mermaid graphers

By default Dragée can create graph of your architecture using detailed C4 models or simpler Mermaid syntax. Integrating these models into your documentation is easy.

Extensibility

Dragée is extensible: it allows to create easily custom asserters and graphers for a specific architecture or a missing rule.