@jumentix/cli-init 0.0.0

package/templates/backend/docker-compose-service-templates.yml

@@ -0,0 +1,40 @@
+services:
+  rest-api:
+    build:
+      context: .
+      dockerfile: ./docker/services/Dockerfile.rest
+    ports:
+      - '3000:3000'
+    profiles: ['rest']
+
+  websocket-api:
+    build:
+      context: .
+      dockerfile: ./docker/services/Dockerfile.websocket
+    ports:
+      - '3001:3000'
+    profiles: ['websocket']
+
+  grpc-api:
+    build:
+      context: .
+      dockerfile: ./docker/services/Dockerfile.grpc
+    ports:
+      - '50051:50051'
+    profiles: ['grpc']
+
+  graphql-api:
+    build:
+      context: .
+      dockerfile: ./docker/services/Dockerfile.graphql
+    ports:
+      - '3002:3000'
+    profiles: ['graphql']
+
+  functions-bundle:
+    build:
+      context: .
+      dockerfile: ./docker/services/Dockerfile.functions
+    ports:
+      - '3003:3000'
+    profiles: ['functions']

package/templates/backend/documentation/README.md

@@ -0,0 +1,65 @@
+# Backend Template Documentation Hub
+
+This is the technical documentation hub for the backend template application used by Jumentix to bootstrap backend services.
+
+## Index
+
+- Guides
+  - [Creating REST API with Jumentix](./guides/CREATING-REST-API-WITH-JUMENTIX.md)
+  - [Creating Realtime API with Jumentix](./guides/CREATING-REALTIME-API-WITH-JUMENTIX.md)
+- Architecture and structure
+  - [Architecture and Structure](../../../documentation/md/ARCHITECTURE-AND-STRUCTURE.md)
+  - [Hexagonal Feature-Driven Migration](../../../documentation/md/HEXAGONAL-FEATURE-DRIVEN-MIGRATION.md)
+- Runtime and adapters
+  - [Runtime Environment Contracts](../../../documentation/md/RUNTIME-ENVIRONMENT-CONTRACTS.md)
+  - [HTTP Adapters](../../../documentation/md/adapters/http/README.md)
+  - [Realtime WebSocket API](../../../documentation/md/adapters/realtime/WEBSOCKET-API.md)
+  - [Realtime gRPC API](../../../documentation/md/adapters/realtime/GRPC-API.md)
+- Data and persistence
+  - [Database Adapters](../../../documentation/md/adapters/databases/README.md)
+  - [Database Drivers Smoke Tests](../../../documentation/md/DATABASE-DRIVERS-SMOKE-TESTS.md)
+- Contracts and quality
+  - [OpenAPI Spec](../../../spec/1.0.0.yml)
+  - [Events and Messages Map](../../../documentation/md/EVENTS-AND-MESSAGES-MAP.md)
+  - [Error Contracts and Responses](../../../documentation/md/ERROR-CONTRACTS-AND-RESPONSES.md)
+  - [Tenant and RBAC Authorization Contract](../../../documentation/md/TENANT-RBAC-AUTHORIZATION-CONTRACT.md)
+  - [Testing, CI and Quality](../../../documentation/md/TESTING-CI-AND-QUALITY.md)
+
+## What This Component Delivers
+
+- Contract-first backend services with OpenAPI 3.1 and AsyncAPI.
+- DDD + Hexagonal architecture baseline for modular monolith and microservice evolution.
+- Runtime adapter matrix for REST, realtime, and serverless contexts.
+- Pluggable persistence and messaging layers through shared `@jumentix/*` packages.
+
+## Main Entrypoints
+
+- REST runtime loaders and adapters in `apps/backend-template/src/interface/HTTP`.
+- Realtime runtime loaders and adapters in `apps/backend-template/src/interface/WebSocket` and `apps/backend-template/src/interface/gRPC`.
+- PM2 profiles from repo root `pm2/` for dev/staging/production process orchestration.
+
+## Architecture Snapshot
+
+- Domain modules expose use cases and controllers through inbound adapters.
+- Outbound concerns (database, key-value, messaging) are injected via shared runtime packages.
+- API contracts are OpenAPI-first for REST and AsyncAPI-first for realtime channels.
+
+## Integration Examples
+
+REST profile with explicit framework selection:
+
+```bash
+JUMENTIX_HTTP_FRAMEWORK=fastify bun run dev:http
+```
+
+WebSocket + REST fallback profile:
+
+```bash
+JUMENTIX_REALTIME_API=yes JUMENTIX_REALTIME_API_PROTOCOL=websocket bun run dev:websocket
+```
+
+gRPC + REST fallback profile:
+
+```bash
+JUMENTIX_REALTIME_API=yes JUMENTIX_REALTIME_API_PROTOCOL=grpc bun run dev:grpc
+```

package/templates/backend/documentation/README.pt-BR.md

@@ -0,0 +1,68 @@
+<!--
+Arquivo gerado automaticamente a partir de: apps/backend-template/documentation/README.md
+Idioma alvo: Português (Brasil)
+-->
+# Hub de documentação de modelo de back-end
+
+Este é o centro de documentação técnica para o aplicativo de modelo de back-end usado pela Jumentix para inicializar serviços de back-end.
+
+## Índice
+
+- Guias
+  - [Criando API REST com Jumentix](./guides/CREATING-REST-API-WITH-JUMENTIX.md)
+  - [Criando API em tempo real com Jumentix](./guides/CREATING-REALTIME-API-WITH-JUMENTIX.md)
+- Arquitetura e estrutura
+  - [Arquitetura e Estrutura](../../../documentation/md/ARCHITECTURE-AND-STRUCTURE.md)
+  - [Migração hexagonal baseada em recursos](../../../documentation/md/HEXAGONAL-FEATURE-DRIVEN-MIGRATION.md)
+- Tempo de execução e adaptadores
+  - [Contratos de ambiente de tempo de execução](../../../documentation/md/RUNTIME-ENVIRONMENT-CONTRACTS.md)
+  - [Adaptadores HTTP](../../../documentation/md/adapters/http/README.md)
+  - [API WebSocket em tempo real](../../../documentation/md/adapters/realtime/WEBSOCKET-API.md)
+  - [API gRPC em tempo real](../../../documentation/md/adapters/realtime/GRPC-API.md)
+- Dados e persistência
+  - [Adaptadores de banco de dados](../../../documentation/md/adapters/databases/README.md)
+  - [Testes de fumaça de drivers de banco de dados](../../../documentation/md/DATABASE-DRIVERS-SMOKE-TESTS.md)
+- Contratos e qualidade
+  - [Especificações OpenAPI](../../../spec/1.0.0.yml)
+  - [Mapa de eventos e mensagens](../../../documentation/md/EVENTS-AND-MESSAGES-MAP.md)
+  - [Erro de contratos e respostas](../../../documentation/md/ERROR-CONTRACTS-AND-RESPONSES.md)
+  - [Teste, CI e Qualidade](../../../documentation/md/TESTING-CI-AND-QUALITY.md)
+
+## O que este componente oferece
+
+- Contrate primeiro serviços de back-end com OpenAPI 3.1 e AsyncAPI.
+- Linha de base da arquitetura DDD + Hexagonal para evolução modular de monólitos e microsserviços.
+- Matriz de adaptador de tempo de execução para contextos REST, em tempo real e sem servidor.
+- Camadas de persistência e mensagens conectáveis ​​através de pacotes `@jumentix/*` compartilhados.
+
+## Principais pontos de entrada
+
+- Carregadores e adaptadores de tempo de execução REST em `apps/backend-template/src/interface/HTTP`.
+- Carregadores e adaptadores de tempo de execução em tempo real em `apps/backend-template/src/interface/WebSocket` e `apps/backend-template/src/interface/gRPC`.
+- Perfis PM2 do repo root `pm2/` para orquestração de processos de desenvolvimento/preparação/produção.
+
+## Instantâneo da arquitetura
+
+- Os módulos de domínio expõem casos de uso e controladores por meio de adaptadores de entrada.
+- As preocupações de saída (banco de dados, valor-chave, mensagens) são injetadas por meio de pacotes de tempo de execução compartilhados.
+- Os contratos de API são OpenAPI first para REST e AsyncAPI first para canais em tempo real.
+
+## Exemplos de integração
+
+Perfil REST com seleção explícita de estrutura:
+
+```bash
+JUMENTIX_HTTP_FRAMEWORK=fastify bun run dev:http
+```
+
+Perfil substituto WebSocket + REST:
+
+```bash
+JUMENTIX_REALTIME_API=yes JUMENTIX_REALTIME_API_PROTOCOL=websocket bun run dev:websocket
+```
+
+Perfil substituto gRPC + REST:
+
+```bash
+JUMENTIX_REALTIME_API=yes JUMENTIX_REALTIME_API_PROTOCOL=grpc bun run dev:grpc
+```

package/templates/backend/documentation/guides/CREATING-REALTIME-API-WITH-JUMENTIX.md

@@ -0,0 +1,176 @@
+# Creating Realtime API with Jumentix
+
+## Responsibility in context
+
+- **Owns:** Realtime adapters (Socket.IO / gRPC) around the same use-cases
+- **Used with:** sdk-websocket-client, sdk-grpc-client, shared-contracts
+- **Not responsible for:** Plain REST-only flows or browser IndexedDB
+
+## What it is
+
+This guide covers enabling **push and bidirectional communication** on top of the
+backend template using WebSocket (browser-friendly) or gRPC (server-to-server), with
+REST kept as an operational fallback.
+
+## Why it exists
+
+Many products need live updates — chat, notifications, dashboards — but teams bolt
+WebSocket code onto REST controllers and lose contract alignment. Jumentix treats
+**AsyncAPI like OpenAPI**: channels and payloads are specified first, handlers invoke
+the same controllers and use cases as REST, and degraded realtime falls back to HTTP.
+
+## Prerequisites
+
+| Item | Required | Notes |
+| --- | --- | --- |
+| Bun 1.3.13+ | Yes | [Getting started](/docs/jumentix/concepts/getting-started) |
+| Working REST profile | Recommended | Complete [REST guide](/docs/jumentix/guides/rest-api) first |
+| AsyncAPI specs | Yes | Under `spec/` alongside OpenAPI |
+| Env file | Yes | `apps/backend-template/src/config/.env.dev` |
+
+## Glossary
+
+| Term | Meaning on this page |
+| --- | --- |
+| **Realtime API** | Non-HTTP primary interface — WebSocket or gRPC — for push/pull messaging. |
+| **AsyncAPI** | Spec describing channels, messages, and payload schemas for realtime. |
+| **WebSocket** | Browser-friendly persistent connection; default protocol for SPAs. |
+| **gRPC** | Binary RPC protocol; use for service-to-service, not browser clients. |
+| **REST fallback** | HTTP endpoints still available when realtime channel is down or unsupported. |
+| **Message handler** | Adapter code receiving a message, calling a controller, replying on same correlation id. |
+| **Correlation id** | Token linking a client request to its response on the same socket. |
+| **JUMENTIX_REALTIME_API** | Env flag `yes`/`no` enabling realtime startup profile. |
+
+## Numbered steps
+
+### Step 1 — Enable the realtime runtime profile (< 5 minutes)
+
+1. Edit your env file:
+
+```bash
+JUMENTIX_REALTIME_API=yes
+JUMENTIX_REALTIME_API_PROTOCOL=websocket   # or grpc
+JUMENTIX_HTTP_FRAMEWORK=express            # REST fallback + docs
+```
+
+2. Start the matching dev profile from monorepo root:
+
+```bash
+# WebSocket + REST fallback (start here for browser apps)
+bun run dev:websocket
+
+# gRPC + REST fallback (Node service mesh)
+bun run dev:grpc
+```
+
+From `apps/backend-template` you can also run `bun run dev:websocket-rest` or
+`bun run dev:grpc-rest`.
+
+**Success check:** PM2 shows the websocket or grpc process online; REST `/health`
+still responds.
+
+### Step 2 — Define Async contracts (< 15 minutes)
+
+1. Add or update AsyncAPI files under `spec/` — define **channels**, **messages**,
+   and payload schemas.
+2. Align payload shapes with domain models and controller method signatures.
+3. Reference shared error/response contracts in handler implementations — same types
+   as REST DTOs where possible.
+4. Cross-check [Events and messages](/docs/jumentix/reference/events-messages) for
+   naming conventions.
+
+**Success check:** AsyncAPI channel names match handler registrations; no orphan messages.
+
+### Step 3 — Implement message handlers (< 30 minutes)
+
+**WebSocket path (browser apps):**
+
+1. Handler receives framed message on a channel.
+2. Handler parses payload → calls controller method.
+3. Handler sends response on the **same client connection** using the message correlation id.
+
+**gRPC path (Node-to-Node):**
+
+1. gRPC service method receives protobuf request.
+2. Invokes the same controller used by REST.
+3. Returns protobuf response mapped from domain result.
+
+Rule: **controllers and use cases stay identical** — only adapter code differs from REST.
+
+**Success check:** unit/integration test invokes handler without starting full cluster.
+
+### Step 4 — Keep REST fallback available (< 5 minutes)
+
+Realtime services always run with REST as a secondary interface:
+
+- Operational tools and degraded mode use REST endpoints.
+- OpenAPI docs remain the backup contract when sockets fail.
+- Do not delete REST routes when adding realtime — clients may downgrade gracefully.
+
+**Success check:** with realtime process stopped, REST endpoints still serve critical reads.
+
+### Step 5 — Validate realtime stability (< 10 minutes)
+
+From monorepo root:
+
+```bash
+bun run test:integration:realtime
+bun run test:smoke:realtime
+```
+
+For Redis-backed Socket.IO scaling (optional advanced path):
+
+```bash
+bun run test:integration:realtime:redis-streams
+```
+
+**Success check:** both commands exit 0; smoke test covers connect → message → response.
+
+### Step 6 — Client integration (junior path)
+
+**Prefer WebSocket for browser apps.** gRPC stays Node-to-Node — use static snippets
+on the [gRPC adapter](/docs/jumentix/adapters/realtime/grpc-api) page, not a browser Run button.
+
+Static subscribe pattern:
+
+```js
+const ws = api.createMockClient();
+const sub = await ws.subscribe({ channel: 'notifications' });
+sub.on('message', (msg) => console.log(msg.payload));
+```
+
+## Examples
+
+### Interactive WebSocket client playground
+
+<DocsPlayground runtime="sdk-websocket-client" id="getting-started" />
+
+**Success check:** **Run** connects mock client, receives a message; **Reset** clears state.
+
+## Common errors
+
+| Symptom | Likely cause | Fix | Verify success |
+| --- | --- | --- | --- |
+| Realtime starts but REST 404 | HTTP adapter not loaded in combined profile | Keep `JUMENTIX_HTTP_FRAMEWORK=express`; use `dev:websocket` not raw socket only | `/health` returns 200 |
+| Handler never replies | Missing correlation id on response | Echo client message id in adapter reply | Integration test green |
+| Browser cannot use gRPC | gRPC is not a browser protocol | Use WebSocket for SPA; gRPC for backend services | WS playground Run green |
+| `test:integration:realtime` fails on grpc | Wrong `JUMENTIX_REALTIME_API_PROTOCOL` | Match env to script (`websocket` vs `grpc`) | Target protocol test passes |
+| Duplicate message handling | Handler registered twice | One registration per channel in adapter bootstrap | Single response per send |
+| Redis streams test skipped | `RUN_REDIS_INTEGRATION` not set | Start redis compose; set env flag | redis-streams integration green |
+
+## Junior checklist (“I can …”)
+
+- [ ] Set `JUMENTIX_REALTIME_API=yes` and choose `websocket` or `grpc`.
+- [ ] Start `bun run dev:websocket` and confirm REST fallback still works.
+- [ ] Locate AsyncAPI under `spec/` and name one channel and its payload schema.
+- [ ] Trace one message: adapter handler → controller → use case.
+- [ ] Run `bun run test:integration:realtime` and `bun run test:smoke:realtime`.
+- [ ] Use the sdk-websocket-client playground (**Run** green).
+- [ ] Explain when to choose gRPC instead of WebSocket.
+
+## Next step
+
+Build the frontend that consumes these channels in
+[Create a SPA or Offline PWA](/docs/jumentix/guides/spa-pwa). For adapter details,
+see [WebSocket adapter](/docs/jumentix/adapters/realtime/websocket-api) and
+[gRPC adapter](/docs/jumentix/adapters/realtime/grpc-api).

package/templates/backend/documentation/guides/CREATING-REALTIME-API-WITH-JUMENTIX.pt-BR.md

@@ -0,0 +1,177 @@
+# Criando API em tempo real com Jumentix
+
+## Responsabilidade no escopo
+
+- **Responsável por:** Adapters realtime (Socket.IO / gRPC) em torno dos mesmos use-cases
+- **Usado com:** sdk-websocket-client, sdk-grpc-client, shared-contracts
+- **Não responsável por:** Fluxos só REST ou IndexedDB no browser
+
+## O que é
+
+Este guia cobre como habilitar **comunicação push e bidirecional** no template de
+backend usando WebSocket (amigável ao browser) ou gRPC (servidor-a-servidor), com
+REST mantido como fallback operacional.
+
+## Por que existe
+
+Muitos produtos precisam de atualizações ao vivo — chat, notificações, dashboards —
+mas times colam código WebSocket em controllers REST e perdem alinhamento de
+contrato. O Jumentix trata **AsyncAPI como OpenAPI**: canais e payloads são
+especificados primeiro, handlers invocam os mesmos controllers e casos de uso do
+REST, e realtime degradado cai para HTTP.
+
+## Pré-requisitos
+
+| Item | Obrigatório | Notas |
+| --- | --- | --- |
+| Bun 1.3.13+ | Sim | [Começando](/docs/pt-BR/jumentix/concepts/getting-started) |
+| Perfil REST funcionando | Recomendado | Complete o [guia REST](/docs/pt-BR/jumentix/guides/rest-api) primeiro |
+| Specs AsyncAPI | Sim | Em `spec/` junto com OpenAPI |
+| Arquivo de env | Sim | `apps/backend-template/src/config/.env.dev` |
+
+## Glossário
+
+| Termo | Significado nesta página |
+| --- | --- |
+| **API em tempo real** | Interface primária não-HTTP — WebSocket ou gRPC — para mensagens push/pull. |
+| **AsyncAPI** | Spec descrevendo canais, mensagens e schemas de payload para tempo real. |
+| **WebSocket** | Conexão persistente amigável ao browser; protocolo padrão para SPAs. |
+| **gRPC** | Protocolo RPC binário; use serviço-a-serviço, não clients de browser. |
+| **Fallback REST** | Endpoints HTTP ainda disponíveis quando o canal realtime cai ou não é suportado. |
+| **Handler de mensagem** | Código adaptador que recebe mensagem, chama controller e responde no mesmo id de correlação. |
+| **Id de correlação** | Token ligando request do client à response no mesmo socket. |
+| **JUMENTIX_REALTIME_API** | Flag de env `yes`/`no` habilitando perfil de startup realtime. |
+
+## Passos numerados
+
+### Passo 1 — Habilitar perfil de runtime realtime (< 5 minutos)
+
+1. Edite seu arquivo de env:
+
+```bash
+JUMENTIX_REALTIME_API=yes
+JUMENTIX_REALTIME_API_PROTOCOL=websocket   # ou grpc
+JUMENTIX_HTTP_FRAMEWORK=express            # fallback REST + docs
+```
+
+2. Inicie o perfil dev correspondente na raiz do monorepo:
+
+```bash
+# WebSocket + fallback REST (comece aqui para apps browser)
+bun run dev:websocket
+
+# gRPC + fallback REST (malha de serviços Node)
+bun run dev:grpc
+```
+
+De `apps/backend-template` também pode rodar `bun run dev:websocket-rest` ou
+`bun run dev:grpc-rest`.
+
+**Verificação de sucesso:** PM2 mostra processo websocket ou grpc online; REST `/health`
+ainda responde.
+
+### Passo 2 — Definir contratos Async (< 15 minutos)
+
+1. Adicione ou atualize arquivos AsyncAPI em `spec/` — defina **canais**, **mensagens**
+   e schemas de payload.
+2. Alinhe formas de payload com modelos de domínio e assinaturas de métodos do controller.
+3. Referencie contratos compartilhados de erro/response nos handlers — mesmos tipos
+   dos DTOs REST quando possível.
+4. Confira [Eventos e mensagens](/docs/pt-BR/jumentix/reference/events-messages) para
+   convenções de nomenclatura.
+
+**Verificação de sucesso:** nomes de canal AsyncAPI batem com registros de handler; sem mensagens órfãs.
+
+### Passo 3 — Implementar handlers de mensagem (< 30 minutos)
+
+**Caminho WebSocket (apps browser):**
+
+1. Handler recebe mensagem enquadrada em um canal.
+2. Handler parseia payload → chama método do controller.
+3. Handler envia resposta na **mesma conexão do client** usando o id de correlação da mensagem.
+
+**Caminho gRPC (Node-a-Node):**
+
+1. Método gRPC recebe request protobuf.
+2. Invoca o mesmo controller usado pelo REST.
+3. Retorna response protobuf mapeada do resultado de domínio.
+
+Regra: **controllers e casos de uso permanecem idênticos** — só código adaptador difere do REST.
+
+**Verificação de sucesso:** teste unitário/integração invoca handler sem subir cluster completo.
+
+### Passo 4 — Manter fallback REST disponível (< 5 minutos)
+
+Serviços realtime sempre rodam com REST como interface secundária:
+
+- Ferramentas operacionais e modo degradado usam endpoints REST.
+- Docs OpenAPI permanecem contrato de backup quando sockets falham.
+- Não remova rotas REST ao adicionar realtime — clients podem degradar graciosamente.
+
+**Verificação de sucesso:** com processo realtime parado, endpoints REST ainda servem leituras críticas.
+
+### Passo 5 — Validar estabilidade realtime (< 10 minutos)
+
+Na raiz do monorepo:
+
+```bash
+bun run test:integration:realtime
+bun run test:smoke:realtime
+```
+
+Para scaling Socket.IO com Redis (caminho avançado opcional):
+
+```bash
+bun run test:integration:realtime:redis-streams
+```
+
+**Verificação de sucesso:** ambos os comandos saem com 0; smoke test cobre connect → mensagem → resposta.
+
+### Passo 6 — Integração com client (caminho júnior)
+
+**Prefira WebSocket para apps browser.** gRPC fica Node-a-Node — use snippets estáticos
+na página do [adaptador gRPC](/docs/pt-BR/jumentix/adapters/realtime/grpc-api), não botão Run no browser.
+
+Padrão estático de subscribe:
+
+```js
+const ws = api.createMockClient();
+const sub = await ws.subscribe({ channel: 'notifications' });
+sub.on('message', (msg) => console.log(msg.payload));
+```
+
+## Exemplos
+
+### Playground interativo WebSocket client
+
+<DocsPlayground runtime="sdk-websocket-client" id="getting-started" />
+
+**Verificação de sucesso:** **Run** conecta client mock e recebe mensagem; **Reset** limpa estado.
+
+## Erros comuns
+
+| Sintoma | Causa provável | Correção | Verificar sucesso |
+| --- | --- | --- | --- |
+| Realtime sobe mas REST 404 | Adaptador HTTP não carregado no perfil combinado | Mantenha `JUMENTIX_HTTP_FRAMEWORK=express`; use `dev:websocket` | `/health` retorna 200 |
+| Handler nunca responde | Id de correlação ausente na resposta | Ecoe id da mensagem do client no reply do adaptador | Teste de integração verde |
+| Browser não usa gRPC | gRPC não é protocolo de browser | Use WebSocket para SPA; gRPC para serviços backend | Run do playground WS verde |
+| `test:integration:realtime` falha no grpc | `JUMENTIX_REALTIME_API_PROTOCOL` errado | Alinhe env ao script (`websocket` vs `grpc`) | Teste do protocolo alvo passa |
+| Handling duplicado de mensagem | Handler registrado duas vezes | Um registro por canal no bootstrap do adaptador | Uma resposta por envio |
+| Teste redis streams pulado | `RUN_REDIS_INTEGRATION` não definido | Suba compose redis; defina flag de env | Integração redis-streams verde |
+
+## Checklist júnior (“Eu consigo …”)
+
+- [ ] Definir `JUMENTIX_REALTIME_API=yes` e escolher `websocket` ou `grpc`.
+- [ ] Iniciar `bun run dev:websocket` e confirmar que fallback REST ainda funciona.
+- [ ] Localizar AsyncAPI em `spec/` e citar um canal e seu schema de payload.
+- [ ] Rastrear uma mensagem: handler adaptador → controller → caso de uso.
+- [ ] Rodar `bun run test:integration:realtime` e `bun run test:smoke:realtime`.
+- [ ] Usar playground sdk-websocket-client (**Run** verde).
+- [ ] Explicar quando escolher gRPC em vez de WebSocket.
+
+## Próximo passo
+
+Construa o frontend que consome estes canais em
+[Criar SPA ou PWA offline](/docs/pt-BR/jumentix/guides/spa-pwa). Para detalhes de
+adaptadores, veja [Adaptador WebSocket](/docs/pt-BR/jumentix/adapters/realtime/websocket-api) e
+[Adaptador gRPC](/docs/pt-BR/jumentix/adapters/realtime/grpc-api).