JxMVC 3.5.1

curl -fsSL https://raw.githubusercontent.com/Andre031222/jxmvc/main/install.sh | sh -s -- new mi-app
cd mi-app && mvn package cargo:run

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/Andre031222/jxmvc/main/install.ps1))) new mi-app
cd mi-app
mvn package cargo:run

git clone https://github.com/Andre031222/jxmvc.git
mvn install -f jxmvc/JxMVC.Core/pom.xml

<dependency>
    <groupId>jakarta.platform</groupId>
    <artifactId>jakarta.jakartaee-api</artifactId>
    <version>10.0.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>jxmvc</groupId>
    <artifactId>jxmvc-core</artifactId>
    <version>3.5.1</version>
</dependency>

jxmvc.controllers.package = com.miapp.controllers
jxmvc.services.package    = com.miapp.services
jxmvc.profiles.active     = dev

@JxControllerMapping("notes")
public class NoteController extends JxController {

    @JxGetMapping("/{id}")
    public ActionResult show() {
        long id = model.pathVarLong("id");
        try (JxDB db = db()) {
            return json(db.queryRow("SELECT * FROM note WHERE id = ?", id));
        }
    }

    @JxPostMapping("/")
    public ActionResult create(@JxValid @JxBody Note note) {
        long id = new NoteRepository().save(note);
        return redirect("/notes/" + id);
    }

    public ActionResult list() {
        int page = model.paramInt("page", 1);
        return text("page " + page);
    }
}

@JxGetMapping("/{id}")
public ActionResult get(@JxPathVar long id, @JxParam("fields") String fields) {
    return json(repo.findById(id));
}

return view("notes/list");
return text("pong");
return json(objeto);
return redirect("/notes");
return view("notes/created").status(201);

view.raw(bytes, "application/pdf", "reporte.pdf");
return null;

String q      = model.param("q");
String raw    = model.paramRaw("q");
int page      = model.paramInt("page", 1);
String id     = model.pathVar("id");
String first  = model.arg(0);
String auth   = model.header("Authorization");
String body   = model.body();

model.setVar("title", "Notas");
sessionSet("user", user);
Object user = sessionGet("user");

@JxControllerMapping("admin")
public class AdminController extends JxController {

    @JxBeforeAction(only = {"create", "update"})
    public void requireAdmin() {
        if (!"ADMIN".equals(sessionGet("role"))) throw JxException.forbidden("Solo administradores");
    }

    @JxModelAttr
    public void common() {
        model.setVar("user", sessionGet("user"));
    }
}

@JxControllerAdvice
public class GlobalAdvice {

    @JxExceptionHandler(JxException.class)
    public ActionResult onError(JxException ex) {
        return ActionResult.json("{\"error\":\"" + ex.getMessage() + "\"}").status(ex.getStatus());
    }
}

try (JxDB db = db()) {
    DBRowSet rows = db.query("SELECT id, title FROM note WHERE owner = ?", owner);
    DBRow one     = db.queryRow("SELECT * FROM note WHERE id = ?", id);
    long newId    = db.insert("note", DBRow.of("title", "Hola"));
    int changed   = db.exec("UPDATE note SET title = ? WHERE id = ?", "Nuevo", id);

    String title = one.GetString("title");
    model.setVar("notes", rows.asList());
}

@JxTable("note")
public class Note {
    @JxId public Long id;
    @JxRequired @JxMaxLength(200) public String title;
}

public class NoteRepository extends JxRepository<Note, Long> {
    public NoteRepository() { super("note", Note.class); }
}

NoteRepository repo = new NoteRepository();
Note n = repo.findById(1L);
List<Note> all = repo.findAll();
long id = repo.save(note);
repo.deleteById(1L);

jxmvc.db.url        = jdbc:postgresql://localhost:5432/mi_db
jxmvc.db.user       = postgres
jxmvc.db.pass       = secret
jxmvc.pool.enabled  = true
jxmvc.pool.size     = 10
jxmvc.pool.timeout  = 5

public class Registro {
    @JxRequired @JxMinLength(3) @JxMaxLength(50) public String nombre;
    @JxRequired @JxEmail public String email;
    @JxPattern("[0-9]{8}") public String dni;
    @JxRange(min = 18, max = 120) public int edad;
    @JxFuture public LocalDate reserva;
}

JxValidation.validate(registro);

List<String> errores = JxValidation.check(registro);
Map<String, String> porCampo = JxValidation.checkMap(registro);

@WebListener
public class AppBootstrap implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        JxSecurity.setProvider((request, roles) -> {
            HttpSession s = request.getSession(false);
            AppUser user = s == null ? null : (AppUser) s.getAttribute("user");
            if (user == null) return false;
            return roles.length == 0 || Arrays.stream(roles).anyMatch(user::hasRole);
        });
    }
}

@JxRequireAuth
@JxGetMapping("perfil")
public ActionResult perfil() { return view("auth/perfil"); }

@JxRequireRole({"ADMIN"})
@JxGetMapping("panel")
public ActionResult panel() { return view("admin/panel"); }

String stored = JxPasswords.hash(password);
boolean ok = JxPasswords.verify(input, stored);
if (ok && JxPasswords.needsRehash(stored)) stored = JxPasswords.hash(input);

JxOAuth.Flow flow = JxOAuth.google().start();
sessionSet("oauth.state", flow.state());
sessionSet("oauth.verifier", flow.codeVerifier());
view.status(302);
view.header("Location", flow.url());
return text("");

if (!model.param("state").equals(sessionGet("oauth.state"))) throw JxException.forbidden("state inválido");
JxOAuth.User u = JxOAuth.google().login(model.param("code"), (String) sessionGet("oauth.verifier"));
sessionSet("user", u);

String out = JxJson.toJson(pedido);
Pedido p   = JxJson.fromJson(body, Pedido.class);

@JxPostMapping("pedidos")
public ActionResult crear(@JxValid @JxBody Pedido pedido) {
    return json(service.guardar(pedido));
}

@JxService
public class Tareas {

    @JxScheduled(cron = "0 3 * * *")
    public void backup() { }

    @JxScheduled(fixedRate = 30_000)
    public void refrescar() { }

    @JxScheduled(fixedDelay = 60_000, initialDelay = 5_000)
    public void purgar() { }
}

JxScheduler.scheduleCron(() -> backup(), "0 2 * * *");
JxScheduler.runOnce(() -> notificar(), 5_000);

@JxAsync
@JxRetry(attempts = 3, backoff = 500)
@JxPostMapping("exportar")
public ActionResult exportar() {
    service.generarYEnviar();
    return null;
}

@JxGetMapping("catalogo")
@JxCacheable(value = "productos", ttl = 300)
public ActionResult catalogo() {
    try (JxDB db = db()) { return json(db.query("SELECT * FROM producto")); }
}

@JxPostMapping("catalogo")
@JxCacheEvict(value = "productos")
public ActionResult guardar() { return ok(); }

String data = JxCache.get("api").computeIfAbsent("clave", 120, () -> consultarApi());

@JxWsEndpoint("/ws/chat/{sala}")
public class ChatEndpoint extends JxWebSocket {

    @Override
    protected void onOpen(Session session, String... vars) {
        String sala = vars.length > 0 ? vars[0] : "general";
        joinRoom(sala, session);
        broadcast(sala, session.getId() + " conectado");
    }

    @Override
    protected void onMessage(Session session, String message) {
        broadcast((String) session.getUserProperties().get("sala"), message);
    }

    @Override
    protected void onClose(Session session) {
        leaveRoom((String) session.getUserProperties().get("sala"), session);
    }
}

JxPdf.Doc doc = JxPdf.read(Path.of("contrato.pdf"));
int pages     = doc.pageCount();
String text   = doc.text();
String first  = doc.page(0);
boolean scan  = doc.isScanned(2);
String author = doc.info().get("Author");

JxPdf.Doc secret = JxPdf.read(bytes, "clave");

byte[] pdf = JxPdf.create("Reporte", "Contenido del reporte");
view.raw(pdf, "application/pdf", "reporte.pdf");
return null;

@JxService
public class EmailService {
    public void enviar(String to, String body) { }
}

@JxControllerMapping("usuarios")
public class UsuarioController extends JxController {

    @JxInject
    private EmailService email;
}

EmailService svc = JxServiceRegistry.get(EmailService.class);

JxFilters.add(new JxFilter() {
    @Override
    public boolean before(JxFilterContext ctx) {
        return !ctx.path().startsWith("/privado") || ctx.request().getSession(false) != null;
    }

    @Override
    public void after(JxFilterContext ctx) {
        ctx.response().header("X-App", "mi-app");
    }
});

JxTest.Response r = JxTest.invoke(NoteController.class)
        .method("GET")
        .pathVar("id", "1")
        .run("show");

if (!r.isOk() || !r.bodyContains("title")) throw new AssertionError(r);

JxTest.mockService(EmailService.class, new FakeEmailService());

jxmvc.controllers.package    = com.miapp.controllers
jxmvc.services.package       = com.miapp.services
jxmvc.profiles.active        = prod
jxmvc.log.level              = INFO

jxmvc.db.url                 = jdbc:postgresql://localhost:5432/mi_db
jxmvc.db.user                = app
jxmvc.db.pass                = secret
jxmvc.pool.enabled           = true
jxmvc.pool.size              = 10

jxmvc.async.threads          = 8
jxmvc.gzip.enabled           = true
jxmvc.body.maxBytes          = 10485760
jxmvc.cache.maxEntries       = 10000

jxmvc.security.frame-options = SAMEORIGIN
jxmvc.security.hsts          = true
jxmvc.security.csp           = default-src 'self'
jxmvc.security.csrf          = false
jxmvc.trustProxy             = false
jxmvc.redirect.external      = false
jxmvc.internal.expose        = false