ZenWave360/zenwave-sdk

The ZenWave SDK is a code generation framework that transforms API specifications (OpenAPI, AsyncAPI) and domain models (ZDL) into production-ready Java and Kotlin backend applications. It generates comprehensive service layers, including REST controllers, event-driven consumers/producers for Kafka and Spring Cloud Stream, and infrastructure code for JPA or MongoDB persistence. Additionally, it supports infrastructure-as-code generation for Kafka topics and provides tools for creating architecture documentation and integration tests.

69 changes.

This period focused on establishing the ZenWave SDK's foundational structure and introducing the Zenwave Definition Language (ZDL) as a core input format for domain modeling. Significant work was done to expand code generation capabilities, particularly through comprehensive support for AsyncAPI v3, Spring Cloud Streams 3, and various backend application templates. The effort also included refactoring the CLI and templating engine to support these new features, alongside extensive test coverage and end-to-end validation for the generated architectures.

34 changes.

This period focused on expanding the SDK's code generation capabilities with new plugins for AsyncAPI, Avro, and Karate testing, alongside a major addition of idiomatic Kotlin backend support. Significant architectural improvements included the introduction of pluggable project layouts for Clean, Hexagonal, and Layered styles, as well as a new ZDL annotator framework for cleaner generated code. The work was heavily supported by comprehensive end-to-end test coverage for these new features and existing modules.

14 changes.

This period focused on expanding the SDK's plugin ecosystem with new generators for EventCatalog documentation and AsyncAPI-driven Terraform infrastructure for Kafka. Significant work included refactoring backend service method generation to support entity lifecycle states and domain events, alongside comprehensive test coverage for these new features and existing ZDL layout structures.

The event-catalog-project location now includes a complete scaffold for generating an EventCatalog site, featuring a new RemoteSpecificationSchema component that fetches and renders AsyncAPI 3.x and OpenAPI 3.x schemas during static builds. The project provides Dockerfiles for both static and server-side rendering modes, a build/start script with support for permissive remote schema loading, and configuration files for authentication and catalog settings.

plugins/event-catalog-generator/event-catalog-project · high confidence

The ZDL-to-AsyncAPI generator now includes dedicated Handlebars templates for generating AsyncAPI documents in both version 2.6.0 and version 3.1.0. These templates enable users to generate specifications that support runtime header expressions for Kafka message keys and CloudEvents attributes (such as ce-id, ce-source, and ce-type) when the corresponding configuration flags are enabled, while also adapting the channel and message structure to match the specific requirements of each AsyncAPI version.

plugins/zdl-to-asyncapi/src/main/resources/io/zenwave360/sdk/plugins/ZDLToAsyncAPIGenerator · high confidence

The Spring Cloud Streams 3 generator now includes template files for in-memory mock implementations of event producers. These generated classes allow developers to capture and inspect messages sent to topics during testing without requiring a live message broker, supporting features like runtime header processing and optional enterprise envelope wrapping.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/producer/mocks · high confidence

The generator now includes a new Handlebars template (EventPublisher.java.hbs) that produces an EventPublisher interface. This interface is placed in the outbound events package and imports domain events and entities, with methods generated for each event type to support modular event publishing.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/outbound/events · high confidence

The \zenwave-sdk-test-resources\ module now includes a comprehensive set of JPA entity models (Blog, Post, Tag, Product) and their MongoDB equivalents, along with auditing base classes and a PostType enum, providing reference implementations for relational and document-based persistence. Additionally, new test utility classes \GitUtils\ and \MavenCompiler\ have been added to support automated git change detection and Maven compilation during testing, and AsyncAPI v2/v3 resource files (including merger overlays and circular reference examples) are now available to support asynchronous API generation tests.

zenwave-sdk-test-resources · high confidence

The backend application generator now includes three new Handlebars templates that produce MapStruct mapper interfaces for generated projects. BaseMapper.java.hbs provides default methods for converting between java.time types (Instant, LocalDateTime, OffsetDateTime). ServiceMapper.java.hbs generates a mapper for each service, handling input/output DTO-to-entity conversions, paginated results, and automatically wiring bidirectional one-to-many relationships via @AfterMapping. EventsMapper.java.hbs creates a mapper for converting between domain entities and event models, supporting both synchronous and asynchronous event definitions.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/implementation/mappers · high confidence

The generator now produces a set of imperative adapter components for Spring Cloud Stream 3 consumers, including a service implementation (ConsumerService), a MapStruct-based event mapper (EventsMapper) for DTO-to-entity conversion, and a base test class (BaseConsumerTest) with corresponding integration test scaffolding (ConsumerTest). This changes the generated output to include these concrete adapter classes and their associated test infrastructure, enabling users to have ready-to-use consumer implementations and tests for their AsyncAPI-defined operations.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/adapters · high confidence

The ZDLToOpenAPI generator now includes server-side templates to produce OpenAPI 3.0.1 specifications and JDL models. The new OpenAPI template defines standard CRUD paths for entities, supports file upload/download operations, includes pagination parameters, and configures basic and bearer authentication schemes. Additionally, a new JDL template is provided to convert ZDL entities, enums, and relationships into JHipster Domain Language format.

plugins/zdl-to-openapi/src/main/resources/io/zenwave360/sdk/plugins/ZDLToOpenAPIGenerator · high confidence

The AsyncAPI generator plugin now includes Handlebars templates that generate imperative consumer and producer implementations for both Apache Kafka and Spring Cloud Stream. For Kafka, consumers use @KafkaListener with configurable autoStartup and dead-letter queue mapping, while producers use KafkaTemplate with timeout handling. For Spring Cloud Stream, consumers implement the Consumer interface with StreamBridge integration and DLQ support, and producers use StreamBridge or ApplicationEventPublisher (Modulith). Both implementations support enterprise envelope wrapping, runtime header processing via SpEL expressions, and in-memory mock producers for testing.

plugins/asyncapi-generator/src/main/resources/io/zenwave360/sdk/plugins/AsyncAPIGenerator · high confidence

The AsyncAPI JSON Schema to POJO generator now includes options to automatically generate Java classes for message binding keys (e.g., Kafka keys), application headers, and protocol-specific binding headers (HTTP, JMS, MQTT). Users can enable these via the new \generateMessageKeys\, \generateMessageHeaders\, and \generateBindingHeaders\ configuration flags, allowing the plugin to produce DTOs for metadata and transport-level structures alongside standard payload schemas.

plugins/asyncapi-jsonschema2pojo/src/main · high confidence

The backend application generator now includes a Handlebars template for a default Spring-based event publisher. This new \DefaultEventPublisher\ component implements the \EventPublisher\ interface and delegates event publishing to Spring's \ApplicationEventPublisher\, allowing generated applications to utilize standard Spring event mechanisms for domain events. A corresponding \package-info.java\ template was also added to document the infrastructure package.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/infrastructure · high confidence

The BackendApplicationDefault plugin now includes support for internal domain event listeners and AsyncAPI adapter implementations. When the \implementEventListeners\ option is enabled, the generator creates \EventListeners\ classes that integrate with Spring Modulith's \@ApplicationModuleListener\ to handle domain events, and generates adapter implementations for consumer interfaces defined in AsyncAPI specifications. This allows backend services to automatically wire up event-driven communication and asynchronous message consumption without manual boilerplate, while keeping the generated listener classes safe for customization.

plugins/backend-application-default/src/main · high confidence

The Kotlin backend plugin now generates idiomatic Kotlin code, replacing Java types with Kotlin equivalents (e.g., \void\ to \Unit\, \byte\[\]\ to \ByteArray\, and Java collections to Kotlin mutable collections). This update introduces support for Spring Modulith annotations and features via the \useSpringModulith\ option, and adds the ability to generate implementations for ZDL \@listener\ and AsyncAPI consumer methods through the \implementEventListeners\ and \includeEmitEventsImplementation\ options. The generator also provides Kotlin-specific template helpers for OpenAPI controllers and Spring Web Test Clients, ensuring proper type signatures and initialization for Kotlin-based web adapters and tests.

plugins/customizations/kotlin-backend-application/src/main/java/io/zenwave360/sdk/plugins/kotlin · high confidence

The new \asyncapi-generator\ plugin introduces template-based code generation for AsyncAPI specifications, specifically targeting Spring Cloud Stream and Spring Kafka runtimes. This location provides the template wiring and Handlebars helper logic that maps AsyncAPI channel and message definitions to Java producer and consumer interfaces, classes, and test doubles. The helpers resolve Java types for headers (e.g., mapping \date-time\ to \Instant\) and manage naming conventions for services and operations, enabling users to generate boilerplate code for message-driven architectures.

plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates · high confidence

The OpenAPI Karate generator now includes the necessary Handlebars templates to produce Karate feature files for API testing. This addition introduces templates for generating Business Flow tests, individual Service tests, and specific Operation tests, along with a shared partial for constructing the request and response assertions. Users can now generate structured Karate test suites that automatically handle path parameters, query parameters, request bodies, and response status codes based on the provided OpenAPI specification.

plugins/openapi-karate/src/main/resources/io/zenwave360/sdk/plugins/OpenAPIKarateGenerator · high confidence

This change establishes the foundational structure for the ZenWave SDK repository. It adds essential configuration files including \.editorconfig\ and \.gitattributes\ to enforce consistent coding styles and line endings, a \.gitignore\ for build artifacts, and an \eclipse-formatter.xml\ for Java code formatting. It also introduces the \jbang-catalog.json\ to define JBang aliases for release, snapshot, and legacy (v1.7.1) versions, and updates the \LICENSE\ file to reflect current copyright holders. Documentation is initialized with \README.md\, \CHANGELOG.md\, \CONTRIBUTING.md\, and \index.md\ to guide users on installation, usage, and contribution.

(repo-wide) · high confidence

A new Model Code Project (MCP) server plugin is added to the ZenWave SDK, enabling users to generate aggregate UML diagrams from ZDL model files via an MCP-compatible host (such as Claude Desktop or VS Code). The server exposes a single tool, \getAggregateUML\, which accepts ZDL content and an aggregate name to produce PlantUML code fences. It is distributed as a JBang artifact (\io.zenwave360.sdk.plugins:zenwave-mcp-server:2.0.0-SNAPSHOT\) and configured via Spring AI MCP server properties.

plugins/zenwave-mcp-server · high confidence

The new JavaZdlModel class in the ZDL model package provides a structured representation of ZDL elements (entities, services, enums, inputs, outputs, and events) for the SDK's code generation pipeline. It distinguishes between internal and external events based on AsyncAPI options and injects synthetic 'id' fields for entities that do not have one, enabling annotators like jMolecules to target identity fields. Additionally, it tracks the applied jMolecules architecture vocabulary, allowing templates to generate architecture verification logic that matches the specific annotations applied.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/zdl/model · high confidence

The new SpringWebTestClientPlugin generates Spring MVC and WebFlux integration tests based on OpenAPI specifications. Users can configure the test structure via the \groupBy\ option (service, operation, partial, or business flow) and control request payloads using \requestPayloadType\ (JSON string or Java DTOs). The plugin also allows customization of test class naming via \testSuffix\ (defaulting to IntegrationTest) and supports transactional test annotations.

plugins/openapi-spring-webtestclient/src/main · high confidence

The SDK now uses a new \ZDLAnnotator\ interface to inject Java annotations into generated artifacts after the model is built, removing the need to hard-code annotation logic in Handlebars templates. This change introduces built-in support for JSpecify nullability annotations (e.g., \@NullMarked\, \@Nullable\) and jMolecules DDD/architecture annotations (e.g., \@AggregateRoot\, \@SecondaryPort\), which are automatically applied based on the selected project layout (Hexagonal or Layered). Users benefit from cleaner generated code with proper null-safety and architectural markers without manual template modifications.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/zdl/utils · high confidence

The SDK now uses a new \processors\ package to handle API model transformations, introducing \AbstractBaseProcessor\ as a base for \OpenApiProcessor\ and \AsyncApiProcessor\. These processors enrich API definitions with normalized tags, operation ID variants (camel/kebab case), and schema metadata to aid code generation. The \AsyncApiProcessor\ adds support for AsyncAPI v3 operations and traits. Additionally, the \OverlayApplicator\ and \YamlOverlyMerger\ classes implement Overlay Specification 1.1 support (including the \copy\ action) alongside 1.0, allowing users to apply overlays to YAML-based API definitions during the generation process.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/processors · high confidence

The Kotlin backend application generator now produces code aligned with Spring Modulith and AsyncAPI standards. Module metadata files are generated with Spring Modulith annotations to define module boundaries and dependencies. Event handling is standardized via Spring Modulith listeners for internal domain events, and AsyncAPI adapters are generated for external event consumption, including MapStruct mappers for payload conversion. Domain entities and aggregates now include lifecycle state management with transition validation, and JPA/MongoDB entity templates support auditing, relationships, and value objects.

plugins/customizations/kotlin-backend-application/src/main/resources/io/zenwave360/sdk/plugins/kotlin · high confidence

A new \asyncapi-generator\ plugin has been added to the SDK, enabling the generation of strongly typed Spring Cloud Stream and Spring Kafka producer/consumer classes from AsyncAPI specifications. The plugin supports JSON and Avro payloads, allowing users to configure template selection, transactional outbox strategies, and enterprise envelope wrapping. It also includes support for AsyncAPI v3 overlays to modify schemas before generation and handles runtime header expressions for Kafka message keys and tracing.

plugins/asyncapi-generator/src · high confidence

The ZDL-to-AsyncAPI plugin now includes a new \ZDLToAsyncAPIClientGenerator\ that produces AsyncAPI 3.0 client documents for services consuming external channels, alongside an \AsyncAPIOverlayProcessor\ that allows merging custom overlay files or documents to modify the generated output. The main generator also adds support for AsyncAPI v3 (with \Command\, \Response\, and \Event\ message suffixes), v2, and options to include Kafka common headers or CloudEvents headers.

plugins/zdl-to-asyncapi/src/main · high confidence

The AsyncAPI Ops plugin now generates Terraform HCL configurations to manage Kafka topics, Avro schemas, and ACLs directly from AsyncAPI specifications. Users can select from three template sets—TerraformKafka, TerraformConfluent, or TerraformConfluentHybrid—to provision infrastructure that prevents API drift. The generator automatically bundles local Avro schemas (including sibling .avsc files) for the Schema Registry, resolves Confluent service accounts in either 'existing' or 'managed' modes, and derives Access Control Lists (ACLs) and error/retry topics from AsyncAPI operation bindings and channel ownership.

plugins/asyncapi-ops/src/main · high confidence

The \avro-schema-compiler\ plugin is now available, allowing users to generate Java classes from Avro \.avsc\ schema files. It supports loading schemas from local directories, classpath resources, and remote URLs, and automatically includes sibling \.avsc\ files found in the same directory as the root schema. The plugin is compatible with Apache Avro versions 1.8.0 through 1.12.0, enabling features like custom logical type factories, custom conversions, optional getters, and null-safe annotations depending on the Avro version in use.

plugins/avro-schema-compiler/src · high confidence

The CLI now includes a comprehensive help system that displays plugin configurations, options, and documentation in multiple formats (list, help, detailed, JSON, Markdown, HTML). Users can access this via the --help flag, which leverages reflection to discover available plugins and their documented options, including support for nested options and custom documentation links. The help output also shows the current version and provides a structured view of all plugin configurations and their available options.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk · high confidence

The \event-catalog-generator\ plugin is introduced to automatically generate and maintain EventCatalog documentation from a ZenWave architecture manifest. It loads the manifest and builds an enriched model of domains, subdomains, and services, then processes AsyncAPI and OpenAPI artifacts to extract channels, events, commands, and queries. The generator creates versioned \index.mdx\ pages for the catalog, preserving historical versions when content changes. Additionally, an importer plugin is provided to reverse-engineer an existing EventCatalog source tree back into a ZenWave architecture manifest.

plugins/event-catalog-generator/src/main · high confidence

The EventCatalog generator now includes a comprehensive set of Handlebars templates (channel, command, docs, domain, entity, event, flow, query, service, and subdomain) to structure the generated documentation. These templates define the layout for each artifact type, incorporating components like NodeGraph, MessageTable, EntityMap, and SchemaViewer, and support rendering remote schemas via RemoteSpecificationSchema where applicable.

plugins/event-catalog-generator/src/main/resources/io/zenwave360/sdk/plugins/EventCatalogGenerator · high confidence

The backend application default generator now includes new Handlebars templates for JPA, MongoDB, and Value Object entities. The JPA template migrates entity generation from javax.persistence to jakarta.persistence, adds support for auditing fields (createdBy, createdDate, etc.) that are read-only, and implements relationship management methods for OneToOne, OneToMany, ManyToMany, and ManyToOne associations. The MongoDB template provides equivalent entity generation for MongoDB with auditing support, while the Value Object template generates simple serializable classes without persistence annotations.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/domain/jpa · high confidence

A new generator plugin has been added that reverse-engineers AsyncAPI specifications from Java event producer classes. It supports generating AsyncAPI v3 documents with either standard JSON Schema or Avro payload formats, and includes options to inject Kafka common headers or CloudEvents headers into the generated messages.

plugins/java-to-asyncapi/src · high confidence

A new \JavaToJDLGenerator\ plugin has been added to the SDK, enabling users to automatically convert existing Java entity classes into JDL (JHipster Domain Language) definitions. The generator supports both JPA (\jakarta.persistence\) and MongoDB (\org.springframework.data.mongodb\) persistence types, scanning specified packages for annotated classes and relationships (such as \@OneToMany\, \@ManyToOne\, etc.) to produce corresponding JDL output. This allows users to reverse-engineer their Java data models into a high-level domain language format.

plugins/java-to-jdl/src · high confidence

The \zenwave-sdk-maven-plugin\ now includes a \generate\ goal (\GeneratorMojo\) that allows users to generate code from API specifications and ZenWave Data Language (ZDL) models. This change introduces support for specifying input via \inputSpec\ (API spec) and \zdlFile\/\zdlFiles\ (ZDL models), along with \authentication\ configuration for fetching remote resources. Users can configure the output directory, control whether generated sources are added to the project's compile/test roots, and pass custom configuration options to the underlying generator plugins.

zenwave-sdk-maven-plugin/src · high confidence

The \OpenAPIControllersPlugin\ is now available to generate Spring MVC controller implementations and DTO mappers based on ZDL models and OpenAPI definitions. This plugin processes OpenAPI specs (and optional ZDL models) to produce \ServiceApiController\ classes, \BaseMapper\ and \ServiceDTOsMapper\ files, and optional controller unit tests. It supports both WebFlux and standard Spring MVC styles, handles paginated and array responses, and allows configuration of package names, DTO naming suffixes, and test inclusion via command-line options.

plugins/openapi-controllers/src/main · high confidence

A new plugin (\OpenAPIKaratePlugin\) and generator (\OpenAPIKarateGenerator\) have been added to the \plugins/openapi-karate\ module, enabling users to automatically generate Karate DSL feature files from OpenAPI specifications. The generator supports grouping tests by service, operation, or business flow, and includes built-in helpers for generating JSON examples and handling query/path parameters. Tests verify the output structure for various grouping modes and layout configurations.

plugins/openapi-karate/src · high confidence

The OpenAPI controllers generator now includes a new Handlebars template for Spring MVC REST controllers. This template generates a controller that maps OpenAPI operations to service methods, handling DTO mapping, logging, and response construction. A key behavioral change is the introduction of a \useOptional\ flag for pagination parameters: when enabled, the generated \pageOf\ method accepts \Optional\<Integer\>\ and \Optional\<List\<String\>\>\ for page, limit, and sort, allowing callers to omit these values; otherwise, it uses primitive wrappers with default values (page 0, limit 10). The template also supports binary downloads, paginated responses, and standard array responses.

plugins/openapi-controllers/src/main/resources/io/zenwave360/sdk/plugins/OpenAPIControllersGenerator/src/main/java/web/mvc · high confidence

A new \SpringCloudStreams3AdaptersPlugin\ and its associated generator (\SpringCloudStreams3AdaptersGenerator\) have been added to the \asyncapi-spring-cloud-streams3\ module. This plugin generates Spring Cloud Streams consumer adapters, mappers, and tests from AsyncAPI definitions. It introduces support for Spring Modulith events (outbox and listeners), configurable transactional outbox types (Modulith, MongoDB, JDBC), enterprise envelope wrapping, and runtime header configuration via AsyncAPI extensions. The generator also supports skipping producer implementations and exposes underlying Spring messages to consumers.

plugins/asyncapi-spring-cloud-streams3/src/main · high confidence

The Spring WebTestClient generator now includes a new set of Handlebars templates (BaseWebTestClientTest, BusinessFlowTest, OperationIT, ServiceIT, and associated partials) that generate integration tests using Spring's WebTestClient. These templates support generating request bodies as either Java DTOs or raw JSON strings, automatically handling URI building for path and query parameters, and asserting response status codes and JSON body content.

plugins/openapi-spring-webtestclient/src/main/resources/io/zenwave360/sdk/plugins/SpringWebTestClientGenerator · high confidence

The AsyncAPIOpsGenerator now includes Handlebars templates that generate Terraform configurations for managing Confluent Cloud and Apache Kafka infrastructure. These templates create resources for Kafka topics (with support for default partitions, replication factors, and topic configs), ACLs, service accounts, role bindings, and Schema Registry schemas, allowing users to provision their messaging infrastructure directly from AsyncAPI definitions.

plugins/asyncapi-ops/src/main/resources/io/zenwave360/sdk/plugins/AsyncAPIOpsGenerator · high confidence

The new ZDL-to-Markdown plugin allows users to generate Markdown documentation from ZenWave Domain Language (ZDL) models. It supports three output formats: a glossary of entities and services, a PlantUML state machine diagram for aggregate lifecycles, and a detailed view of a specific aggregate. The plugin parses ZDL content, processes it to resolve relationships and paths, and uses Handlebars templates to produce the final Markdown output, including embedded PlantUML diagrams for state transitions.

plugins/zdl-to-markdown/src/main · high confidence

The event-catalog-generator plugin now includes a comprehensive set of Java record classes to define the structure of frontmatter for various catalog entities. This change introduces specific models for Agents, Channels, Commands, Containers, Data Products, Diagrams, Domains, Entities, Events, Flows, and Queries, alongside a shared \FrontmatterTypes\ class containing common fields and detail panel configurations. These records, which implement the \Frontmatter\ interface and utilize Jackson for serialization, provide the underlying data structures required to generate and manage metadata for these resource types within the event catalog.

plugins/event-catalog-generator/src/main/java/io/zenwave360/sdk/plugins/frontmatter · high confidence

The Spring Cloud Streams 3 generator now includes new Handlebars templates for imperative and reactive consumer implementations. These templates generate service interfaces and consumer components that support both imperative (single message) and reactive (Flux) processing modes. Key additions include configurable Dead Letter Queue (DLQ) routing via Spring configuration, handling for tombstone records (null payloads) through a default handler, and optional support for Spring Modulith events and enterprise envelope unwrapping.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/consumer · high confidence

The backend application default generator now includes new Handlebars templates for inbound Data Transfer Objects (EntityInput, InputOrOutput) and package metadata. These templates generate Java classes that support field validation annotations, handle entity relationships (including OneToOne @MapsId and required relationships via ID fields or full objects), and provide builder-style methods for array fields. This change enhances the generated code's ability to handle complex data structures and validation requirements in inbound requests.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/inbound/dtos · high confidence

The Backend Application Default Generator now includes a new Handlebars template for generating inbound service ports (Service.java.hbs). This template supports Spring Modulith by applying the @NamedInterface annotation when the useSpringModulith flag is enabled, and it conditionally imports CompletableFuture to handle asynchronous service methods defined in the service configuration.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/inbound · high confidence

The Spring Cloud Streams 3 generator now includes new Handlebars templates for producer outbox implementations, providing four distinct strategies: JDBC (using JdbcTemplate to persist messages to a relational database), MongoDB (using MongoTemplate with Change Stream listeners for reliable delivery), Spring Modulith (leveraging ApplicationEventPublisher for event-driven outbox patterns), and a direct 'none' mode (sending directly via StreamBridge without an outbox). These templates generate producer classes that implement the standard producer interface, allowing users to choose the persistence and delivery mechanism that best fits their architecture.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/producer/outbox · high confidence

The CLI and Maven plugin now expose new configuration enums to tailor code generation. Users can select specific database backends (generic, postgresql, mysql, mariadb, oracle) via the DatabaseType option, choose between MongoDB or JPA persistence, and define web frameworks (mvc, webflux) and programming styles (imperative, reactive). Additionally, draft support for AsyncAPI v3 is introduced through new options for API versioning, operation types (publish/send, subscribe/receive), and roles (provider/client).

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/options · high confidence

The SDK now includes a comprehensive set of new project layout definitions in the \zenwave-sdk-cli\ module, allowing users to generate code structures based on specific architectural styles. New layout classes include \CleanArchitectureProjectLayout\ (following Robert C. Martin's ring vocabulary), \CleanHexagonalProjectLayout\ (Ports and Adapters with DDD/EDA), \HexagonalProjectLayout\ (standard Ports and Adapters), \LayeredProjectLayout\ (traditional layered approach), and \SimpleDomainProjectLayout\. These layouts define specific package structures for domain entities, use cases, adapters (web, event, command), and infrastructure, and support modular projects via common package configurations for shared base classes. The \DefaultProjectLayout\ now extends \CleanHexagonalProjectLayout\.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/zdl/layouts · high confidence

The SDK now includes dedicated writer components for handling template output: \TemplateFileWriter\ saves generated code to a specified target folder (with options to skip overwriting existing files), while \TemplateStdoutWriter\ prints the generated content to the console. These classes implement the \TemplateWriter\ interface, providing a structured way to direct template results either to disk or standard output.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/writers · high confidence

The SDK introduces a suite of new utility classes in the \io.zenwave360.sdk.utils\ package to support enhanced AsyncAPI handling and dynamic dependency management. \AsyncAPIUtils\ provides methods to detect AsyncAPI versions (v2 vs v3) and extract operation and channel messages, enabling the SDK to process both specification versions. \MavenLoader\ allows the CLI to dynamically load external Maven dependencies at runtime using JBang, supporting custom repository configurations. Additional utilities include \AntStyleMatcher\ for wildcard pattern matching, \JSONPath\ for safe JSON document navigation, and several Jackson deserialization handlers (\CommaSeparatedCollectionDeserializationHandler\, \ObjectInstantiatorDeserializationHandler\) that improve JSON parsing flexibility for collections and object instantiation.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/utils · high confidence

The backend application generator now supports emitting domain events from service methods. When the \includeEmitEventsImplementation\ flag is enabled, generated methods will automatically map entities or parameters to events and publish them via either an \eventsProducer\ (for async API) or an \eventPublisher\ (for local events). Additionally, generated service method Javadoc now includes a list of associated method policies and explicitly notes if the method is configured to emit events, improving code readability and documentation.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/implementation/partials · high confidence

The CLI now supports loading configuration from ZDL files via the new ConfigurationProvider interface, allowing users to define plugin settings using the ZDL format. Additionally, a new ZdlToJsonPlugin has been added, which allows users to print the internal ZDL model as formatted JSON to standard output, aiding in debugging and inspection of the parsed model structure.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/plugins · high confidence

The ZdlToMarkdownGenerator plugin now includes a new set of Handlebars templates (ZdlToMarkdownAggregate, ZdlToMarkdownGlossary, ZdlToMarkdownPlantUML, and supporting partials like aggregateClass, entityClass, service, and enumClass) that enable the generation of detailed PlantUML diagrams within the produced Markdown documentation. These templates allow users to visualize domain structures, including aggregate-entity relationships, service methods with annotations, command inputs/outputs, domain events, and lifecycle state machines, providing a richer visual representation of the ZDL model alongside the textual documentation.

plugins/zdl-to-markdown/src/main/resources/io/zenwave360/sdk/plugins/ZdlToMarkdownGenerator · high confidence

The ZDL-to-OpenAPI plugin now supports merging external OpenAPI definitions via the new OpenAPIOverlayProcessor (using openapiMergeFile and openapiOverlayFiles options) and allows filtering generated operations by ID using operationIdsToInclude and operationIdsToExclude with Ant-style wildcards. Additionally, a new OpenAPIToJDLPlugin is introduced to generate JDL models from OpenAPI schemas, and the PathsProcessor now exposes serviceMethod details in the generated paths.

plugins/zdl-to-openapi/src/main · high confidence

A new simplelogger.properties file has been added to the CLI resources, establishing default logging behavior. This configuration sets the general log level to info, hides thread names, shows short log names, and specifically enables debug-level logging for the io.zenwave360 package to aid in troubleshooting.

zenwave-sdk-cli/src/main/resources · high confidence

The OpenAPI controllers generator now includes template files for a \BaseMapper\ and a \ServiceDTOsMapper\. The \BaseMapper\ provides default methods for converting between \Instant\, \OffsetDateTime\, \LocalDateTime\, and \byte\[\]\ (mapped to \ByteArrayResource\), ensuring consistent handling of time and binary data across generated mappers. The \ServiceDTOsMapper\ template uses \BaseMapper\ and generates specific mapping methods for request and response DTOs, including support for paginated responses via \Page\ objects.

plugins/openapi-controllers/src/main/resources/io/zenwave360/sdk/plugins/OpenAPIControllersGenerator/src/main/java/web/mappers · high confidence

The backend application generator now supports distinct primary key generation strategies for Oracle, MySQL, MariaDB, PostgreSQL, and generic databases. This is achieved by introducing new Handlebars templates (oracle.hbs, mysql.hbs, mariadb.hbs, postgresql.hbs, generic.hbs) in the JPA ID partials directory, which configure the appropriate JPA annotations (such as GenerationType.IDENTITY for MySQL/MariaDB and GenerationType.SEQUENCE for Oracle/PostgreSQL) to match each database's native capabilities.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/domain/jpa/partials/id · high confidence

The Spring Cloud Streams 3 generator now includes new template partials that significantly improve how message headers are processed at runtime. The \runtime-headers.hbs\ partial introduces support for Spring Expression Language (SpEL) via \\#{...}\ syntax, JSON Pointer navigation via \\#/...\ syntax, and external value suppliers via \$...\ syntax, allowing dynamic header population based on the message payload or Spring beans. Additionally, the \wrapNullPayload.hbs\ partial ensures that null payloads are correctly wrapped in Spring Kafka's \KafkaNull\ instance when necessary, preventing potential issues with Kafka message sending.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/producer/partials · high confidence

The JDL-to-AsyncAPI generator plugin has been refactored to accept ZDL (Zenwave Domain Language) models via the \zdlFile\ option (with backward compatibility for the legacy \specFile\ name) and to generate AsyncAPI definitions in both v2 and v3 formats. Users can now select the target version using the \asyncapiVersion\ option, which switches the output structure to AsyncAPI 3.0.0 semantics (e.g., separating channels and operations). The plugin continues to support generating AsyncAPI specs from JDL entities, with options to include command requests and domain events, and supports both AsyncAPI schema and Avro payload formats.

plugins/jdl-to-asyncapi/src · high confidence

The SDK's Java source formatting has switched from Google Java Format to Spring Java Format as the default implementation, addressing compatibility issues with newer Java versions. Users can now explicitly choose between three formatters—Spring (default), Palantir, and Google—via the \formatter\ option. The system also introduces a Kotlin formatter (using ktfmt) for Kotlin projects and includes an import organizer that gracefully handles JDK internal API restrictions by falling back to the original source if import fixing fails.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/formatters · high confidence

The backend application generator now includes new Handlebars templates in the core domain common package to support richer domain modeling. Aggregate.java.hbs and AggregateTransitions.java.hbs generate aggregate root wrappers with command methods that enforce state machine lifecycle transitions via a dedicated transitions class and InvalidStateTransitionException. EntityTransitions.java.hbs provides similar state-transition enforcement for standalone entities. DomainEvent.java.hbs generates serializable domain event classes with optional Spring Modulith naming and Lombok support. The Enum.java.hbs template (used by DomainEnum, EventEnum, and InputEnum) now restricts enum values to integers only, including a JPA AttributeConverter for persistence mapping when JPA is the selected persistence strategy.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/domain/common · high confidence

The CLI now includes new Handlebars templates (detailed, list, markdown, and help) that define how plugin help information is rendered. Users will see structured output for available plugins, including summaries, descriptions, and detailed option lists with defaults and allowed values, accessible via the help command.

zenwave-sdk-cli/src/main/resources/io · high confidence

The parser module has been restructured to support Zenwave Definition Language (ZDL) alongside existing YAML/OpenAPI parsing. ZDLParser now loads and parses ZDL files, handles referenced API models (resolving ZDL vs YAML references differently), and provides configuration updates to plugins via the ConfigurationProvider interface. Authentication support has been added to SpecResourceLoader and DefaultYamlParser, allowing secure fetching of remote resources. The GraphQLParser is currently disabled (returns null). New helper classes include Model for wrapping parsed results with references, JSONMerger for deep merging, and WithProjectClassLoader interface for classloader injection.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/parsers · high confidence

The generated producer interface template has been updated to include a headers parameter in the method signatures, allowing producers to send AsyncAPI-defined headers alongside message payloads. The template also supports custom @Generated annotations via the generatedAnnotationClass variable and correctly imports header property types, ensuring that date-time and other complex header types are properly handled in the generated code.

plugins/asyncapi-spring-cloud-streams3/src/main/resources/io/zenwave360/sdk/plugins/SpringCloudStream3Generator/producer · high confidence

The backend application default generator now uses new Handlebars partials to structure service method bodies for both JPA and MongoDB backends. For JPA, the \methodBody\ partial delegates to specific aggregate command templates via a helper, while \methodAnnotations\ now explicitly applies \@Transactional(readOnly = true)\ for GET operations and \@Async\ for async methods. MongoDB templates follow a similar pattern, with dedicated partials for aggregate commands and void methods. This change refactors how service methods are generated, enabling better support for rich aggregate modeling and idiomatic transaction handling.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/implementation/partials/jpa · high confidence

The ZDL project generator now returns a structured \GeneratedProjectFiles\ object that categorizes generated artifacts (such as aggregates, entities, services, and listeners) rather than a flat list, and template definitions have been moved into a new \ProjectTemplates\ class. This change allows for better organization of generated code and supports specific template configurations for internal and AsyncAPI listeners, as well as Kotlin+Spring Boot projects, by externalizing how templates are defined and applied.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/zdl · high confidence

The BackendApplicationDefaultGenerator's service method body generation has been refactored to introduce structured support for entity lifecycle states and domain events. New support classes (LifecycleSupport, ServiceEventPlanner, ServiceMethodBodyPlanner) and a MethodBodyCase enum now drive the generation of service method bodies, enabling proper handling of state transitions (from/to), natural ID lookups, and event publishing (both domain and AsyncAPI). The corresponding Handlebars partials (entities-methodBody.hbs, aggregates-commands-methodBody.hbs, entities-crud-methodBody.hbs) have been updated to use these helpers, resulting in generated service methods that correctly manage entity lifecycle transitions and emit events where defined.

plugins/backend-application-default/src/main/java/io/zenwave360/sdk/plugins/support, plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/implementation/partials/shared · high confidence

The code generation engine has been restructured to improve modularity and template handling. A new base \Generator\ class now centralizes configuration processing, automatically flattening \additionalProperties\ into the template context so that pass-through options are directly available in templates. Abstract base classes (\AbstractAsyncapiGenerator\, \AbstractOpenAPIGenerator\, \AbstractZDLGenerator\) have been introduced to standardize generation logic for their respective protocols. Additionally, new converter utilities (\EntitiesToAvroConverter\, \EntitiesToSchemasConverter\) and a \JsonSchemaToJsonFaker\ (which now defaults the 'sort' property to 'id:asc') have been added to support domain model conversion and example data generation.

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/generators · high confidence

The templating subsystem has been restructured to support more granular code generation. A new \AnnotationHelper\ allows templates to render annotations filtered by artifact type (e.g., domain entity vs. repository port). \AsyncapiHandlebarsHelpers\ provide specific access to AsyncAPI model properties like operation messages and generated Java types. \CustomHandlebarsHelpers\ introduce new logic for populating property defaults (handling enums, dates, and references) and improve path resolution in partials. The core \HandlebarsEngine\ now registers these helpers and manages context isolation during template processing. Supporting data structures \TemplateInput\ and \TemplateOutput\ define the contract for template execution, including skip logic and MIME types, while \OutputFormatType\ enumerates supported output formats (Java, Kotlin, YAML, etc.).

zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/templating · high confidence

The generated service implementation templates now explicitly apply the @Transactional annotation to ensure database operations are managed within transactions. Additionally, when Spring Modulith is enabled, the generated services are annotated with @NamedInterface to integrate with the modulith architecture. The template also conditionally imports event-related classes (AsyncApiProducer or EventPublisher) based on service configuration, and supports Lombok for constructor generation.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/implementation/imperative · high confidence

The backend application generator's JPA relationship templates (ManyToMany, ManyToOne, OneToMany, OneToOne) now include Jackson annotations (@JsonManagedReference/@JsonBackReference) to prevent serialization cycles, and the OneToOne template supports @MapsId for required relationships.

plugins/backend-application-default/src/main/resources/io/zenwave360/sdk/plugins/BackendApplicationDefaultGenerator/src/main/java/core/domain/jpa/partials · high confidence

The e2e module now includes a new empty Java class (Empty.java) to resolve the issue of an empty module structure, ensuring the module contains at least one class.

e2e/src/main · high confidence

Added E2E test fixtures for AsyncAPI Ops Terraform Kafka defaulting; Added Handlebars template test resources for templating validation; Added Kotlin backend application test resources; Added e2e test fixtures for Clean Architecture and Hexagonal project layouts; Added e2e test fixtures for SimpleDomainPackaging and ThreeLayersProject layouts; Added e2e test project for PostgreSQL JSON customer-address domain; Added e2e test project for patch and naturalId features; Added e2e test resources for Kotlin-based clinical monolith project; Added e2e test resources for clinical monolith domain models; Added e2e test resources for online food delivery microservices; Added e2e test resources for online-food-delivery-mongo modulith; Added e2e test resources for the clinical modular monolith; Added end-to-end test resources for relational customer-address scenarios; Added end-to-end tests for Kotlin backend application generation; Added test coverage for AsyncAPI Ops plugin intent processing and Terraform generation; Added test coverage for CLI help, plugin configuration, and generator workflows; Added test coverage for SDK generator components; Added test coverage for SDK processors; Added test coverage for Spring Cloud Streams 3 AsyncAPI generators; Added test coverage for ZDL-to-Markdown plugin generation; Added test coverage for ZDL-to-OpenAPI generation and processing; Added test coverage for parser components; Added test coverage for the Event Catalog Generator plugin; Added test fixtures for the Java-to-AsyncAPI event producer plugin; Added test resources for AsyncAPI Ops plugin; Added test resources for ZDL aggregate, async, and field population scenarios; Added test template for MVC Service API controllers; Added tests for AsyncAPI generator Avro and JSON code generation; Added tests for AsyncAPI generator plugin with Avro, JSON, and Kafka templates; Added tests for AsyncAPI v3 generation and configuration options; Added tests for Java and Kotlin code formatters; Added tests for OpenAPI controller generation and dummy data processing; Added tests for Spring WebTestClient generator; Added tests for ZDL annotation helpers and annotators; Added tests for ZDL configuration and plugin generation; Added tests for ZDL model parsing and project template helper selection; Added tests for ZDL project layout package structures; Added tests for the ZDL annotator framework and backend generator plugins; Added unit tests for ZDL utility classes; Added unit tests for ZDL-to-AsyncAPI generation and client generation; Added unit tests for ZenWaveProjectTools; Added unit tests for backend application default support helpers; Added unit tests for template engine and Handlebars helpers; Expanded end-to-end test coverage for project layouts and async API operations; Generated test infrastructure for architecture validation, in-memory testing, and integration.

The e2e test suite now includes new Maven project templates demonstrating ZenWave SDK usage with Spring Boot 4.0.0, including clean-architecture, hexagonal, and modular monolith (online-food-delivery-mongo) examples. These projects validate plugin configurations for OpenAPI and AsyncAPI generation, Spring Cloud Stream integration, and jMolecules annotations against the latest Spring Boot release.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 62 → 71 (+9.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 86 (+8.0)
• Architecture 100 → 100 (-0.1)
• Maturity 77 → 79 (+2.7)
• Readiness 53 → 61 (+7.7)
• Security 57 → 77 (+20.3)
• Accessibility 78 (new)

• AsyncAPIUtils.extractMessages (cognitive 19) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/utils/AsyncAPIUtils.java)
• Coverage not included — suite not readable by the collector
• Critical vulnerability: [GHSA redacted] (Gemfile.lock)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (plugins/java-to-asyncapi/src/main/java/io/zenwave360/sdk/plugins/JavaToAsyncAPIGenerator.java)
• Duplicated block (10 lines × 2) (plugins/zdl-to-markdown/src/main/java/io/zenwave360/sdk/plugins/LifecycleDiagramBuilder.java)
• Duplicated block (10 lines × 2) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/formatters/GoogleJavaFormatter.java)
• Duplicated block (10 lines × 3) (plugins/event-catalog-generator/src/main/java/io/zenwave360/sdk/plugins/EventCatalogAsyncApiProcessor.java)
• Duplicated block (11 lines × 2) (plugins/zdl-to-markdown/src/main/java/io/zenwave360/sdk/plugins/LifecycleDiagramBuilder.java)
• Duplicated block (12 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/AsyncAPIGenerator.java)
• Duplicated block (12 lines × 2) (plugins/customizations/kotlin-backend-application/src/main/java/io/zenwave360/sdk/plugins/kotlin/OpenAPIControllersKotlinHelpers.java)
• Duplicated block (12 lines × 2) (plugins/customizations/kotlin-backend-application/src/main/java/io/zenwave360/sdk/plugins/kotlin/OpenAPIControllersKotlinHelpers.java)
• Duplicated block (12 lines × 2) (plugins/zdl-to-markdown/src/main/java/io/zenwave360/sdk/plugins/LifecycleDiagramBuilder.java)
• Duplicated block (13 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates/AsyncAPIHandlebarsHelpers.java)
• Duplicated block (13 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates/AsyncAPIHandlebarsHelpers.java)
• Duplicated block (13 lines × 2) (plugins/java-to-asyncapi/src/main/java/io/zenwave360/sdk/plugins/JavaToAsyncAPIGenerator.java)
• Duplicated block (5 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates/AsyncAPIHandlebarsHelpers.java)
• Duplicated block (5 lines × 2) (plugins/backend-application-default/src/main/java/io/zenwave360/sdk/plugins/support/CrudMethodSupport.java)
• Duplicated block (5 lines × 2) (plugins/backend-application-default/src/main/java/io/zenwave360/sdk/plugins/support/RepositoryIdSupport.java)
• Duplicated block (5 lines × 2) (plugins/customizations/kotlin-backend-application/src/main/java/io/zenwave360/sdk/plugins/kotlin/OpenAPIControllersKotlinHelpers.java)
• …and 88 more

• ClassTooLong: EventCatalogGenerator (plugins/event-catalog-generator/src/main/java/io/zenwave360/sdk/plugins/EventCatalogGenerator.java)
• Coverage not measured — JavaScript/TypeScript suite
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no architecture or design documentation (plugins/event-catalog-generator/event-catalog-project/README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (plugins/java-to-asyncapi/README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (plugins/asyncapi-ops/src/main/java/io/zenwave360/sdk/plugins/AsyncAPIOpsIntentProcessor.java)
• Duplicated block (10 lines × 2) (plugins/event-catalog-generator/src/main/java/io/zenwave360/sdk/plugins/EventCatalogGenerator.java)
• Duplicated block (10 lines × 2) (plugins/event-catalog-generator/src/main/java/io/zenwave360/sdk/plugins/EventCatalogOpenApiProcessor.java)
• Duplicated block (10 lines × 2) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/formatters/GoogleJavaFormatter.java)
• Duplicated block (10 lines × 3) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/generators/AbstractAsyncapiGenerator.java)
• Duplicated block (11 lines × 3) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/formatters/GoogleJavaFormatter.java)
• Duplicated block (12 lines × 2) (plugins/customizations/kotlin-backend-application/src/main/java/io/zenwave360/sdk/plugins/kotlin/OpenAPIControllersKotlinHelpers.java)
• Duplicated block (12 lines × 2) (zenwave-sdk-cli/src/main/java/io/zenwave360/sdk/processors/OverlayApplicator.java)
• Duplicated block (12 lines × 6) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates/AsyncAPIHandlebarsHelpers.java)
• Duplicated block (13 lines × 2) (plugins/zdl-to-markdown/src/main/java/io/zenwave360/sdk/plugins/LifecycleDiagramBuilder.java)
• Duplicated block (15 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/AsyncAPIGenerator.java)
• Duplicated block (15–16 lines × 2) (plugins/zdl-to-markdown/src/main/java/io/zenwave360/sdk/plugins/LifecycleDiagramBuilder.java)
• Duplicated block (16 lines × 2) (plugins/asyncapi-generator/src/main/java/io/zenwave360/sdk/plugins/templates/AsyncAPIHandlebarsHelpers.java)
• …and 175 more

• 38 commits — 35 feature/other, 3 fixes

• (repo) — 12 commits
• plugins/customizations — 8 commits
• (root) — 6 commits
• plugins/event-catalog-generator — 4 commits
• zenwave-sdk-cli/src — 2 commits
• .github/workflows — 1 commit
• e2e/src — 1 commit
• plugins/asyncapi-generator — 1 commit
• plugins/asyncapi-ops — 1 commit
• plugins/backend-application-default — 1 commit
• plugins/zdl-to-asyncapi — 1 commit

• fix: fix(asyncapi-ops): automatically include sibling *.avsc files from the root schema’s directory.
• fix: fix(zdl-to-asyncapi): v3 message names to use Command, Response, or Event suffixes
• fix: fix: jbang-catalog.json and manifest-core.version
• change: Merge branch 'main' into develop
• change: Merge pull request #140 from ZenWave360/develop
• change: Merge pull request #146 from ZenWave360/release/2.6.0
• change: Merge pull request #147 from ZenWave360/release/2.6.0
• change: Merge pull request #148 from ZenWave360/main
• change: Merge pull request #149 from ZenWave360/ivangsa-patch-1
• change: Merge pull request #150 from ZenWave360/develop
• change: Merge pull request #151 from ZenWave360/develop
• change: Merge pull request #152 from ZenWave360/release/2.7.0
• change: Merge pull request #153 from ZenWave360/main
• change: Merge pull request #154 from ZenWave360/develop
• change: Merge pull request #155 from ZenWave360/release/2.7.1
• change: Update zenwave-sdk-cli and plugin versions to 2.7.0
• change: [maven-release-plugin] prepare for next development iteration
• change: [maven-release-plugin] prepare for next development iteration
• change: [maven-release-plugin] prepare for next development iteration
• change: [maven-release-plugin] prepare for next development iteration
• …and 18 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ZenWave360/zenwave-sdk was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.