What’s new with Jakarta NoSQL? (Part II)

import jakarta.nosql.mapping.Column;
import jakarta.nosql.mapping.Entity;
import jakarta.nosql.mapping.Id;

import javax.json.bind.annotation.JsonbVisibility;
import java.io.Serializable;
import java.util.Objects;
import java.util.Set;

@Entity
@JsonbVisibility(FieldPropertyVisibilityStrategy.class)
public class Hero implements Serializable {

 @Id
 private String name;

 @Column
 private Integer age;

 @Column
 private Set<String> powers;

}

import jakarta.nosql.mapping.Page;
import jakarta.nosql.mapping.Pagination;
import jakarta.nosql.mapping.Repository;

import java.util.stream.Stream;

public interface HeroRepository extends Repository<Hero, String> {

 Stream<Hero> findAll();

 Page<Hero> findAll(Pagination pagination);

 Stream<Hero> findByPowersIn(String powers);

 Stream<Hero> findByAgeGreaterThan(Integer age);

 Stream<Hero> findByAgeLessThan(Integer age);
}

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
import java.util.function.Supplier;

import static java.util.stream.Collectors.toList;

@ApplicationScoped
@Path("heroes")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class HeroResource {

 private static final Supplier<WebApplicationException> NOT_FOUND =
         () -> new WebApplicationException(Response.Status.NOT_FOUND);

 @Inject
 private HeroRepository repository;

 @GET
 public List<Hero> findAll() {
     return repository.findAll()
             .collect(toList());
 }

 @GET
 @Path("/{id}")
 public Hero findById(@PathParam("id") String id) {
     return repository.findById(id).orElseThrow(NOT_FOUND);
 }

 @GET
 @Path("seniors/{age}")
 public List<Hero> findByOlder(@PathParam("age") Integer age) {
     return repository.findByAgeGreaterThan(age)
             .collect(toList());
 }

 @GET
 @Path("youngs/{age}")
 public List<Hero> findByYounger(@PathParam("age") Integer age) {
     return repository.findByAgeLessThan(age)
             .collect(toList());
 }

 @POST
 public void save(Hero hero) {
     repository.save(hero);
 }

 @PUT
 @Path("/{id}")
 public void update(@PathParam("id") String id, Hero hero) {
     repository.save(hero);
 }

 @Path("/{id}")
 @DELETE
 public void delete(@PathParam("id") String name) {
     repository.deleteById(name);
 }
}

import jakarta.nosql.document.DocumentCollectionManager;
import org.eclipse.microprofile.config.inject.ConfigProperty;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.inject.Inject;

@ApplicationScoped
class DocumentManagerProducer {

 @Inject
 @ConfigProperty(name = "document")
 private DocumentCollectionManager manager;

 @Produces
 public DocumentCollectionManager getManager() {
     return manager;
 }

 public void destroy(@Disposes DocumentCollectionManager manager) {
     manager.close();
 }
}

document=document
document.database=conferences
document.settings.jakarta.nosql.host=localhost:27017
document.provider=org.eclipse.jnosql.diana.mongodb.document.MongoDBDocumentConfiguration

mongodb:
  type: mongodb:3.6
  disk: 1024

# This file describes an application. You can have multiple applications
# in the same project.
#
# See https://docs.platform.sh/user_guide/reference/platform-app-yaml.html

# The name of this app. Must be unique within a project.
name: app

# The runtime the application uses.
type: "java:8"

disk: 800

# The hooks executed at various points in the lifecycle of the application.
hooks:
  build: |
  wget https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64
  mv jq-linux64 jq
  chmod +x jq
  mvn -U -DskipTests clean package payara-micro:bundle

# The relationships of the application with services or other applications.
#
# The left-hand side is the name of the relationship as it will be exposed
# to the application in the PLATFORM_RELATIONSHIPS variable. The right-hand
# side is in the form `<service name>:<endpoint name>`.
relationships:
  mongodb: 'mongodb:mongodb'

# The configuration of app when it is exposed to the web.
web:
  commands:
    start: |
      export MONGO_PORT=`echo $PLATFORM_RELATIONSHIPS|base64 -d|json_pp|./jq -r ".mongodb[0].port"`
      export MONGO_HOST=`echo $PLATFORM_RELATIONSHIPS|base64 -d|json_pp|./jq -r ".mongodb[0].host"`
      export MONGO_ADDRESS="${MONGO_HOST}:${MONGO_PORT}"
      export MONGO_PASSWORD=`echo $PLATFORM_RELATIONSHIPS|base64 -d|json_pp|./jq -r ".mongodb[0].password"`
      export MONGO_USER=`echo $PLATFORM_RELATIONSHIPS|base64 -d|json_pp|./jq -r ".mongodb[0].username"`
      export MONGO_DATABASE=`echo $PLATFORM_RELATIONSHIPS|base64 -d|json_pp|./jq -r ".mongodb[0].path"`
      java -jar -Xmx1024m -Ddocument.settings.jakarta.nosql.host=$MONGO_ADDRESS \
      -Ddocument.database=$MONGO_DATABASE -Ddocument.settings.jakarta.nosql.user=$MONGO_USER \
      -Ddocument.settings.jakarta.nosql.password=$MONGO_PASSWORD \
      -Ddocument.settings.mongodb.authentication.source=$MONGO_DATABASE \
      target/heroes-microbundle.jar --port $PORT

git remote add platform <platform.sh@gitrepository>
git commit -m "Initial project"
git push -u platform master