# Manual de Configuração do Servidor Ubuntu 24.04 — Refood-One

Este guia contém todos os passos necessários para preparar um servidor limpo com Ubuntu 24.04 para alojar e executar a aplicação **Refood-One** (SvelteKit + Drizzle/SQLite). 

Por questões de segurança, a aplicação será executada sob um utilizador de sistema dedicado (`refood`) sem privilégios de superutilizador.

---

## 1. Atualizar o Servidor e Instalar Dependências de Compilação
Como a aplicação utiliza módulos nativos de Node.js (como `better-sqlite3` e `bcrypt`), precisamos das ferramentas de compilação instaladas:
```bash
sudo apt update && sudo apt upgrade -y
sudo apt install -y curl git build-essential sqlite3
```

---

## 2. Instalar o Node.js LTS (Versão 22 ou 20)
Configurar o repositório NodeSource e instalar o Node.js:
```bash
# Adicionar o repositório do Node.js 22 LTS
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

# Confirmar as versões instaladas
node -v
npm -v
```

---

## 3. Criar Utilizador Dedicado para a Aplicação (Segurança)
Nunca execute a aplicação como utilizador `root`. Crie um utilizador de sistema sem palavra-passe e com pasta própria:
```bash
sudo adduser --system --group --home /var/www/refood-one refood
```

---

## 4. Configurar o Diretório da Aplicação e Dependências
1. Faça o clone do repositório da aplicação (como root/administrador):
   ```bash
   # Clonar para a pasta dedicada
   git clone <URL_DO_REPOSITORIO_GIT> /var/www/refood-one
   ```

2. Ajuste as permissões para que o utilizador `refood` seja o proprietário exclusivo dos ficheiros:
   ```bash
   sudo chown -R refood:refood /var/www/refood-one
   ```

3. Mude para o diretório da aplicação:
   ```bash
   cd /var/www/refood-one
   ```

4. Instale as dependências. Recomenda-se realizar a instalação como o utilizador `refood`:
   ```bash
   sudo -u refood npm install
   ```

---

## 5. Configurar as Variáveis de Ambiente
Crie o ficheiro `.env` de produção:
```bash
sudo -u refood nano /var/www/refood-one/.env
```

Adicione e adapte as configurações necessárias:
```env
# Porta onde o servidor SvelteKit irá correr localmente
PORT=3000
ORIGIN=https://o-seu-dominio.com

# Drizzle / SQLite
DATABASE_URL=local.db

# Odoo API
ODOO_URL="https://erp.onrefood.com/jsonrpc"
ODOO_DB="refood.flybyodoo.pt"
ODOO_KEY="b4dadfb997fa8e3735c52b8d28476cd5ca339d2e"
ODOO_USER="duarte.caldas.oliveira@gmail.com"
ODOO_COMPANY_ID=
```

---

## 6. Inicializar Base de Dados e Compilar o Projeto
Execute estes comandos para aplicar as tabelas na base de dados SQLite e construir a build de produção da aplicação SvelteKit:
```bash
# Executar as migrações/push do Drizzle (injetando a variável de ambiente necessária)
sudo -u refood DATABASE_URL=local.db npm run db:push

# Criar a build de produção da aplicação
sudo -u refood npm run build
```

---

## 7. Instalar e Configurar o PM2 (Process Manager)
O PM2 irá manter o processo Node.js ativo e iniciá-lo no arranque do sistema.

1. Instalar o PM2 globalmente:
   ```bash
   sudo npm install -y -g pm2
   ```

2. Criar o ficheiro de configuração do PM2 (`ecosystem.config.cjs`) para carregar o ficheiro `.env` e as variáveis necessárias no arranque:
   ```bash
   sudo -u refood nano /var/www/refood-one/ecosystem.config.cjs
   ```
   Cole o seguinte conteúdo:
   ```javascript
   const fs = require('fs');
   const path = require('path');

   // Ler e parsear o ficheiro .env
   const envPath = path.resolve(__dirname, '.env');
   const env = {};
   if (fs.existsSync(envPath)) {
     const lines = fs.readFileSync(envPath, 'utf-8').split('\n');
     for (const line of lines) {
       if (!line.trim() || line.trim().startsWith('#')) continue;
       const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
       if (match) {
         const key = match[1];
         let value = match[2] || '';
         if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
         if (value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
         env[key] = value.trim();
       }
     }
   }

   module.exports = {
     apps: [
       {
         name: 'refood-one',
         script: 'build/index.js',
         cwd: '/var/www/refood-one',
         env: {
           NODE_ENV: 'production',
           ...env
         }
       }
     ]
   };
   ```

3. Iniciar a aplicação usando a configuração criada:
   ```bash
   sudo -u refood pm2 start /var/www/refood-one/ecosystem.config.cjs
   ```

4. Configurar o PM2 para iniciar no arranque do servidor com o utilizador `refood`:
   ```bash
   sudo pm2 startup systemd -u refood --hp /var/www/refood-one
   ```
   *Nota: O comando acima irá gerar um comando `sudo env PATH=$PATH...` na consola. Copie e execute esse comando gerado para ativar o serviço no systemd.*

5. Guardar a lista de processos para o utilizador `refood`:
   ```bash
   sudo -u refood pm2 save
   ```

---

## 8. Configurar o Nginx como Reverse Proxy
1. Instalar o Nginx:
   ```bash
   sudo apt install -y nginx
   ```

2. Criar um ficheiro de configuração do site:
   ```bash
   sudo nano /etc/nginx/sites-available/refood-one
   ```

3. Colar a seguinte configuração (substituindo `o-seu-dominio.com` pelo seu domínio real):
   ```nginx
   server {
       listen 80;
       server_name o-seu-dominio.com www.o-seu-dominio.com;

       location / {
           proxy_pass http://127.0.0.1:3000;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection 'upgrade';
           proxy_set_header Host $host;
           proxy_cache_bypass $http_upgrade;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
       }
   }
   ```

4. Ativar a configuração e reiniciar o Nginx:
   ```bash
   # Criar o link simbólico para ativar
   sudo ln -s /etc/nginx/sites-available/refood-one /etc/nginx/sites-enabled/

   # Desativar a configuração por defeito do Nginx (opcional)
   sudo rm /etc/nginx/sites-enabled/default

   # Verificar se a sintaxe do Nginx está correta
   sudo nginx -t

   # Recarregar o Nginx
   sudo systemctl restart nginx
   ```

---

## 9. Configurar Certificado SSL (HTTPS) com Let's Encrypt
1. Instalar o Certbot:
   ```bash
   sudo apt install -y certbot python3-certbot-nginx
   ```

2. Obter o certificado SSL (o Certbot irá alterar a configuração do Nginx automaticamente):
   ```bash
   sudo certbot --nginx -d o-seu-dominio.com -d www.o-seu-dominio.com
   ```

---

## Anexo: Limpeza do PM2 Root Antigo
Se configurou anteriormente o PM2 a correr diretamente como `root` e deseja remover esses vestígios do servidor atual, execute:

```bash
# 1. Parar o serviço systemctl antigo do root
sudo systemctl stop pm2-root
sudo systemctl disable pm2-root

# 2. Remover o script de arranque antigo do root
sudo pm2 unstartup systemd

# 3. Remover o ficheiro do serviço systemd
sudo rm /etc/systemd/system/pm2-root.service
sudo systemctl daemon-reload
sudo systemctl reset-failed

# 4. Matar o processo daemon residual do root
sudo pm2 kill
```

---

## Anexo B: Como Atualizar a Aplicação (Deploy de Novas Versões)
Sempre que fizer alterações no Git e as quiser colocar em produção, execute a seguinte sequência de comandos no servidor:

```bash
# 1. Mudar para a pasta da aplicação
cd /var/www/refood-one

# 2. Descarregar a última versão do código (como utilizador refood)
sudo -u refood git pull

# 3. Instalar novas dependências (caso package.json tenha alterado)
sudo -u refood npm install

# 4. Aplicar novas migrações na base de dados (se o schema do Drizzle tiver mudado)
sudo -u refood DATABASE_URL=local.db npm run db:push

# 5. Compilar o projeto novamente
sudo -u refood npm run build

# 6. Recarregar o PM2 de forma segura (Zero Downtime)
sudo -u refood pm2 reload refood-one
```
*Dica: O comando `pm2 reload` reinicia os processos de forma faseada, garantindo que o seu site não fica fora do ar (zero downtime) enquanto a atualização é aplicada.*