ZenWave SDK

👉 ZenWave360 Helps You Create Software Easy to Understand

Domain Driven Design (DDD) and API-First for Event Driven Microservices

ZenWave SDK is a configurable and extensible code generator tool for Domain Driven Design (DDD) and API-First for Event Driven Microservices that can generate code from a mix of different models including:

ZenWave SDK can generate code from a mix of different models including:

• ZDL Domain Language as Ubiquitous Language. You can describe the core of your Bounded Context, as well as how it connects to external systems through different adapters and APIs.
• AsyncAPI: Industry de-facto standard to describe Event-Driven Architectures for Message-based APIs.
• OpenAPI: Industry standard for Request-Response Architectures with REST APIs.

Using ZenWave Domain Language as Ubiquitous Language for modeling and describing Bounded Contexts: aggregates, entities with their relationships, services, value objects, commands and events.

ZenWave Domain Language started as an extended subset of JHipster Domain Language (JDL) that let you describe your entities and relationships.

Using ZDL Domain Language as Ubiquitous Language for Data on the Inside and API-First specs like AsyncAPI and OpenAPI to describe Inter Process Communications (IPC) for Data on the Outside.

• ZenWave Domain Language (ZDL) as Ubiquitous Language: To describe your domain core domain model.
• API-First specs like AsyncAPI and OpenAPI: to describe Inter Process Communications (IPC) between bounded contexts/microservices.
• ZenWave SDK: to generate (a lot of) infrastructure, functional and testing code from your models and APIs.

ZenWave SDK is designed to be easily extensible and adaptable to your project or your organization needs and likes. You can always fork an existing, standard or custom plugin.

You can install the latest release using jbang running the following command:

jbang alias add --fresh --name=zw release@zenwave360/zenwave-sdk

Please refer to ZenWave SDK for more detailed installation options.

Note: Official plugins are designed to generate functional code and tests on top of existing projects. Creating a base project is out of scope, but you can always go to start.spring.io or start.jhipster.tech, in case your company doesn’t already have a project starter or archetype.

Not (just) a Code Generator

ZenWave SDK is a Modeling Tool for Domain Driven Design and API-First in disguise of a code generator.

Its purpose is to produce successful software projects by dramatically shortening the feedback loop between the expert domain knowledge and working software and its tests.

In this way all team members: Domain Experts, Product Owners, Software Architects, Developers and Testers can provide early feedback based on an Ubiquitous Language (JDL) and the software and tests generated from that model.

Why Domain Driven Design?

“There are three types of developers implementing microservices. Those who use DDD, those who don’t realise they do, and those who fail.”

DDD: is about building software around a domain model that represents the problem we want to solve. Expressed by and Ubiquitous Language that is shared by all team members. It helps understand the problem before thinking of a solution. It connects Domain Experts with Technical Experts building a shared understanding of the problem and the solution.

ZenWave360: is about speeding up the feedback loop from idea -> model -> working software and tests.

Table of Contents

• ZenWave SDK
  • Domain Driven Design (DDD) and API-First for Event Driven Microservices
  • Not (just) a Code Generator
  • Why Domain Driven Design?
  • Table of Contents
  • Generate complete Event Driven Microservices using DDD and API-First
  • What can we generate for you today?
    • Example: Generate a complete Backend Application from a JDL model
    • Describe your core business model using JDL:
    • Generate Backend Application
    • Generate OpenAPI draft from JDL model
    • Generate AsyncAPI definition from JDL model
    • Configure ZenWave Maven Plugin for AsyncAPI generation
    • Spring REST Controllers from OpenAPI
    • Integration Test for your Controllers using Spring WebTestClient
    • E2E and Contract Testing
      • KarateDSL Ent-to-End tests for REST APIs (using sister project ZenWave KarateIDE)
      • High Fidelity Stateful REST API Mocks (using sister project ZenWave ApiMock)
      • AsyncAPI interfaces Mocks and Contract Tests (ToBeDefined)
• Refactoring a legacy monolith
  • Reverse engineering JDL from Java classes (JPA and MongoDB)
• Adding functionality on top of an existent microservices architecture
  • Reverse engineering JDL from Java classes (JPA and MongoDB)
  • Reverse engineering JDL from OpenAPI definition schemas

Generate complete Event Driven Microservices using DDD and API-First

You can generate complete Event Driven Microservices using DDD and API-First

Follow instructions in Getting Started

👉 Describe your Model → Generate Backend ⤳ Generate OpenAPI ⤳ Generate AsyncAPI → Generate API Implementations → Generate Tests and Contracts 👍

1. Start by describing your core domain model using JDL entities and relationships, annotations and comments.
2. Generate a complete Backend Application from your Domain Definition Model.
3. Generate a draft OpenAPI definition from the JDL model. Edit collaboratively this OpenAPI document and then generate some more functional code and tests from that definition.
4. Generate a draft AsyncAPI definition for consuming async request commands and publishing domain events. Now use zenwave maven plugin to generate strongly typed business interfaces implementing some Enterprise Integration Patterns like: transactional outbox, business dead letter queue…
5. Generate E2E, Integration tests and Consumer Contracts for the public APIs you just produced.

What can we generate for you today?

Whether you are:

• Designing a system from scratch,
• Refactoring a legacy monolith or just
• Adding functionality on top of an existent microservices architecture

…ZenWave SDK can… generate a lot of code for you!!

• Standard Plugins
  • JDL Backend Application (flexible hexagonal architecture)
    • Domain Entities,
    • Inbound
      • Service Ports, DTOs, Mappers
      • Implementation for CRUD operations
      • Acceptance Tests: SpringData InMemory Repositories
    • Outbound: SpringData Repositories, ElasticSearch… (for REST or Async see other plugins)
    • Adapters:
      • Spring MVC
      • Spring WebFlux
    • Flavors
      • MongoDB
        • Imperative
        • Reactive
      • JPA
        • Imperative
        • Reactive
    • Unit/Integration Testing
      • Edge Integration Testing: partial spring-boot context for outbound adapters (with testcontainers)
      • Sociable Vertical Testing: manual dependency setup with in memory infrastructure test-doubles
      • Vertical Integration Testing: full spring-boot context for inbound adapters (with testcontainers)
  • JDL OpenAPI Controllers
  • OpenAPI to Spring WebTestClient
  • AsyncAPI Spring Cloud Streams3
    • Consumer and Producer. Imperative and Reactive.
      • Business Exceptions Dead Letter Queues Routing
    • Producer with Transactional Outbox pattern
      • For MongoDB
      • For JDBC
    • Enterprise Envelop Pattern
    • Automatically fill headers at runtime from payload paths, tracing-id supplier…
  • JDL to Specs
    • JDL to OpenAPI
    • JDL to AsyncAPI
      • AsyncAPI schemas
      • AVRO schemas
  • API Testing
    • KarateDSL
      • OpenAPI to Karate E2E Tests (please use KarateIDE VSCode Extension instead)
      • OpenAPI to Karate/ApiMock Stateful Mocks (please use KarateIDE VSCode Extension and ZenWave ApiMock instead)
    • OpenAPI to Spring WebTestClient
    • OpenAPI to REST-assured
    • OpenAPI to Pact (postponed sine die)
  • Reverser Engineering
    • OpenAPI 2 JDL
    • Java 2 JDL
      • Spring Data MongoDB annotations
      • JPA annotations

Generate a Complete Backend Implementation: Getting Started

Follow instructions in Getting Started