# Assinaturas

MVP Laravel 12 com Blade puro e PostgreSQL 16 isolado para o fluxo de assinaturas.

## Requisitos locais

- Docker com Compose.
- PHP 8.2+ e Composer 2 quando rodar comandos PHP no host.
- Node.js/npm apenas quando for compilar assets Vite.

O workspace Clever legado usa PostgreSQL 10 em outro container. Este projeto usa PostgreSQL 16 próprio e expõe a porta `5433` no host.

## Setup

```bash
cd /home/mariel/works/assinaturas
docker compose up -d
composer install
cp .env.example .env
php artisan key:generate
```

Preencha `INGESTION_TOKEN` no `.env` local. Não grave token real no Git.

## Desenvolvimento com Docker

Para simular o runtime da VPS localmente, suba a aplicação em PHP 8.3 dentro do Docker:

```bash
cd /home/mariel/works/assinaturas
docker compose up -d app vite
```

A aplicação fica em `http://127.0.0.1:8000` e o Vite em `http://127.0.0.1:5174`.

Comandos Artisan devem rodar no container da app:

```bash
docker compose exec app php artisan about
docker compose exec app php artisan migrate:fresh --seed
docker compose exec app php artisan test
```

Nesse modo, mantenha o `.env` com `DB_HOST=postgres` e `DB_PORT=5432`, que é a rede interna do Docker. Quando rodar PHP direto no host, troque para `DB_HOST=127.0.0.1` e `DB_PORT=5433`.

Se arquivos de runtime tiverem sido criados por outro usuário ou container, corrija as permissões:

```bash
docker compose exec -u root app chown -R app:app storage bootstrap/cache public/build .phpunit.result.cache
```

## Banco

Para rodar dentro do Docker, as variáveis esperadas são:

```dotenv
DB_CONNECTION=pgsql
DB_HOST=postgres
DB_PORT=5432
DB_DATABASE=assinaturas
DB_USERNAME=assinaturas_user
DB_PASSWORD=assinaturas_dev_password
```

Para rodar PHP direto no host, use:

```dotenv
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5433
DB_DATABASE=assinaturas
DB_USERNAME=assinaturas_user
DB_PASSWORD=assinaturas_dev_password
```

Para recriar o banco local com dados demo:

```bash
php artisan migrate:fresh --seed
```

O seeder nao cria usuarios. Crie usuarios manualmente com senha forte usando o SQL local nao versionado `.local/install-users.sql`.

## Token de ingestao

O endpoint `POST /api/ingestion/customer-payloads` usa um token compartilhado server-to-server. Esse token nunca deve ir para `public-web`, `delivery/` ou qualquer arquivo versionado.

Gere o token diretamente no servidor de producao:

```bash
php -r "echo bin2hex(random_bytes(32)), PHP_EOL;"
```

Configure o valor gerado nos dois lados:

```dotenv
# /assinaturas/.env
INGESTION_TOKEN=<token-gerado>

# /api/.env
ASSINATURAS_INGESTION_URL=https://assinaturas.seudominio.com.br
ASSINATURAS_INGESTION_TOKEN=<token-gerado>
```

Como alternativa ao `.env` da API, a URL e o token tambem podem ficar nos parametros de sistema `assinaturas_ingestion_url` e `assinaturas_ingestion_token`.

Depois de alterar o `.env` do `/assinaturas` em producao, recarregue o cache de configuracao:

```bash
php artisan config:clear
php artisan config:cache
```

Valide a ingestao com uma chamada server-to-server:

```bash
curl -i -X POST "https://assinaturas.seudominio.com.br/api/ingestion/customer-payloads" \
  -H "Content-Type: application/json" \
  -H "X-Ingestion-Token: <token-gerado>" \
  -d '{"prefix":"tenant","origem":"DELIVERY_PRO","pedido":{"id":123}}'
```

Resposta esperada: HTTP `201` com `customer_id` e `customer_payload_id`.

## Testes

O ambiente de testes usa PostgreSQL 16 isolado no mesmo container local, com database `assinaturas_testing`.

Crie o banco de teste uma vez:

```bash
docker compose up -d
docker exec assinaturas-postgres psql -U assinaturas_user -d postgres -c "CREATE DATABASE assinaturas_testing OWNER assinaturas_user;"
```

Rode a suite:

```bash
php artisan test
```

Se o host nao tiver PHP com `pdo_pgsql`, rode com um container PHP 8.4 temporario:

```bash
docker run --rm --network host -v "$PWD":/app -w /app php:8.4-cli-alpine sh -lc "apk add --no-cache postgresql-dev linux-headers >/dev/null && docker-php-ext-install pdo_pgsql >/dev/null && php artisan test"
```

## Checklist local validado

- PostgreSQL 16 local em `127.0.0.1:5433`.
- `php artisan test` passando em `assinaturas_testing`.
- `php artisan migrate:fresh --seed` passando em `assinaturas`.
- Login local com usuario criado manualmente.
- Ingestao local via `POST /api/ingestion/customer-payloads` com `X-Ingestion-Token`.
- Tela `/dados` autenticada listando somente cliente e quantidade.
- Alternancia claro/escuro disponivel no login e na tela `/dados`, persistida em `localStorage.theme`.
- Throttle aplicado em `POST /login` e `POST /api/ingestion/customer-payloads`.

## Desenvolvimento

```bash
php artisan serve --host=127.0.0.1 --port=8000
npm install
npm run dev
```

Este app não depende da stack legada `api/`, `web/`, `delivery/` ou `public-web/`.

## Build de release

Antes de publicar, gere um release limpo:

```bash
npm ci
npm run build
rm -f public/hot
composer install --no-dev --prefer-dist --optimize-autoloader
php artisan config:cache
php artisan route:cache
php artisan view:cache
```

O arquivo `public/hot` e o servidor Vite sao exclusivos do desenvolvimento. Se `public/hot` existir no release, o Laravel tentara carregar assets de `localhost:5174`.

Para imagem Docker de producao, use `Dockerfile.production`. O `Dockerfile` e o `docker-compose.yml` da raiz continuam sendo ambiente de desenvolvimento e usam `php artisan serve`.

Exemplo de build:

```bash
docker build -f Dockerfile.production -t assinaturas:production .
```

Para VPS com Nginx/PHP-FPM instalados no host, use `deploy/nginx-assinaturas.conf` como ponto de partida e ajuste `server_name`, caminho do projeto e socket do PHP-FPM.

## Deploy VPS

Nao executar deploy sem aprovacao explicita.

Quando aprovado:

- Criar database e usuario proprios no PostgreSQL 16 da VPS.
- Criar `.env` real fora do Git a partir de `.env.production.example`.
- Gerar `APP_KEY` no servidor e configurar `APP_ENV=production`, `APP_DEBUG=false`, `APP_URL=https://...`, credenciais reais do banco, `INGESTION_TOKEN` forte e `SESSION_SECURE_COOKIE=true`.
- Configurar na API Clever `ASSINATURAS_INGESTION_URL` e `ASSINATURAS_INGESTION_TOKEN` com o mesmo token do `/assinaturas`.
- Apontar o virtual host para `assinaturas/public`, nunca para a raiz do projeto.
- Rodar `php artisan migrate --force`.
- Criar o usuario administrativo manualmente com o SQL local nao versionado `.local/install-users.sql`, substituindo email, username e hash bcrypt antes de executar.
- Rodar os caches de producao: `php artisan config:cache`, `php artisan route:cache` e `php artisan view:cache`.
- Validar login, ingestao e `/dados` na URL final.
- Confirmar que `public/hot` nao existe no release publicado.
- Definir backup inicial separado para o database `assinaturas`, sem misturar com bancos Clever atuais.