ci(docs): Add docs in main branch, commit gradle version on relese

Author: juancgalvis

.gitignore

@@ -644,5 +644,4 @@ MigrationBackup/
 # End of https://www.toptal.com/developers/gitignore/api/macos,linux,windows,gradle,java,intellij,visualstudio,eclipse
 contiperf-report
 
-samples/async/local-example/
-docs
+samples/async/local-example/

docs/.gitignore

@@ -0,0 +1,20 @@
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.docusaurus
+.cache-loader
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

docs/.nvmrc

@@ -0,0 +1 @@
+v20.11.1

docs/README.md

@@ -0,0 +1,41 @@
+# Website
+
+This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
+
+### Installation
+
+```
+$ yarn
+```
+
+### Local Development
+
+```
+$ yarn start
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+### Build
+
+```
+$ yarn build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+### Deployment
+
+Using SSH:
+
+```
+$ USE_SSH=true yarn deploy
+```
+
+Not using SSH:
+
+```
+$ GIT_USER=<Your GitHub username> yarn deploy
+```
+
+If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

docs/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
+};

docs/docs/img/reactive-commons.png

@@ -0,0 +1,82 @@
+---
+sidebar_position: 1
+---
+
+# Overview
+
+![Maven metadata URL](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Frepo1.maven.org%2Fmaven2%2Forg%2Freactivecommons%2Fasync-commons-rabbit-starter%2Fmaven-metadata.xml)
+
+## Reactive Commons
+
+![Example banner](./img/reactive-commons.png)
+
+The purpose of reactive-commons is to provide a set of abstractions and implementations over different patterns and practices that make the foundation of a reactive microservices architecture.
+
+Even though the main purpose is to provide such abstractions in a mostly generic way such abstractions would be of little use without a concrete implementation so we provide some implementations in a best effors maner that aim to be easy to change, personalize and extend.
+
+The first approach to this work was to release a very simple abstractions and a corresponding implementation over asyncronous message driven communication between microservices build on top of project-reactor and spring boot.
+
+
+## Project Reactor
+
+[Reactor](https://projectreactor.io) is a highly optimized reactive library for
+building efficient, non-blocking applications on the JVM based on the
+[Reactive Streams Specification](https://github.com/reactive-streams/reactive-streams-jvm).
+Reactor based applications can sustain very high throughput message rates
+and operate with a very low memory footprint,
+making it suitable for building efficient event-driven applications using
+the microservices architecture.
+
+Reactor implements two publishers
+[Flux\<T>](https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html) and
+[Mono\<T>](https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html),
+both of which support non-blocking back-pressure.
+This enables exchange of data between threads with well-defined memory usage,
+avoiding unnecessary intermediate buffering or blocking.
+
+## Reactive API for Event Mechanism
+
+Reactive Commons is a reactive API for asynchronous message driven communication based on Reactor.
+Reactive Commons API enables messages to be published over a event bus like RabbitMQ or SNS/SQS and consumed using functional APIs with non-blocking back-pressure and low overheads.
+It enables applications using Reactor to use RabbitMQ or SNS/SQS as a message bus, integrating it with other systems to provide an end-to-end reactive system.
+
+When we talk about asynchronous message driven communication, we can use several sematic ways to use the term "message". So, we can talk about Events, Commands and Queries.
+
+## Cloud Events
+
+[CloudEvents](https://cloudevents.io/) is a specification for describing event data in a common way. CloudEvents seeks to dramatically simplify event declaration and delivery across services, platforms, and beyond!
+
+## Async API
+
+[Async API](https://www.asyncapi.com/) Open-Source tools to easily build and maintain your event-driven architecture. All powered by the AsyncAPI specification, the industry standard for defining asynchronous APIs.
+
+## Reactive Commons Abstraction
+
+#### Events - Pub/Sub
+
+Events represent a fact inside the domain, it is the representation of a decision or a state change that a system want to notify to its subscribers. Events represents facts that nobody can change, so events are not intentions or requests of anything, An example may be and UserRegistered or a NotificationSent.
+
+Events are the most important topic in a Publish-Subscribe system, because this element let's notify a many stakeholders in a specific event. An other benefit is the system is decouple, because you can add more subscriber to the system without modify some component.
+
+We support a Notification Event pattern in which each instance of an app can receive an event, it can be used to refresh or invalidate some data in all replicas.
+
+#### Commands
+
+Commands represent a intention for doing something, that intention must to be done by the domain context with that responsibility. An example of a command may be:  "registerUser" or "sendNotification".
+
+#### Request / Reply
+
+Queries represent a intention for getting information about something, that query must to be processed by the domain context with that responsibility and that context must respond with the information requested throught request/reply pattern. An example of a query may be:  "UserInfo".
+
+## Versioning
+
+Reactive Commons uses [Semantic Versioning Specification](https://semver.org)
+
+Reactive Commons uses a MAJOR.MINOR.PATCH scheme, whereby an increment in:
+
+MAJOR version when you make incompatible API changes,
+
+MINOR version when you add functionality in a backwards compatible manner, and
+
+PATCH version when you make backwards compatible bug fixes. Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format. == New & Noteworthy
+

docs/docs/intro.md

@@ -0,0 +1,79 @@
+---
+sidebar_position: 1
+---
+
+# Getting Started
+
+## What Changes in this Variant?
+
+Before start this guide please review base [Reactive Commons](/reactive-commons-java/docs/category/reactive-commons)
+
+### Multi Broker or Multi Domain support
+
+This variant enables to you the ability to listen events from different domains, send commands to different domains and make queries to different domains.
+
+### Cloud Events
+
+This variant also includes the Cloud Events specification
+
+## Setup
+
+### Current version
+![Maven metadata URL](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Frepo1.maven.org%2Fmaven2%2Forg%2Freactivecommons%2Fasync-commons-rabbit-starter-eda%2Fmaven-metadata.xml)
+
+### Dependency
+
+```groovy
+dependencies {
+  implementation "org.reactivecommons:async-commons-rabbit-starter-eda:<version>"
+}
+```
+
+### Configuration properties
+
+Also you need to include the name for your app in the `application.properties`, it is important because this value will be used
+to name the application queues inside RabbitMQ:
+
+```properties
+spring.application.name=MyAppName
+```
+
+Or in your `application.yaml`
+
+```yaml
+spring:
+  application:
+    name: MyAppName
+```
+
+You can set the RabbitMQ connection properties through spring boot with the [`spring.rabbitmq.*` properties](https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html)
+
+```yaml
+spring:
+  rabbitmq:
+   host: localhost
+   port: 5672
+   username: guest
+   password: guest
+   virtual-host: /
+```
+
+You can also set it in runtime for example from a secret, so you can create the `RabbitProperties` bean like:
+
+```java title="org.reactivecommons.async.rabbit.config.RabbitProperties"
+@Configuration
+public class MyRabbitMQConfig {
+
+    @Bean
+    @Primary
+    public RabbitProperties customRabbitProperties(){
+        RabbitProperties properties = new RabbitProperties();
+        properties.setHost("localhost");
+        properties.setPort(5672);
+        properties.setVirtualHost("/");
+        properties.setUsername("guest");
+        properties.setPassword("guest");
+        return properties;
+    }
+}
+```

docs/docs/reactive-commons-eda/1-getting-started.md

@@ -0,0 +1,52 @@
+---
+sidebar_position: 2
+---
+
+# Creating a CloudEvent
+
+## Aditional Dependencies
+
+To start using this approach you should know the base of `Events`, `Commands` and `AsyncQuery`
+
+This varian includes an object mapper that allows to you to emit CloudEvent serialize and deserialize.
+
+Each API includes overloads related to emit CloudEvent events, send CloudEvent commands and make CloudEvent async queries.
+
+In order to instantiate a CloudEvent you need to include the dependencies:
+
+```groovy
+implementation 'io.cloudevents:cloudevents-core:3.0.0'
+implementation 'io.cloudevents:cloudevents-http-basic:3.0.0'
+implementation 'io.cloudevents:cloudevents-json-jackson:3.0.0'
+implementation 'io.cloudevents:cloudevents-spring:3.0.0'
+```
+## Creating a CloudEvent instance
+
+```java
+ObjectMapper om = new ObjectMapper();
+
+CloudEvent commandCloudEvent = CloudEventBuilder.v1()
+    .withId(UUID.randomUUID().toString())
+    .withSource(URI.create("https://reactivecommons.org/foos"))
+    .withType("some.command.name")
+    .withTime(OffsetDateTime.now())
+    .withData("application/json", om.writeValueAsBytes(command)) // command is your own object
+    .build();
+
+CloudEvent queryCloudEvent = CloudEventBuilder.v1()
+    .withId(UUID.randomUUID().toString())
+    .withSource(URI.create("https://reactivecommons.org/foos"))
+    .withType("some.query.name")
+    .withTime(OffsetDateTime.now())
+    .withData("application/json", om.writeValueAsBytes(query)) // query is your own object
+    .build();
+
+CloudEvent eventCloudEvent = CloudEventBuilder.v1()
+    .withId(UUID.randomUUID().toString())
+    .withSource(URI.create("https://reactivecommons.org/foos"))
+    .withType("some.event.name")
+    .withDataContentType("application/json")
+    .withTime(OffsetDateTime.now())
+    .withData("application/json", om.writeValueAsBytes(event)) // event is your own object
+    .build();
+```

docs/docs/reactive-commons-eda/2-creating-a-cloud-event.md

@@ -0,0 +1,57 @@
+---
+sidebar_position: 3
+---
+
+# Additional API Definitions
+
+Returning to the base API, the additional methods enabled for EDA and CloudEvents are indicated below.
+
+## Aditional Methods in Senders
+
+### DomainEventBus interface
+
+This interface has one additional method specific for EDA
+
+```java
+public interface DomainEventBus {
+    Publisher<Void> emit(CloudEvent event); // Emit with CloudEvent format
+
+    //... other base definitions
+}
+```
+
+### DirectAsyncGateway interface
+
+Ths interface adds some actions for commands and async queries
+
+```java
+public interface DirectAsyncGateway {
+    <T> Mono<Void> sendCommand(Command<T> command, String targetName, String domain); // Send to specific domain
+
+    <T> Mono<Void> sendCommand(Command<T> command, String targetName, long delayMillis, String domain); // Send to specific domain with delay
+
+    Mono<Void> sendCommand(CloudEvent command, String targetName); // Send with CloudEvent format
+
+    Mono<Void> sendCommand(CloudEvent command, String targetName, String domain); // Send with CloudEvent format to an specific domain
+
+    <T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type, String domain); // Query to specific domain
+
+    <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type); // Query with CloudEvent format
+
+    <R extends CloudEvent> Mono<R> requestReply(CloudEvent query, String targetName, Class<R> type, String domain); // Query with CloudEvent format to specific domain
+}
+```
+
+## Aditional Listener capabilities
+
+On the other hand, for listener you can use additional capabilities like listen from another domain
+
+### HandlerRegistry class
+
+```java
+public class HandlerRegistry {
+    public <T> HandlerRegistry listenDomainEvent(String domain, String eventName, EventHandler<T> handler, Class<T> eventClass) {...} // Class could be CloudEvent.class
+
+    // ... other base methods
+}
+```