build: fix checkstyle issues

Signed-off-by: Maximillian Arruda <dearrudam@gmail.com>

api/nosql-column/src/main/java/jakarta/nosql/column/ColumnTemplate.java

@@ -30,7 +30,9 @@
  * where each column contains a particular attribute or piece of information.
  *
  * <p>
- * This interface provides some methods that accepts queries in a text format to retrieve from the database but, <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it. Accordingly, it might vary from implementation and NoSQL provider.</b>
+ * This interface provides some methods that accepts queries in a text format to retrieve from the database but,
+ * <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it.
+ * Accordingly, it might vary from implementation and NoSQL provider.</b>
  */
 public interface ColumnTemplate extends Template {
 

api/nosql-core/src/main/java/jakarta/nosql/Column.java

@@ -45,7 +45,8 @@
      * }
      * }</pre>
      * <p>
-     * If any name customization is needed, it just set the single attribute of the annotation to specify the desired name. In the sample below the Person name field will be mapped to the "personName" column:
+     * If any name customization is needed, it just set the single attribute of the annotation to specify the desired name.
+     * In the sample below the Person name field will be mapped to the "personName" column:
      *
      * <pre>{@code
      * @Entity

api/nosql-core/src/main/java/jakarta/nosql/Entity.java

@@ -52,7 +52,8 @@
  * }
  * }</pre>
  * <p>
- * However, it’s essential to remember that NoSQL databases have varying behaviors then the serialization method may differ depending on the NoSQL vendor. For instance, in a Document database, these entities may be converted into a sub-document, while on a Key-value, it will be the value:
+ * However, it’s essential to remember that NoSQL databases have varying behaviors then the serialization method may differ depending on the NoSQL vendor.
+ * For instance, in a Document database, these entities may be converted into a sub-document, while on a Key-value, it will be the value:
  *
  * <pre>{@code
  * {

api/nosql-core/src/main/java/jakarta/nosql/Template.java

@@ -25,10 +25,14 @@
  * It follows the standard template pattern, a common design pattern used in software development.
  *
  * <p>
- * The Template pattern involves creating a skeletal structure for an algorithm, with some steps implemented and others left to be implemented by subclasses. Similarly, the Template feature in Jakarta NoSQL makes a skeleton around NoSQL database operations, allowing developers to focus on implementing the specific logic required for their application.
+ * The Template pattern involves creating a skeletal structure for an algorithm, with some steps implemented and others left to be implemented by subclasses. Similarly, the
+ * Template feature in Jakarta NoSQL makes a skeleton around NoSQL database operations, allowing developers to focus on implementing the specific logic required for their
+ * application.
  *
  * <p>
- * Overall, the Template feature in Jakarta NoSQL provides a simple and efficient way to implement common database operations while following established design patterns like the Template Method. By using the Template feature, developers can save time and effort in implementing their NoSQL database operations, allowing them to focus on other aspects of their application.
+ * Overall, the Template feature in Jakarta NoSQL provides a simple and efficient way to implement common database operations while following established design patterns like
+ * the Template Method. By using the Template feature, developers can save time and effort in implementing their NoSQL database operations, allowing them to focus on other
+ * aspects of their application.
  *
  * <pre>{@code
  * @Inject
@@ -52,7 +56,8 @@
  *
  * }</pre>
  * <p>
- * Furthermore, in CRUD operations, Template provides a fluent-API for either select or delete entities. Thus, Template offers the capability for search and remove beyond the ID attribute. Take a look at {@link QueryMapper} for more detail about the provided fluent-API.
+ * Furthermore, in CRUD operations, Template provides a fluent-API for either select or delete entities. Thus, Template offers the capability for search and remove beyond the ID
+ * attribute. Take a look at {@link QueryMapper} for more detail about the provided fluent-API.
  *
  * <pre>{@code
  * @Inject
@@ -89,7 +94,6 @@
  * }</pre>
  *
  * @see QueryMapper
- *
  */
 public interface Template {
 

api/nosql-document/src/main/java/jakarta/nosql/document/DocumentTemplate.java

@@ -29,7 +29,9 @@
  * These databases store data as documents, individual data sets that can be grouped into collections.
  *
  * <p>
- * This interface provides some methods that accepts queries in a text format to retrieve from the database but, <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it. Accordingly, it might vary from implementation and NoSQL provider.</b>
+ * This interface provides some methods that accepts queries in a text format to retrieve from the database but,
+ * <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it.
+ * Accordingly, it might vary from implementation and NoSQL provider.</b>
  */
 public interface DocumentTemplate extends Template {
 

api/nosql-document/src/main/java/jakarta/nosql/document/package-info.java

@@ -27,13 +27,16 @@
  * <p>
  * Document-oriented databases are inherently a subclass of the key-value store, another NoSQL database concept.
  * <p>
- * The difference lies in the way the data is processed; in a key-value store the data is considered to be inherently opaque to the database, whereas a document-oriented system relies on internal structure in the document in order to extract metadata that the database engine uses for further optimization.
+ * The difference lies in the way the data is processed; in a key-value store the data is considered to be inherently opaque to the database, whereas a document-oriented system
+ * relies on internal structure in the document in order to extract metadata that the database engine uses for further optimization.
  * <p>
  * Although the difference is often moot due to tools in the systems, conceptually the document-store is designed to offer a richer experience with modern programming techniques.
  * <p>
  * Document databases contrast strongly with the traditional relational database (RDB).
- * Relational databases generally store data in separate tables that are defined by the programmer, and a single object may be spread across several tables. Document databases store all information for a given object in a single instance in the database, and every stored
- * object can be different from every other. This makes mapping objects into the database a simple task, normally eliminating anything similar to an
+ * Relational databases generally store data in separate tables that are defined by the programmer, and a single object may be spread across several tables.
+ * Document databases store all information for a given object in a single instance in the database, and every stored
+ * object can be different from every other.
+ * This makes mapping objects into the database a simple task, normally eliminating anything similar to an
  * object-relational mapping. This makes document stores attractive
  * for programming web applications, which are subject to continual change in place, and where speed of deployment is an important issue.
  */

api/nosql-key-value/src/main/java/jakarta/nosql/keyvalue/KeyValueTemplate.java

@@ -36,7 +36,9 @@
  * for a piece of data.
  *
  * <p>
- * This interface provides some methods that accepts queries in a text format to retrieve from the database but, <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it. Accordingly, it might vary from implementation and NoSQL provider.</b>
+ * This interface provides some methods that accepts queries in a text format to retrieve from the database but,
+ * <b>the query syntax belongs to each provider, thus, it is not Jakarta's NoSQL scope to define it.
+ * Accordingly, it might vary from implementation and NoSQL provider.</b>
  */
 public interface KeyValueTemplate extends Template {
     /**

api/nosql-key-value/src/main/java/jakarta/nosql/keyvalue/package-info.java

@@ -23,8 +23,10 @@
  * The key-value model is one of the simplest non-trivial data models, and richer data models are often implemented
  * as an extension of it.
  * <p>
- * The key-value model can be extended to a discretely ordered model that maintains keys in lexicographic order. This extension is computationally powerful, in that it can efficiently retrieve selective key ranges.
+ * The key-value model can be extended to a discretely ordered model that maintains keys in lexicographic order.
+ * This extension is computationally powerful, in that it can efficiently retrieve selective key ranges.
  * <p>
- * Key-value stores can use consistency models ranging from eventual consistency to serializability. Some databases support ordering of keys. There are various hardware implementations, and some users maintain data in memory (RAM), while others employ solid-state drives or rotating disks.
+ * Key-value stores can use consistency models ranging from eventual consistency to serializability. Some databases support ordering of keys.
+ * There are various hardware implementations, and some users maintain data in memory (RAM), while others employ solid-state drives or rotating disks.
  */
 package jakarta.nosql.keyvalue;