[BUG] Failed to start quarkus: org.eclipse.jnosql.mapping.reflection.ConstructorException is thrown on using Java Records as entities
### Which JNoSQL project the issue refers to?

JNoSQL (Core)

### Bug description

Quarkus wasn't able to start during the tests execution of the PR: https://github.com/JNOSQL/demos-ee/pull/13. Here are the error log messages from the CI results: https://github.com/JNOSQL/demos-ee/actions/runs/5501334804/jobs/10024846814#step:4:4940 ;

The project is using Java Record as an entity (click [here](https://github.com/JNOSQL/demos-ee/pull/13/files#diff-2b076d6cb015e3dd509722da43baf2317738ed2253a795b1b026043972f5a663L12) to see the whole record):

```java
@Entity
public record Developer(
        @Id String id,
        @Column String name,
        @Column LocalDate birthday
) {
// skipped implementation
}
```
 And the root throwable below is thrown when the implementation didn't could detect a valid constructor:

```text
Caused by: org.eclipse.jnosql.mapping.reflection.ConstructorException: This class must have a no arg with either public or default visibility: org.jnosql.demoee.Developer
```

![Peek 2023-07-09 17-41](https://github.com/eclipse/jnosql/assets/6537623/8ef82468-a4fa-464c-bb5b-b441c919c25c)

Debugging this test in order to learn more about the issue, I've realized that during the execution, at this line: 

https://github.com/eclipse/jnosql/blob/5602d4a9911cec5120ccdaa395818ecd587dcd87/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java#L154

The `java.lang.reflect.Parameter.getAnnotation(Class<T> annotationClass)` method is returning `null` in both cases: when is passed `@Id` or `@Column` annotation class. It's happening for all parameters of the `Developer` constructor, but they're annotated or with `@Id` or `@Column`.

### JNoSQL Version

1.0.0

### Steps To Reproduce

Environment:
### Java
```bash
quarkus-jnosql-mongodb/ (added-tests) $ java -version
openjdk version "17.0.6" 2023-01-17
OpenJDK Runtime Environment Temurin-17.0.6+10 (build 17.0.6+10)
OpenJDK 64-Bit Server VM Temurin-17.0.6+10 (build 17.0.6+10, mixed mode, sharing)
```
### Maven
```bash
quarkus-jnosql-mongodb/ (added-tests) $ mvn -version
[Apache Maven 3.8.6 (84538c9988a25aec085021c365c560670ad80f63)
Maven home: /home/maximillianarruda/.sdkman/candidates/maven/current
Java version: 17.0.6, vendor: Eclipse Adoptium, runtime: /home/maximillianarruda/.sdkman/candidates/java/17.0.6-tem
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.15.0-76-generic", arch: "amd64", family: "UNIX"
```


1. get the codes from: https://github.com/dearrudam/jnosql-demos-ee/tree/added-tests;
2. go to the `quarkus-jnosql-mongodb` module;
3. execute the tests with: `mvn test` ;

### Expected Results

The expectation is to be able to execute the tests successfully;

### Code example, screenshot, or link to a repository

_No response_
diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc
index 630e5a4cd..5f7dbf824 100644
--- a/CHANGELOG.adoc
+++ b/CHANGELOG.adoc
@@ -13,6 +13,7 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 - Added no-args constructor into the injectable beans
 - Fixes lazy loading metadata at the EntityMetadata
 - Fixes ParameterMedataData to not thrown NullPointException when it's built with a Parameter without @Column or @Id annotations
+- Fixes Reflections.getConstructor() method logic to detect constructors with parameters annotated with @Id or @Column
 
 == [1.0.0] - 2023-6-22
 
diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java
index ca976ec28..5a6bd5fc3 100644
--- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java
+++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java
@@ -11,6 +11,7 @@
  *   Contributors:
  *
  *   Otavio Santana
+ *   Maximillian Arruda
  */
 package org.eclipse.jnosql.mapping.reflection;
 
@@ -24,11 +25,13 @@ import org.eclipse.jnosql.mapping.Inheritance;
 import org.eclipse.jnosql.mapping.MappedSuperclass;
 import org.eclipse.jnosql.mapping.util.StringUtils;
 
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -47,6 +50,10 @@ public class Reflections {
 
     private static final Logger LOGGER = Logger.getLogger(Reflections.class.getName());
 
+    private static final Predicate<String> IS_ID_ANNOTATION = Id.class.getName()::equals;
+    private static final Predicate<String> IS_COLUMN_ANNOTATION = Column.class.getName()::equals;
+    private static final Predicate<String> IS_NOSQL_ANNOTATION = IS_ID_ANNOTATION.or(IS_COLUMN_ANNOTATION);
+
     /**
      * Return The Object from the Column.
      *
@@ -106,7 +113,7 @@ public class Reflections {
      * Create new instance of this class.
      *
      * @param type the class's type
-     * @param <T>   the instance type
+     * @param <T>  the instance type
      * @return the new instance that class
      */
     public <T> T newInstance(Class<T> type) {
@@ -143,15 +150,16 @@ public class Reflections {
      * conflicts with a JVM SecurityManager (if active).
      *
      * @param type the class constructor acessible
-     * @param <T>   the entity type
+     * @param <T>  the entity type
      * @return the constructor class
      * @throws ConstructorException when the constructor has public and default
      */
     public <T> Constructor<T> getConstructor(Class<T> type) {
+
         final Predicate<Constructor<?>> defaultConstructorPredicate = c -> c.getParameterCount() == 0;
         final Predicate<Constructor<?>> customConstructorPredicate = c -> {
             for (Parameter parameter : c.getParameters()) {
-                if (parameter.getAnnotation(Id.class) != null || parameter.getAnnotation(Column.class) != null) {
+                if (hasNoSQLAnnotation(parameter)) {
                     return true;
                 }
             }
@@ -163,7 +171,6 @@ public class Reflections {
                 .filter(defaultConstructorPredicate.or(customConstructorPredicate))
                 .toList();
 
-
         if (constructors.isEmpty()) {
             throw new ConstructorException(type);
         }
@@ -182,6 +189,21 @@ public class Reflections {
         return (Constructor<T>) constructor;
     }
 
+    /**
+     * Checks if the {@link Parameter} instance is annotated with
+     * Jakarta NoSQL annotations (@{@link Id} or @{@link Column}).
+     *
+     * @param parameter the parameter
+     * @return if the provided {@link Parameter} instance is annotated with
+     * Jakarta NoSQL annotations (@{@link Id} or @{@link Column}).
+     */
+    boolean hasNoSQLAnnotation(Parameter parameter) {
+        return parameter != null && Arrays.stream(parameter.getAnnotations())
+                .map(Annotation::annotationType)
+                .map(Class::getName)
+                .anyMatch(IS_NOSQL_ANNOTATION);
+    }
+
     /**
      * Returns the name of the entity. So it tries to read the {@link Entity} otherwise
      * {@link Class#getSimpleName()}
['jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/reflection/Reflections.java', 'CHANGELOG.adoc']