Um Primeiro Olhar no Eclipse JNoSQL: Oracle NoSQL e Quarkus para Quem Está Começando

# Crie o projeto
quarkus create app com.caverna:heroes-management \
    --extension="quarkus-jnosql-oracle-nosql,quarkus-rest-jackson"

cd heroes-management

# application.properties

# Configuração base
jnosql.oracle.nosql.host=localhost:8080
jnosql.document.database=realm_caverna
jnosql.keyvalue.database=heroes_cache

# Desenvolvimento local
%dev.jnosql.oracle.nosql.host=localhost:8080
%dev.jnosql.document.database=caverna_dev

# Produção (Oracle Cloud)
%prod.jnosql.oracle.nosql.host=${ORACLE_NOSQL_ENDPOINT}
%prod.jnosql.oracle.nosql.region=${OCI_REGION}
%prod.jnosql.oracle.nosql.compartment=${OCI_COMPARTMENT}

# Logging para debug
quarkus.log.category."org.eclipse.jnosql".level=INFO

package com.caverna.model;

import org.eclipse.jnosql.mapping.Column;
import org.eclipse.jnosql.mapping.Entity;
import org.eclipse.jnosql.mapping.Id;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

@Entity("herois")  // Nome customizado da collection
public class Heroi {

    @Id
    private String id;

    @Column
    private String nome;

    @Column
    private ClasseHeroi classe;

    @Column
    private Integer experiencia;

    @Column
    private List<String> habilidadesEspeciais;

    @Column
    private ArmaLendaria armaLendaria;

    // Aqui está o legal: dados flexíveis!
    @Column
    private Map<String, Object> atributosPersonalizados;

    @Column
    private LocalDateTime ultimaAventura;

    @Column
    private Boolean ativo = true;

    // Construtor padrão obrigatório
    public Heroi() {}

    // Construtor útil
    public Heroi(String nome, ClasseHeroi classe, List<String> habilidades) {
        this.nome = nome;
        this.classe = classe;
        this.habilidadesEspeciais = habilidades;
        this.experiencia = 0;
        this.ultimaAventura = LocalDateTime.now();
    }

    // Getters e setters...
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getNome() { return nome; }
    public void setNome(String nome) { this.nome = nome; }

    public ClasseHeroi getClasse() { return classe; }
    public void setClasse(ClasseHeroi classe) { this.classe = classe; }

    // ... outros getters/setters
}

// Enums para type safety
enum ClasseHeroi {
    CAVALEIRO, RANGER, MAGO, LADINA, ACROBATA, BARBARO
}

// Classe aninhada para demonstrar objetos complexos
class ArmaLendaria {
    private String nome;
    private Integer poder;
    private List<String> encantamentos;

    // Construtores, getters e setters...
}

package com.caverna.repository;

import com.caverna.model.Heroi;
import com.caverna.model.ClasseHeroi;
import jakarta.data.repository.Repository;
import jakarta.data.repository.Query;
import jakarta.data.repository.OrderBy;
import jakarta.enterprise.context.ApplicationScoped;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Repository
@ApplicationScoped
public interface HeroiRepository extends NoSQLRepository<Heroi, String> {

    // Queries derivadas - o JNoSQL gera automaticamente!
    List<Heroi> findByClasse(ClasseHeroi classe);

    List<Heroi> findByAtivoTrue();

    @OrderBy("experiencia DESC")
    List<Heroi> findByExperienciaGreaterThan(Integer minExperiencia);

    // Query customizada - aqui usamos a linguagem própria do JNoSQL
    @Query("SELECT * FROM herois WHERE habilidadesEspeciais CONTAINS ?1 AND ativo = true")
    List<Heroi> buscarPorHabilidade(String habilidade);

    // Query mais complexa
    @Query("SELECT * FROM herois WHERE ultimaAventura >= ?1 ORDER BY experiencia DESC LIMIT 5")
    List<Heroi> heroisMaisAtivos(LocalDateTime dataLimite);

    // Contadores
    long countByClasse(ClasseHeroi classe);

    // Operações em lote
    @Query("SELECT * FROM herois WHERE classe IN (?1) AND experiencia >= ?2")
    List<Heroi> buscarEliteDeClasses(List<ClasseHeroi> classes, Integer minExperiencia);
}

package com.caverna.service;

import com.caverna.model.Heroi;
import com.caverna.model.ClasseHeroi;
import com.caverna.repository.HeroiRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@ApplicationScoped
public class GrupoAventureirosService {

    @Inject
    HeroiRepository repository;

    public Heroi recrutar(Heroi novoHeroi) {
        // Regra de negócio: novos heróis começam com experiência 0
        novoHeroi.setExperiencia(0);
        novoHeroi.setUltimaAventura(LocalDateTime.now());
        return repository.save(novoHeroi);
    }

    public List<Heroi> montarGrupoBalanceado() {
        // Lógica para montar um grupo equilibrado
        List<Heroi> tanques = repository.findByClasse(ClasseHeroi.CAVALEIRO);
        List<Heroi> dps = repository.findByClasse(ClasseHeroi.RANGER);
        List<Heroi> suporte = repository.findByClasse(ClasseHeroi.MAGO);

        // Aqui você implementaria a lógica de balanceamento...
        return repository.findByAtivoTrue();
    }

    public void promoverHeroi(String heroiId, Integer bonusExperiencia) {
        Optional<Heroi> heroi = repository.findById(heroiId);
        if (heroi.isPresent()) {
            Heroi h = heroi.get();
            h.setExperiencia(h.getExperiencia() + bonusExperiencia);
            h.setUltimaAventura(LocalDateTime.now());
            repository.save(h);
        }
    }

    public List<Heroi> buscarEspecialistas(String habilidade) {
        return repository.buscarPorHabilidade(habilidade);
    }
}

package com.caverna.resource;

import com.caverna.model.Heroi;
import com.caverna.model.ClasseHeroi;
import com.caverna.service.GrupoAventureirosService;
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.util.List;

@Path("/herois")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class HeroiResource {

    @Inject
    GrupoAventureirosService service;

    @POST
    @Path("/recrutar")
    public Response recrutar(Heroi heroi) {
        Heroi recrutado = service.recrutar(heroi);
        return Response.status(201).entity(recrutado).build();
    }

    @GET
    @Path("/grupo-balanceado")
    public List<Heroi> montarGrupo() {
        return service.montarGrupoBalanceado();
    }

    @PUT
    @Path("/{id}/promover/{bonus}")
    public Response promover(@PathParam("id") String id, @PathParam("bonus") Integer bonus) {
        service.promoverHeroi(id, bonus);
        return Response.ok().build();
    }

    @GET
    @Path("/especialistas/{habilidade}")
    public List<Heroi> buscarEspecialistas(@PathParam("habilidade") String habilidade) {
        return service.buscarEspecialistas(habilidade);
    }
}

# Inicie o Quarkus
./mvnw quarkus:dev

# Recrute o Hank
curl -X POST localhost:8080/herois/recrutar \
  -H "Content-Type: application/json" \
  -d '{
    "nome": "Hank",
    "classe": "CAVALEIRO",
    "habilidadesEspeciais": ["Escudo Mágico", "Liderança"],
    "armaLendaria": {
      "nome": "Escudo do Valor",
      "poder": 95,
      "encantamentos": ["Proteção", "Reflexão"]
    }
  }'

# Recrute a Diana
curl -X POST localhost:8080/herois/recrutar \
  -H "Content-Type: application/json" \
  -d '{
    "nome": "Diana",
    "classe": "ACROBATA", 
    "habilidadesEspeciais": ["Bastão Mágico", "Acrobacia Extrema"]
  }'

// Adicione isso como configuração
@Query("CREATE INDEX idx_classe_experiencia ON herois (classe, experiencia)")

@Inject
@ConfigProperty(name = "jnosql.keyvalue.database")
KeyValueTemplate keyValueTemplate;

// Cache rápido
keyValueTemplate.put("ultimo_grupo", grupoAtual);

@Readiness
public class OracleNoSQLHealthCheck implements HealthCheck {
    @Override
    public HealthCheckResponse call() {
        // Teste sua conexão Oracle NoSQL aqui
    }
}