funifier-mcp 0.2.26 → 0.2.27

package/datasource-funifier-docs/knowledge/guides/java-libraries.md

@@ -1,330 +1,306 @@
 # Java Libraries — Referência
 
-Bibliotecas e utilitários disponíveis para uso em **triggers**, **schedulers** e **public endpoints**.
+## 1. Visão Geral
 
----
+### 1.1 O que é este documento
 
-## JsonUtil
+Este documento descreve as bibliotecas e utilitários disponíveis no runtime Java/Groovy da Funifier (triggers, schedulers e public endpoints) — assinatura, uso e em quais runtimes cada um funciona.
 
-**Classe:** `com.funifier.engine.util.JsonUtil`
+### 1.2 Quando consultar
 
-Utilitário estático para serialização/deserialização JSON (baseado em Jackson).
+- Consulte ao precisar **serializar/desserializar JSON** (`JsonUtil`).
+- Consulte ao precisar **gerar IDs ou códigos** (`Guid`).
+- Consulte ao precisar **calcular datas em código** (`DateUtil`).
+- Consulte ao precisar fazer **requisição HTTP** a partir de código server-side (`Unirest`).
+- Consulte ao precisar **enviar email** via SMTP (`EmailBuilder`).
+- Consulte ao decidir **se uma classe funciona no Public Endpoint** (sandbox).
 
-| Método | Retorno | Descrição |
-|--------|---------|-----------|
-| `toJson(Object obj)` | String | Converte objeto para JSON string |
-| `toJsonRemoveNullFields(Object obj)` | String | Converte para JSON excluindo campos null |
-| `fromJson(String json, Class<T> valueType)` | T | Converte JSON string para objeto tipado |
-| `fromJsonToMap(String json)` | Map\<String, Object\> | Converte JSON string para Map |
-| `toBsonStrictMode(Object obj)` | String | Converte para BSON strict mode (MongoDB) |
+### 1.3 Quando NÃO consultar
 
-**Exemplos:**
+- **NÃO** consulte para **acesso ao banco** (Jongo, find/save/aggregate) — use `datasource-funifier-docs/knowledge/guides/database-access.md`. Este documento só aponta para lá.
+- **NÃO** consulte para a **semântica das expressões de data** (`-0M-`, `-1d+`) — use `datasource-funifier-docs/knowledge/guides/aggregates.md`. Aqui ficam apenas os métodos Java de `DateUtil`.
+- **NÃO** consulte para **managers/entidades** — use `java-managers.md` e `java-entities.md`.
 
-```java
-// Objeto para JSON
-HashMap data = new HashMap();
-data.put("name", "John");
-data.put("score", 100);
-String json = JsonUtil.toJson(data);
-// {"name":"John","score":100}
+### 1.4 Índice de decisão
 
-// JSON para Map
-Map<String, Object> map = JsonUtil.fromJsonToMap("{\"name\":\"John\",\"score\":100}");
-String name = (String) map.get("name");
+| Problema / Situação | O que usar | Seção |
+|---|---|---|
+| Converter objeto ↔ JSON | `JsonUtil` | §2 |
+| Gerar ID único ou código curto | `Guid` | §3 |
+| Calcular/parsear/formatar data em código | `DateUtil` | §4 |
+| Fazer requisição HTTP externa | `Unirest` (ou `java.net.URL` no Public Endpoint) | §5 |
+| Enviar email SMTP | `EmailBuilder` / `MailerBuilder` | §6 |
+| Hashear senha de jogador | `BCrypt` | §7 |
+| Acessar MongoDB | (ver `database-access.md`) | §8 |
 
-// JSON para objeto tipado
-Player player = JsonUtil.fromJson(jsonString, Player.class);
+### 1.5 Restrições globais críticas
 
-// Ignorar campos null
-String cleanJson = JsonUtil.toJsonRemoveNullFields(obj);
-```
+> ⚠️ **O sandbox do Public Endpoint bloqueia bibliotecas que funcionam em Trigger/Scheduler.** Consequência: código portado de uma trigger lança `MissingPropertyException`/`ClassCastException` no Public Endpoint. → Antes de usar uma biblioteca num Public Endpoint, confira a coluna **Disponível em** de cada seção e a tabela completa do sandbox em `patterns.md` §1.5. Resumo: `Unirest` (`com.mashape.*`), `EmailBuilder` (`org.simplejavamail`), `BCrypt` e qualquer nome `com.*`/`org.*` totalmente qualificado são **bloqueados** no Public Endpoint; `JsonUtil`/`DateUtil` (nome curto) funcionam.
+
+### 1.6 Documentos relacionados
+
+> 📄 `datasource-funifier-docs/knowledge/guides/database-access.md` — Jongo e operações de banco
+> 📄 `datasource-funifier-docs/knowledge/guides/aggregates.md` — semântica das expressões de data Funifier
+> 📄 `datasource-funifier-docs/knowledge/modules/public.md` — runtime e sandbox de Public Endpoints
 
 ---
 
-## Guid
+## 2. JsonUtil
+
+Quando usar: serializar objetos para JSON ou parsear JSON em código.
+Não usar quando: precisar de `JsonSlurper`/`JsonOutput` no Public Endpoint — são bloqueados (`patterns.md` §1.5); use `JsonUtil`.
+Depende de: —
+Disponível em: Todos (uso em Public Endpoint confirmado em `patterns.md` §6).
+
+### Descrição
 
-**Classe:** `com.funifier.engine.guid.Guid`
+Utilitário estático para serialização/desserialização JSON (baseado em Jackson). Classe `com.funifier.engine.util.JsonUtil`. Por ser pré-importado com nome curto, funciona no sandbox do Public Endpoint (ao contrário de `groovy.json.*`).
 
-Geração de identificadores únicos.
+### Uso
 
 | Método | Retorno | Descrição |
 |--------|---------|-----------|
-| `newShortGuid()` | String | Gera ID único (MongoDB ObjectId, 24 chars) |
-| `shortTimeMillis()` | String | Gera código baseado no timestamp (base62, ~7 chars) |
-
-**Exemplos:**
+| `toJson(Object obj)` | String | Objeto → JSON |
+| `toJsonRemoveNullFields(Object obj)` | String | Objeto → JSON sem campos null |
+| `fromJson(String json, Class<T> valueType)` | T | JSON → objeto tipado |
+| `fromJsonToMap(String json)` | Map\<String, Object\> | JSON → Map |
+| `toBsonStrictMode(Object obj)` | String | Objeto → BSON strict mode (MongoDB) |
 
 ```java
-// Gerar ID para novo objeto
-String id = Guid.newShortGuid();
-// Ex: "64a5d92f1b2c3d4e5f6a7b8c"
+HashMap data = new HashMap();
+data.put("name", "John");
+String json = JsonUtil.toJson(data);                 // {"name":"John"}
 
-// Gerar código curto baseado no tempo (útil para códigos de convite)
-String code = Guid.shortTimeMillis();
-// Ex: "y6z3D6H"
+Map<String, Object> map = JsonUtil.fromJsonToMap(json);
+Player player = JsonUtil.fromJson(jsonString, Player.class);
 ```
 
-**Quando usar cada um:**
-- `newShortGuid()` — Para IDs de objetos (achievements, action logs, etc.)
-- `shortTimeMillis()` — Para códigos legíveis (convites, vouchers, etc.)
+```groovy
+// No Public Endpoint: parsear o payload SEM JsonSlurper (ver patterns.md §1.5)
+def body = JsonUtil.fromJsonToMap(JsonUtil.toJson(payload))
+```
 
----
+### Armadilhas conhecidas
 
-## DateUtil
+- **`JsonSlurper`/`JsonOutput` no Public Endpoint** → `ClassCastException: [B incompatible with [C`. Causa: bloqueio do sandbox. Correção: `JsonUtil.fromJsonToMap()` (`patterns.md` §6).
 
-**Classe:** `com.funifier.engine.util.DateUtil`
+---
 
-Utilitário para cálculos e parsing de datas, incluindo as **expressões de data Funifier**.
+## 3. Guid
 
-### Expressões de Data (Funifier Syntax)
+Quando usar: gerar IDs de objetos novos ou códigos curtos legíveis.
+Não usar quando: o objeto já tem `_id` definido pela API (ex: documento vindo de `findOne`).
+Depende de: —
+Disponível em: Trigger / Scheduler (uso em Public Endpoint não verificado nas fontes).
 
-Formato: `[sinal][quantidade][unidade][ajuste]`
+### Descrição
 
-**Unidades:** `y`=ano, `M`=mês, `w`=semana, `d`=dia, `h`=hora, `m`=minuto, `s`=segundo
+Geração de identificadores únicos. Classe `com.funifier.engine.guid.Guid`.
 
-**Ajuste:** `-` = início da unidade (floor), `+` = fim da unidade (ceil), sem ajuste = exato
+### Uso
 
-| Expressão | Significado |
-|-----------|------------|
-| `-0d` | Agora |
-| `-0d-` | Início do dia atual (00:00:00) |
-| `-0d+` | Fim do dia atual (23:59:59) |
-| `-1d` | Exatamente 1 dia atrás |
-| `-1d-` | Início do dia anterior |
-| `-1d+` | Fim do dia anterior |
-| `+1d` | Exatamente 1 dia no futuro |
-| `+1d-` | Início do dia seguinte |
-| `-0w-` | Início da semana atual |
-| `-0w+` | Fim da semana atual |
-| `-0M-` | Primeiro dia do mês (00:00:00) |
-| `-0M+` | Último dia do mês (23:59:59) |
-| `-1M-` | Primeiro dia do mês anterior |
-| `-0y-` | 1 de janeiro do ano atual |
-| `-0y+` | 31 de dezembro do ano atual |
+| Método | Retorno | Quando usar |
+|--------|---------|-------------|
+| `newShortGuid()` | String | IDs de objetos (achievements, action logs) — MongoDB ObjectId, 24 chars |
+| `shortTimeMillis()` | String | Códigos legíveis (convites, vouchers) — base62, ~7 chars |
 
-**Encadeamento com `|`:**
-```
--1d+|GMT+3            → fim do dia anterior no fuso GMT+3
--0d-|+5h|+30m|GMT-3   → início do dia + 5h30m no fuso GMT-3
+```java
+String id = Guid.newShortGuid();      // "64a5d92f1b2c3d4e5f6a7b8c"
+String code = Guid.shortTimeMillis(); // "y6z3D6H"
 ```
 
-### Métodos
+### Armadilhas conhecidas
+
+- **Atribuir o ID gerado a `entity._id` em Groovy** → não persiste. Use `entity.id` (`java-entities.md` §1.5).
+
+---
+
+## 4. DateUtil
+
+Quando usar: calcular, parsear ou formatar datas em código Java/Groovy.
+Não usar quando: precisar das expressões de data dentro de **queries/aggregates** (`{"$date": "-0M-"}`) — a semântica completa está em `aggregates.md`.
+Depende de: expressões de data Funifier (definidas em `aggregates.md`).
+Disponível em: Todos (uso em Public Endpoint confirmado em `patterns.md` §6 — `DateUtil.fromKeyword("+7d")`).
+
+### Descrição
+
+Utilitário para cálculo, parsing e formatação de datas, incluindo a conversão das **expressões de data Funifier** em `Date`. Classe `com.funifier.engine.util.DateUtil`.
+
+> A tabela de expressões (`-0d`, `-0M-`, `-1d+`, encadeamento com `|GMT±N`) é mantida em `datasource-funifier-docs/knowledge/guides/aggregates.md` (dono único). Aqui ficam apenas os **métodos Java**.
+
+### Uso
 
 | Método | Retorno | Descrição |
 |--------|---------|-----------|
-| `fromKeyword(String keyword)` | Date | Converte expressão Funifier em Date |
-| `fromKeyword(String keyword, Date reference)` | Date | Converte com data de referência |
-| `fromKeyword(String keyword, Date reference, String timezone)` | Date | Converte com referência e timezone |
-| `fromKeywordPeriodExpression(String period)` | Date[] | Converte período (ex: "-0M-;-0M+") em [inicio, fim] |
+| `fromKeyword(String keyword)` | Date | Expressão Funifier → Date |
+| `fromKeyword(String keyword, Date reference)` | Date | Com data de referência |
+| `fromKeyword(String keyword, Date reference, String timezone)` | Date | Com referência e timezone |
+| `fromKeywordPeriodExpression(String period)` | Date[] | Período `"-0M-;-0M+"` → `[início, fim]` |
 | `parse(Object date)` | Date | Parse genérico (Date, Long, String, expressão) |
-| `parse(String date, String pattern)` | Date | Parse com padrão SimpleDateFormat |
-| `format(Date date, String pattern)` | String | Formata data com padrão SimpleDateFormat |
-| `between(Date ref, int scale, int amount)` | Date[] | Intervalo [inicio, fim] da unidade |
-| `add(Date ref, int scale, int amount)` | Date | Adiciona unidades à data |
-| `reset(Date date, int scale)` | Date | Trunca data para o início da unidade |
+| `parse(String date, String pattern)` | Date | Parse com `SimpleDateFormat` |
+| `format(Date date, String pattern)` | String | Formata com `SimpleDateFormat` |
+| `between(Date ref, int scale, int amount)` | Date[] | Intervalo `[início, fim]` da unidade |
+| `add(Date ref, int scale, int amount)` | Date | Adiciona unidades |
+| `reset(Date date, int scale)` | Date | Trunca para o início da unidade |
 
-**Escalas (TimeScale):**
-```java
-TimeScale.MILLISECOND = 0;
-TimeScale.SECOND = 1;
-TimeScale.MINUTE = 2;
-TimeScale.HOUR = 3;
-TimeScale.DAY = 4;
-TimeScale.WEEK = 5;
-TimeScale.MONTH = 6;
-TimeScale.YEAR = 7;
-```
-
-**Exemplos:**
+**Escalas (`TimeScale`):** `MILLISECOND=0`, `SECOND=1`, `MINUTE=2`, `HOUR=3`, `DAY=4`, `WEEK=5`, `MONTH=6`, `YEAR=7`.
 
 ```java
-// Usar expressões Funifier
 Date inicioMes = DateUtil.fromKeyword("-0M-");
-Date fimMes = DateUtil.fromKeyword("-0M+");
-Date ontem = DateUtil.fromKeyword("-1d");
-
-// Período completo
 Date[] periodo = DateUtil.fromKeywordPeriodExpression("-0M-;-0M+");
-Date inicio = periodo[0];
-Date fim = periodo[1];
-
-// Parse genérico
-Date d1 = DateUtil.parse("2023-07-05T20:57:33.303Z");
-Date d2 = DateUtil.parse("-1d");
-
-// Formatar data
-String formatted = DateUtil.format(new Date(), "dd/MM/yyyy HH:mm:ss");
-
-// Adicionar tempo
 Date amanha = DateUtil.add(new Date(), TimeScale.DAY, 1);
-Date mesPassado = DateUtil.add(new Date(), TimeScale.MONTH, -1);
+String fmt = DateUtil.format(new Date(), "dd/MM/yyyy HH:mm:ss");
 ```
 
-> **Referência completa de expressões de data em consultas:** consulte `guides/aggregates.md`.
+### Armadilhas conhecidas
+
+- **Usar `System.currentTimeMillis()` no Public Endpoint** → bloqueado. Correção: `new Date().getTime()` (`patterns.md` §1.5).
 
 ---
 
-## Unirest
+## 5. Unirest
+
+Quando usar: requisição HTTP a API externa a partir de **trigger ou scheduler**.
+Não usar quando: estiver num **Public Endpoint** — `com.mashape.*` é `com.*` → bloqueado; use `java.net.URL`/`openConnection()`.
+Depende de: `JsonUtil` (para body JSON).
+Disponível em: **Trigger / Scheduler** (bloqueado em Public Endpoint — `patterns.md` §1.5).
 
-**Biblioteca:** `com.mashape.unirest`
+### Descrição
 
-Cliente HTTP para fazer requisições a APIs externas.
+Cliente HTTP. Biblioteca `com.mashape.unirest`.
 
-**Exemplos:**
+### Uso
 
 ```java
 // GET
-HttpResponse<String> response = Unirest.get("https://api.example.com/data")
+HttpResponse<String> res = Unirest.get("https://api.example.com/data")
     .header("Authorization", "Bearer token123")
     .asString();
-String body = response.getBody();
-int status = response.getStatus();
+String body = res.getBody();
+int status = res.getStatus();
 
 // POST com JSON
-HashMap payload = new HashMap();
-payload.put("name", "John");
-payload.put("email", "john@email.com");
-
-HttpResponse<String> response = Unirest.post("https://api.example.com/users")
+HttpResponse<String> res = Unirest.post("https://api.example.com/users")
     .header("Content-Type", "application/json")
     .body(JsonUtil.toJson(payload))
     .asString();
 
-// POST form
-HttpResponse<String> response = Unirest.post("https://api.example.com/form")
-    .field("username", "john")
-    .field("password", "secret")
-    .asString();
+// POST form / PUT / DELETE
+Unirest.post(url).field("username", "john").field("password", "secret").asString();
+Unirest.put(url).header("Content-Type", "application/json").body(JsonUtil.toJson(payload)).asString();
+Unirest.delete(url).asString();
+```
 
-// PUT
-HttpResponse<String> response = Unirest.put("https://api.example.com/users/1")
-    .header("Content-Type", "application/json")
-    .body(JsonUtil.toJson(payload))
-    .asString();
+### Armadilhas conhecidas
 
-// DELETE
-HttpResponse<String> response = Unirest.delete("https://api.example.com/users/1")
-    .asString();
-```
+- **Unirest no Public Endpoint** → `MissingPropertyException` (é `com.*`). Correção: `java.net.URL`/`openConnection()` (`patterns.md` §6).
+- **HTTP lento estourando o timeout** → Public Endpoint tem default 10s, Trigger 5s (`patterns.md` §1.5). Correção: chamadas rápidas ou aumentar `timeout` via API.
 
 ---
 
-## EmailBuilder (SimpleJavaMail)
+## 6. EmailBuilder (SimpleJavaMail)
+
+Quando usar: enviar email via SMTP a partir de **trigger ou scheduler**.
+Não usar quando: estiver num Public Endpoint (`org.simplejavamail` é `org.*` → bloqueado); ou quando uma notificação in-app basta → `modules/notification.md`.
+Depende de: servidor SMTP configurado na gamificação.
+Disponível em: **Trigger / Scheduler** (bloqueado em Public Endpoint — `patterns.md` §3).
 
-**Biblioteca:** `org.simplejavamail`
+### Descrição
 
-Envio de emails via SMTP.
+Construção e envio de emails. Biblioteca `org.simplejavamail`.
 
-**Exemplos:**
+### Uso
 
 ```java
-// Enviar email simples
-Email email = EmailBuilder
-    .startingBlank()
+Email email = EmailBuilder.startingBlank()
     .from("Company", "noreply@company.com")
     .to("John", "john@email.com")
     .withSubject("Welcome!")
-    .withPlainText("Welcome to our platform!")
+    .withHTMLText("<h1>Hello</h1>")   // ou .withPlainText("...")
     .buildEmail();
 
 MailerBuilder.withSMTPServer("smtp.host.com", 587, "login", "password")
     .buildMailer()
     .sendMail(email);
+```
 
-// Email com HTML
-Email email = EmailBuilder
-    .startingBlank()
-    .from("Company", "noreply@company.com")
-    .to("John", "john@email.com")
-    .withSubject("Report")
-    .withHTMLText("<h1>Hello</h1><p>Your monthly report is ready.</p>")
-    .buildEmail();
+Para o padrão completo (template editável + SMTP da gamificação via `MailContext`), ver `patterns.md` §3.
 
-MailerBuilder.withSMTPServer("smtp.host.com", 587, "login", "password")
-    .buildMailer()
-    .sendMail(email);
+### Armadilhas conhecidas
+
+- **Enviar email de um Public Endpoint** → bloqueado (`patterns.md` §3). Correção: envie de trigger/scheduler.
+
+---
+
+## 7. BCrypt
+
+Quando usar: hashear senha de jogador server-side antes de `PlayerManager.insert`.
+Não usar quando: estiver num Public Endpoint — `BCrypt` é indisponível no sandbox; delegue ao trigger `before_update` (`patterns.md` §4).
+Depende de: —
+Disponível em: **Trigger / Scheduler** (indisponível em Public Endpoint — `patterns.md` §1.5).
+
+### Descrição
+
+Hash de senha. Classe `com.funifier.engine.util.BCrypt`. Necessário porque `POST/PUT /v3/player` grava `password` **sem hash** (`java-entities.md` §1.5; `patterns.md` §2).
+
+### Uso
+
+```groovy
+p.password = com.funifier.engine.util.BCrypt.hashpw(
+    entity.password, com.funifier.engine.util.BCrypt.gensalt());
 ```
 
+### Armadilhas conhecidas
+
+- **Tentar `BCrypt` no Public Endpoint** → indisponível. Correção: hashear via trigger `signup__c`/`change_password__c` (`patterns.md` §2, §11).
+
 ---
 
-## Jongo (Acesso ao MongoDB)
+## 8. Jongo (Acesso ao MongoDB)
+
+Quando usar: ler/escrever coleções diretamente em código.
+Não usar quando: existir um manager para a operação → `java-managers.md`.
+Depende de: `database` (param do trigger) ou `manager.getJongoConnection()`.
+Disponível em: Todos (via `manager.getJongoConnection()`; uso em Public Endpoint confirmado em `patterns.md` §6).
 
-**Biblioteca:** `org.jongo`
+### Descrição
 
-Acesso direto ao MongoDB através do objeto `database` (em triggers) ou `manager.getJongoConnection()`.
+Acesso direto ao MongoDB. Biblioteca `org.jongo`.
 
-### Operações
+> Operações completas (find, save, remove, count, aggregate, placeholders `#`) são documentadas em **`datasource-funifier-docs/knowledge/guides/database-access.md`** (dono único). Resumo abaixo apenas para orientar.
+
+### Uso
 
 ```java
-// Obter coleção
-org.jongo.MongoCollection collection = database.getCollection("nome_colecao");
-
-// --- INSERT / UPDATE ---
-// Save (insere ou atualiza se _id existir)
-database.getCollection("email__c").save(hashMap);
-
-// --- FIND ---
-// Buscar um documento
-Object result = database.getCollection("player")
-    .findOne("{_id: 'john'}").as(Object.class);
-
-// Buscar com parâmetro (#)
-Object result = database.getCollection("product__c")
-    .findOne("{_id: #}", productId).as(Object.class);
-
-// Buscar vários
-Iterable<Object> results = database.getCollection("action_log")
-    .find("{userId: #}", "john").as(Object.class);
-
-// Buscar com projeção
-Object result = database.getCollection("player")
-    .findOne("{_id: #}", id)
-    .projection("{name: 1, email: 1}")
-    .as(Object.class);
-
-// --- DELETE ---
-database.getCollection("car__c").remove("{_id: 'car001'}");
-
-// --- COUNT ---
-long total = database.getCollection("action_log")
-    .count("{userId: #}", "john");
-
-// --- AGGREGATE ---
-Iterable<Object> result = database.getCollection("achievement")
-    .aggregate("{$match: {type: 0, item: 'xp'}}")
-    .and("{$group: {_id: '$player', total: {$sum: '$total'}}}")
-    .and("{$sort: {total: -1}}")
-    .and("{$limit: 10}")
-    .as(Object.class);
+// Em trigger: usar o param `database`. Em scheduler/endpoint: manager.getJongoConnection()
+database.getCollection("player").findOne("{_id: #}", id).as(Map.class);
+manager.getJongoConnection().getCollection("email__c").save(payload);
 ```
 
-### Parâmetros com `#`
+### Armadilhas conhecidas
 
-O Jongo usa `#` como placeholder para parâmetros seguros (evita injection):
+- **Concatenar valores na query string** → injeção. Use o placeholder `#` (`database-access.md`).
 
-```java
-// Um parâmetro
-database.getCollection("player").findOne("{_id: #}", playerId).as(Object.class);
+---
 
-// Múltiplos parâmetros
-database.getCollection("action_log")
-    .find("{userId: #, actionId: #}", "john", "sell")
-    .as(Object.class);
-```
+## 9. Utilitários referenciados sem documentação completa
 
-> **Referência completa:** consulte `guides/database-access.md` e `guides/aggregates.md`.
+> ⚠️ Documentação pendente: as classes abaixo são usadas em `patterns.md` mas não têm referência de API nas fontes atuais. Documentadas aqui apenas como ponteiros — **não inferir assinaturas**.
+>
+> - `com.funifier.engine.util.MustacheUtils.parse(template, valuesMap)` — substituição de variáveis Mustache (`patterns.md` §3).
+> - `com.funifier.engine.mail.MailContext` — config SMTP da gamificação: `hostName`, `smtpPort`, `authUser`, `authPassword` (`patterns.md` §3).
+> - `com.funifier.controller.Configuration.getCurrentConfiguration().getMailContext()` — obtém o `MailContext` atual (`patterns.md` §3).
 
 ---
 
-## Resumo Rápido
-
-| Necessidade | O que usar |
-|------------|-----------|
-| Converter objeto para JSON | `JsonUtil.toJson(obj)` |
-| Converter JSON para objeto | `JsonUtil.fromJson(json, Class)` |
-| Gerar ID único | `Guid.newShortGuid()` |
-| Gerar código curto | `Guid.shortTimeMillis()` |
-| Calcular data com expressão | `DateUtil.fromKeyword("-0M-")` |
-| Fazer requisição HTTP | `Unirest.get/post/put/delete(url)` |
-| Enviar email | `EmailBuilder.startingBlank()...` |
-| Acessar MongoDB | `database.getCollection("nome")` |
+## 10. Resumo Rápido
+
+| Necessidade | O que usar | Public Endpoint? |
+|------------|-----------|------------------|
+| Objeto → JSON / JSON → objeto | `JsonUtil` | Sim |
+| Gerar ID único / código curto | `Guid.newShortGuid()` / `shortTimeMillis()` | Trigger/Scheduler |
+| Calcular data | `DateUtil.fromKeyword("-0M-")` | Sim |
+| Requisição HTTP | `Unirest` | Não → `java.net.URL` |
+| Enviar email | `EmailBuilder` | Não → trigger/scheduler |
+| Hashear senha | `BCrypt` | Não → trigger |
+| Acessar MongoDB | `database` / `getJongoConnection()` | Sim (via manager) |