@authenty/authapi-types 1.0.9 → 1.0.11

package/CLIENT_USAGE.md

@@ -0,0 +1,317 @@
+# AuthAPI Client - Guia de Uso
+
+A classe `AuthApi.Client` fornece uma interface completa e tipada para se comunicar com a API de autenticação.
+
+## Instalação
+
+```bash
+npm install @authenty/authapi-types
+```
+
+## Uso Básico
+
+### Frontend (React, Vue, etc.)
+
+```typescript
+import { AuthApi } from '@authenty/authapi-types';
+
+// Configurar o client com storage do navegador
+const client = new AuthApi.Client({
+    baseURL: 'https://api.exemplo.com',
+    tokenStorage: {
+        getToken: () => localStorage.getItem('token'),
+        setToken: (token) => localStorage.setItem('token', token),
+        getPin1: () => localStorage.getItem('pin1'),
+        setPin1: (pin1) => localStorage.setItem('pin1', pin1)
+    },
+    retryAttempts: 2,
+    retryDelay: 1000
+});
+
+// Usar o client
+async function fazerLogin() {
+    const result = await client.login('usuario@exemplo.com', 'senha123');
+    
+    if (result.success) {
+        console.log('Usuário logado:', result.data.user);
+    } else {
+        console.error('Erro no login:', result.msg);
+    }
+}
+```
+
+### Backend (Node.js)
+
+```typescript
+import { AuthApi } from '@authenty/authapi-types';
+
+// Configurar o client sem storage (tokens gerenciados manualmente)
+const client = new AuthApi.Client({
+    baseURL: 'https://api.exemplo.com',
+    retryAttempts: 3,
+    retryDelay: 500
+});
+
+// Definir token manualmente se necessário
+client.setToken('seu-token-jwt');
+
+// Usar o client
+async function obterUsuario(userId: number) {
+    const result = await client.getUser(userId);
+    
+    if (result.success) {
+        return result.data;
+    } else {
+        throw new Error(result.msg);
+    }
+}
+```
+
+## API Completa
+
+### Autenticação
+
+```typescript
+// Login
+const loginResult = await client.login(email, password);
+
+// Logout
+const logoutResult = await client.logout();
+
+// Verificar sessão
+const sessionResult = await client.checkSession();
+
+// Verificar saúde do servidor
+const isHealthy = await client.isHealthy();
+```
+
+### Usuários
+
+```typescript
+// Listar todos os usuários
+const usersResult = await client.listUsers();
+
+// Obter um usuário específico
+const userResult = await client.getUser(userId, includePurchases);
+
+// Atualizar usuário
+const updateResult = await client.updateUser(userId, {
+    fullname: 'Novo Nome',
+    email: 'novo@email.com'
+});
+
+// Atualizar configuração
+const configResult = await client.updateUserConfig(userId, {
+    config_ihm_showRates: true
+});
+
+// Atualizar privilégios de admin
+const adminResult = await client.updateUserAdmin(userId, true);
+
+// Obter informações de licença
+const licenseResult = await client.getUserLicense(userId);
+```
+
+### Purchases (Compras)
+
+```typescript
+// Criar nova compra
+const purchaseResult = await client.createPurchase(userId, paymentMethodId);
+
+// Sincronizar compra com gateway
+const syncResult = await client.syncPurchase(userId, purchaseId);
+
+// Atualizar compra
+const updateResult = await client.updatePurchase(userId, purchaseData);
+
+// Cancelar compra
+const cancelResult = await client.cancelPurchase(userId, purchaseId);
+
+// Deletar compra
+const deleteResult = await client.deletePurchase(userId, purchaseId);
+
+// Listar compras
+const listResult = await client.listPurchases(page, pageSize, userId);
+
+// Obter compra do gateway
+const gatewayResult = await client.getPurchaseFromGateway(userId, purchaseId);
+```
+
+### Produtos
+
+```typescript
+// Listar produtos
+const productsResult = await client.listProducts();
+
+// Obter produto específico
+const productResult = await client.getProduct(productId);
+
+// Atualizar produto
+const updateResult = await client.updateProduct(productId, productData);
+```
+
+### Métodos de Pagamento
+
+```typescript
+// Criar método de pagamento
+const createResult = await client.createPaymentMethod(bundleId, paymentMethodData);
+
+// Atualizar método de pagamento
+const updateResult = await client.updatePaymentMethod(bundleId, paymentMethodId, paymentMethodData);
+
+// Deletar método de pagamento
+const deleteResult = await client.deletePaymentMethod(bundleId, paymentMethodId);
+```
+
+### Logs
+
+```typescript
+// Listar logs
+const logsResult = await client.listLogs({
+    page: 1,
+    itemsPerPage: 50,
+    search: 'termo de busca'
+});
+
+// Obter status dos logs
+const statusResult = await client.getLogsStatus();
+```
+
+### CronJobs
+
+```typescript
+// Obter status dos cronjobs
+const statusResult = await client.getCronJobsStatus();
+
+// Executar cronjob manualmente
+const runResult = await client.runCronJob('jobName');
+```
+
+### Auxiliares
+
+```typescript
+// Listar países
+const countriesResult = await client.listCountries();
+
+// Listar estados de um país
+const statesResult = await client.listStates(countryId);
+
+// Listar cidades de um estado
+const citiesResult = await client.listCities(countryId, stateId);
+
+// Enviar relatório de erro
+const reportResult = await client.sendReport(errorId, errorData, appVersion);
+```
+
+## Configuração Avançada
+
+### Com callbacks para atualização de tokens
+
+```typescript
+const client = new AuthApi.Client({
+    baseURL: 'https://api.exemplo.com',
+    tokenStorage: {
+        getToken: () => localStorage.getItem('token'),
+        setToken: (token) => localStorage.setItem('token', token),
+        getPin1: () => localStorage.getItem('pin1'),
+        setPin1: (pin1) => localStorage.setItem('pin1', pin1)
+    },
+    onTokenUpdate: (token) => {
+        console.log('Token atualizado:', token);
+        // Disparar evento global, atualizar estado, etc.
+    },
+    onPin1Update: (pin1) => {
+        console.log('PIN1 atualizado:', pin1);
+    },
+    retryAttempts: 3,
+    retryDelay: 1000
+});
+```
+
+### Gerenciamento manual de tokens
+
+```typescript
+// Definir token
+client.setToken('novo-token');
+
+// Definir PIN1
+client.setPin1('novo-pin1');
+
+// Obter token atual
+const currentToken = client.getToken();
+
+// Obter PIN1 atual
+const currentPin1 = client.getPin1();
+```
+
+## Tipos de Resposta
+
+Todas as respostas seguem o padrão `ApiResponse<T>`:
+
+```typescript
+type ApiResponse<T> = {
+    conex: boolean;      // true se houve conexão com o servidor
+    reqStat: number;     // Código de status HTTP
+    success: boolean;    // true se a requisição foi bem-sucedida (200-299)
+    data: T;            // Dados retornados pela API
+    msg: string;        // Mensagem de erro ou sucesso
+}
+```
+
+### Exemplo de tratamento de resposta:
+
+```typescript
+const result = await client.login(email, password);
+
+if (!result.conex) {
+    // Erro de conexão - servidor indisponível
+    console.error('Sem conexão com o servidor');
+} else if (!result.success) {
+    // Erro da API - credenciais inválidas, etc.
+    console.error('Erro:', result.msg);
+} else {
+    // Sucesso!
+    console.log('Usuário:', result.data.user);
+}
+```
+
+## Tipos Disponíveis
+
+Todos os tipos estão disponíveis através do namespace `AuthApi`:
+
+```typescript
+// Objetos de domínio
+import type { 
+    AuthApi.objects.User,
+    AuthApi.objects.Purchase,
+    AuthApi.objects.Product,
+    // ... etc
+} from '@authenty/authapi-types';
+
+// Tipos de resposta
+import type {
+    AuthApi.responses.auth.login.post,
+    AuthApi.responses.users.list.get,
+    // ... etc
+} from '@authenty/authapi-types';
+```
+
+## Migração do código antigo
+
+### Antes (usando api/index.tsx):
+
+```typescript
+import api from '../api';
+
+const result = await api.auth.login(email, password);
+```
+
+### Depois (usando AuthApi.Client):
+
+```typescript
+import { client } from '../config/api'; // client configurado uma vez
+
+const result = await client.login(email, password);
+```
+
+A API é praticamente idêntica, mas agora completamente tipada e reutilizável!

package/README.md

@@ -1,34 +1,106 @@
 # @authenty/authapi-types
 
-Pacote de tipos compartilhados da Authenty API.
+Pacote de tipos compartilhados e client HTTP da Authenty API.
 
-## Como Publicar
+## Recursos
 
-1.  Certifique-se de estar logado no npm:
+- ✅ Tipos TypeScript completos para toda a API
+- ✅ Client HTTP pronto para uso (browser e Node.js)
+- ✅ Gerenciamento automático de tokens
+- ✅ Retry logic configurável
+- ✅ Totalmente tipado com autocomplete
+
+## Instalação
+
+```bash
+npm install @authenty/authapi-types
+```
+
+## Uso Rápido
+
+### Frontend (React, Vue, etc.)
+
+```typescript
+import { AuthApi } from '@authenty/authapi-types';
+
+// Configurar o client
+const client = new AuthApi.Client({
+    baseURL: 'https://api.exemplo.com',
+    tokenStorage: {
+        getToken: () => localStorage.getItem('token'),
+        setToken: (token) => localStorage.setItem('token', token),
+        getPin1: () => localStorage.getItem('pin1'),
+        setPin1: (pin1) => localStorage.setItem('pin1', pin1)
+    },
+    retryAttempts: 2,
+    retryDelay: 1000
+});
+
+// Usar
+const result = await client.login('usuario@exemplo.com', 'senha123');
+if (result.success) {
+    console.log('Usuário logado:', result.data.user);
+}
+```
+
+### Backend (Node.js)
+
+```typescript
+import { AuthApi } from '@authenty/authapi-types';
+
+const client = new AuthApi.Client({
+    baseURL: 'https://api.exemplo.com'
+});
+
+client.setToken('seu-token-jwt');
+const user = await client.getUser(123);
+```
+
+### Usando apenas os tipos
+
+```typescript
+import type { 
+    AuthApi.objects.LocalUser,
+    AuthApi.objects.Purchase,
+    AuthApi.responses.auth.login.post
+} from '@authenty/authapi-types';
+```
+
+## Documentação
+
+- [Guia Completo do Client](./CLIENT_USAGE.md) - Documentação detalhada de todos os métodos
+
+## Publicação
+
+1. Certifique-se de estar logado no npm:
     ```bash
     npm login
     ```
 
-2.  Faça o build do pacote:
+2. Incremente a versão (se necessário):
+    ```bash
+    npm run version:increment
+    ```
+
+3. Faça o build do pacote:
     ```bash
     npm run build
     ```
 
-3.  Publique o pacote (acesso público):
+4. Publique o pacote (acesso público):
     ```bash
     npm publish --access public
     ```
 
-## Como Usar
-
-Instale o pacote em seu projeto:
+## Desenvolvimento
 
 ```bash
-npm install @authenty/authapi-types
-```
+# Instalar dependências
+npm install
 
-Importe os tipos:
+# Build
+npm run build
 
-```typescript
-import { ExampleType } from '@authenty/authapi-types';
+# Incrementar versão
+npm run version:increment
 ```

package/dist/general.d.ts

@@ -11,12 +11,12 @@ export type Product = {
     title: string;
     short: string;
     resume: string;
-    video?: string;
-    imgUrls?: string;
+    video: string;
+    imgUrls: string | null;
     logo: string;
-    themeImage?: string;
-    themeColor?: string;
-    themeVideo?: string;
+    themeImage: string;
+    themeColor: string;
+    themeVideo: string;
     url: string;
     type: number;
     period_test: number;

package/dist/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "@authenty/authapi-types",
+    "version": "1.0.11",
+    "description": "Shared types for Authenty API",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "prebuild": "node IncrementVersion.js",
+        "build": "tsc",
+        "dev": "tsc -w"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "devDependencies": {
+        "typescript": "^5.0.0"
+    }
+}