diff --git a/.cursor/rules/cursorrules.mdc b/.cursor/rules/cursorrules.mdc new file mode 100644 index 0000000..5a7fe7b --- /dev/null +++ b/.cursor/rules/cursorrules.mdc @@ -0,0 +1,30 @@ +--- +description: +globs: +alwaysApply: false +--- +# Code Style & Quality +- Always use TypeScript over JavaScript +- Prefer const over let, avoid var +- Use meaningful variable names, no single letters except for loops +- Add JSDoc comments for functions and complex logic +- Use explicit return types for functions + +# HTMX Specific +- Always validate HTMX attributes (hx-get, hx-post, etc.) +- Use hx-target and hx-swap explicitly +- Include proper error handling with hx-on +- Prefer semantic HTML elements +- Use CSS classes instead of inline styles +# Security & Best Practices +- Never hardcode API keys or secrets +- Validate all user inputs +- Use parameterized queries for database operations +- Implement proper error boundaries +- Add loading states for async operations + +# Project Structure +- Keep components small and focused +- Use consistent file naming (kebab-case) +- Group related files in feature folders +- Separate business logic from UI components diff --git a/.cursorrules b/.cursorrules new file mode 100644 index 0000000..afe2586 --- /dev/null +++ b/.cursorrules @@ -0,0 +1,26 @@ +# Code Style & Quality +- Always use TypeScript over JavaScript +- Prefer const over let, avoid var +- Use meaningful variable names, no single letters except for loops +- Add JSDoc comments for functions and complex logic +- Use explicit return types for functions + +# HTMX Specific +- Always validate HTMX attributes (hx-get, hx-post, etc.) +- Use hx-target and hx-swap explicitly +- Include proper error handling with hx-on +- Prefer semantic HTML elements +- Use CSS classes instead of inline styles + +# Security & Best Practices +- Never hardcode API keys or secrets +- Validate all user inputs +- Use parameterized queries for database operations +- Implement proper error boundaries +- Add loading states for async operations + +# Project Structure +- Keep components small and focused +- Use consistent file naming (kebab-case) +- Group related files in feature folders +- Separate business logic from UI components \ No newline at end of file diff --git a/.denoignore b/.denoignore new file mode 100644 index 0000000..083ec5f --- /dev/null +++ b/.denoignore @@ -0,0 +1 @@ +tailwind.config.cjs \ No newline at end of file diff --git a/.env b/.env new file mode 100644 index 0000000..11f3954 --- /dev/null +++ b/.env @@ -0,0 +1,5 @@ +AUTH_GATEWAY_URL=http://localhost:8888 +AUTH_CLIENT_ID=YOUR_CLIENT_ID +AUTH_CLIENT_SECRET=YOUR_CLIENT_SECRET +AUTH_REDIRECT_URI=http://localhost:8000/callback +PORT=8000 diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml new file mode 100644 index 0000000..bd929d7 --- /dev/null +++ b/.github/workflows/deploy.yml @@ -0,0 +1,25 @@ +name: Deploy +on: [push] + +jobs: + deploy: + name: Deploy + runs-on: ubuntu-latest + permissions: + id-token: write + contents: read + + steps: + - name: Clone repository + uses: actions/checkout@v3 + + - name: Install Deno + uses: denoland/setup-deno@v1 + with: + deno-version: v1.x + + - name: Upload to Deno Deploy + uses: denoland/deployctl@v1 + with: + project: "imockapi" + entrypoint: "server.ts" \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..743061e --- /dev/null +++ b/README.md @@ -0,0 +1,214 @@ +# Refactoring Runbook: Fake API Server New iUI + +This runbook guides the refactoring of the Fake API Server New iUI project to align with best practices for Deno, Hono, HTMX, and clean code architecture. Use this as a checklist and reference for your refactor. + +--- + +## 1. Current State +- **Monolithic main.tsx**: Most logic (routing, middleware, business, helpers) is in a single large file. +- **Some modularization**: There are `components/`, `services/`, `routes/`, `types/`, and `utils/` directories, but boundaries are unclear. +- **No automated tests**: No Deno or other test files found. +- **Authentication, error handling, and logging**: Logic is duplicated and scattered. +- **HTMX**: Used, but not fully leveraged for partial updates or advanced UX. + +--- + +## 2. Target Architecture & Directory Structure + +**Proposed structure:** + +``` +/src + /controllers # Request handlers (business logic) + /middleware # Auth, logging, error handling + /services # Business/domain logic + /repositories # Data access (if needed) + /routes # Route definitions (grouped by feature) + /utils # Pure helpers + /components # JSX UI components + /types # TypeScript types + /tests # Unit/integration tests +``` + +--- + +## 3. Refactor Plan (Step-by-Step) + +### 3.1. Modularize main.tsx +- [x] **Extract route handlers** to `/controllers`. +- [x] **Move middleware** (auth, logger, static, layout) to `/middleware`. + - [x] Logger middleware + - [x] Static file middleware + - [x] Layout middleware + - [x] Auth middleware +- [x] **Move helper functions** (e.g., template string processing, request body parsing) to `/utils`. +- [x] **Keep only app setup and route registration** in `main.tsx`. +- [x] **Group routes by feature in `/routes` and register routes in `main.tsx` only** + +### 3.2. Middleware Improvements +- [ ] **Centralize authentication**: Create `/middleware/auth.ts` for all token extraction and validation logic. +- [ ] **Centralize error handling**: Add `/middleware/errorHandler.ts` for consistent error responses. +- [ ] **Centralize logging**: Use a single logger middleware. + +### 3.3. Service & Repository Pattern +- [ ] **Define interfaces** for repositories in `/repositories`. +- [ ] **Move business logic** (e.g., traffic log storage, API matching) to `/services`. +- [ ] **Inject dependencies** via context or constructor. + +### 3.4. Route Organization +- [x] **Group routes by feature in `/routes` and register routes in `main.tsx` only** + +### 3.5. HTMX Best Practices +- [x] **Create dedicated endpoints** for partial updates (fragments). +- [x] **Use HTMX response headers** (e.g., `HX-Redirect`, `HX-Refresh`). +- [x] **Document HTMX patterns** in code and README. + +### 3.6. Error Handling +- [x] **Use try/catch** in all async handlers. +- [x] **Return structured error responses** (JSON for APIs, HTML for UI). +- [x] **Log errors with context**. + +### 3.7. Authentication +- [ ] **Move all token logic** to middleware. +- [ ] **Support multiple auth types** via strategy pattern if needed. +- [ ] **Document the flow** in `/middleware/auth.ts` and README. + +### 3.8. Testing +- [ ] **Add unit tests** for utils, services, and middleware in `/tests`. +- [ ] **Add integration tests** for routes. +- [ ] **Use Deno's built-in test runner.** + +### 3.9. Documentation +- [ ] **Update README** with architecture, setup, and usage. +- [ ] **Document each module** with JSDoc/TSDoc. +- [ ] **Add code comments for complex logic.** + +--- + +## 4. Best Practices Checklist +- [x] Each file < 300 lines (except UI components) +- [x] Extract route handlers to `/controllers` +- [x] Move middleware (auth, logger, static, layout) to `/middleware` + - [x] Logger middleware + - [x] Static file middleware + - [x] Layout middleware + - [x] Auth middleware +- [x] All helpers in `/utils` +- [x] Keep only app setup and route registration in `main.tsx` +- [x] Group routes by feature in `/routes` and register routes in `main.tsx` only +- [ ] No business logic in route files +- [x] All middleware in `/middleware` +- [x] All helpers in `/utils` +- [x] All types in `/types` + - All context and domain types are now defined in `/types` and imported where needed. +- [ ] All tests in `/tests` + - No test files or test directories were found in the codebase. It is recommended to add a `/tests` directory with Deno tests for key modules and routes. +- [x] Consistent error handling and logging +- [x] Modular, composable route registration + - All feature routes are registered in main.tsx using app.route(), and controllers are imported and used for individual handlers. +- [x] HTMX endpoints return fragments, not full pages + - All HTMX endpoints return fragments, use HX-Redirect and HX-Refresh as appropriate, and follow best practices for partial updates. +- [x] Use HTMX response headers (e.g., `HX-Redirect`, `HX-Refresh`) + - All relevant endpoints set these headers for navigation and partial updates as appropriate. +- [x] Document HTMX patterns in code and README +- [x] Authentication is DRY and centralized + - All authentication logic is now handled in a single middleware (authIntrospectionMiddleware), and no routes or controllers duplicate authentication checks. +- [x] README and code are well documented + - The README now documents architecture, setup, usage, and authentication flow. Code is documented with comments and JSDoc/TSDoc where appropriate. +- [x] Improve error handling (try/catch, structured responses, contextual logging) + - try/catch blocks, contextual logging, and structured error responses (HTML for UI, JSON for API/HTMX) were added to all relevant POST handlers in mockApi routes. + +--- + +## 5. References +- [Deno Best Practices](https://deno.land/manual@v1.40.0/basics/best_practices) +- [Hono Documentation](https://hono.dev/docs) +- [HTMX Patterns](https://htmx.org/docs/) +- [Clean Architecture](https://github.com/ryanmcdermott/clean-code-javascript) + +--- + +**Use this runbook as a checklist and guide for your refactor.** + +# Fake API Server New iUI + +Servidor de API Fake (Mock API Server) construído com Deno, Hono e HTMX para facilitar o desenvolvimento e testes de integrações. + +## Migrating to Central Auth (Autenticação Centralizada) + +A partir desta versão, todas as rotas de front-end e de API são protegidas pelo nosso servidor de autenticação central. + +### Variáveis de Ambiente Necessárias + +- `CENTRAL_AUTH_URL` (opcional): URL base do servidor de autenticação central (padrão: `http://localhost:8888`). +- Para o servidor de autenticação central (Auth0 Gateway), use estas variáveis: + ```dotenv + AUTH0_DOMAIN=dev-ulp8mj8hsi4j2ofh.us.auth0.com + AUTH0_CLIENT_ID=FWjzQfi1yeIGVqBa7ON7p1sy7Iy6LAY9 + AUTH0_CLIENT_SECRET=-A84NCTmtEkKfAnzUzrzOt4I8q4L6JdC7aO-xQoeCdDezQ6GdpVSTCMe6giWYDXk + AUTH0_CALLBACK_URL=https://your-app.com/callback + AUTH0_LOGOUT_REDIRECT=https://your-app.com/logout + AUTH0_MGMT_CLIENT_ID= + AUTH0_MGMT_CLIENT_SECRET= + ``` + +### Fluxos de Login e Logout + +- **Login**: + ```http + GET /login?return_to=/caminho-desejado + ``` + - Redireciona para o servidor de autenticação central. + - Para requisições HTMX, utiliza cabeçalho `HX-Redirect`. + +- **Logout**: + ```http + POST /api/auth/logout?return_to=/caminho-desejado + ``` + - Encerra a sessão no servidor de autenticação central e redireciona de volta. + - Para HTMX, utiliza cabeçalho `HX-Redirect`. + +### Exemplos de Integração de Cliente + +#### HTMX +```html + +``` + +#### Deno (Hono) +```ts +import { Hono } from "hono/mod.ts"; + +const app = new Hono(); + +app.get("/login", (c) => { + const returnTo = encodeURIComponent("http://localhost:3000/callback"); + return c.redirect(`/login?return_to=${returnTo}`); +}); + +app.post("/api/auth/logout", (c) => { + const returnTo = encodeURIComponent("/"); + return c.redirect(`/logout?return_to=${returnTo}`); +}); +``` + +### Executando a Aplicação + +```bash +export CENTRAL_AUTH_URL=http://localhost:8888 +# (Opcionalmente configure as variáveis do servidor Auth0 Gateway) +deno run -A src/main.tsx +``` + +## Uso Básico + +- Navegue em `/` para Início. +- `/mock-api` para CRUD de APIs mock. +- `/traffic` para visualizar logs de tráfego. + +Por favor, consulte também o arquivo ` \ No newline at end of file diff --git a/README_API_AUTH.md b/README_API_AUTH.md new file mode 100644 index 0000000..3ed2915 --- /dev/null +++ b/README_API_AUTH.md @@ -0,0 +1,260 @@ +# API Gateway Authentication System + +This document describes the dual authentication system implemented in the API Gateway, where UI screens are protected by central authentication while dynamic APIs use their own configured authentication methods. + +## Overview + +The system implements two distinct authentication strategies: + +1. **Central Authentication**: Used for UI screens and administrative interfaces +2. **API-Specific Authentication**: Used for dynamically exposed APIs based on their individual configuration + +## Architecture + +### Central Authentication (UI Protection) + +- **Purpose**: Protects administrative screens, API management interfaces, and traffic monitoring +- **Mechanism**: Auth0 integration through central authentication gateway +- **Scope**: All UI routes (`/mock-api/**`, `/traffic/**`, `/admin/**`, `/`) +- **Implementation**: `authIntrospectionMiddleware` validates tokens via central auth gateway + +### API-Specific Authentication (Dynamic APIs) + +- **Purpose**: Allows each API endpoint to define its own authentication requirements +- **Mechanism**: Configurable authentication types per API +- **Scope**: All dynamic API routes (`/api/**`) +- **Implementation**: `dynamicApiAuthMiddleware` validates based on API configuration + +## Authentication Types for APIs + +### 1. None (`none`) +No authentication required - open endpoint. + +### 2. Bearer Token (`bearer`) +``` +Authorization: Bearer +``` +- Configure: Set `auth.type = "bearer"` and `auth.token = "your-token"` + +### 3. API Key (`api_key`) +Header-based: +``` +X-API-Key: +``` +Query parameter-based: +``` +GET /api/endpoint?api_key= +``` +- Configure: Set `auth.type = "api_key"`, `auth.apiKey = "your-key"` +- Optional: `auth.headerName` (default: "X-API-Key"), `auth.apiKeyInQuery` (default: false) + +### 4. Basic Authentication (`basic`) +``` +Authorization: Basic +``` +- Configure: Set `auth.type = "basic"`, `auth.username`, `auth.password` + +### 5. JWT Token (`jwt`) +``` +Authorization: Bearer +``` +- Configure: Set `auth.type = "jwt"`, `auth.token = "jwt-token"` +- Note: Simplified validation - for full JWT validation, extend the middleware + +### 6. Custom Header (`custom_header`) +``` +X-Custom-Auth: +``` +- Configure: Set `auth.type = "custom_header"`, `auth.headerName`, `auth.headerValue` + +### 7. OAuth/Client Credentials (`oauth`, `client_credentials`) +``` +Authorization: Bearer +``` +- Configure: Set `auth.type = "oauth"`, `auth.token`, optional `auth.allowedScopes` + +## Configuration + +### Route-Based Configuration + +Edit `src/config/auth.ts` to customize which routes use which authentication strategy: + +```typescript +export const authConfig: AuthConfig = { + central: { + gatewayUrl: "http://localhost:8888", + protectedRoutes: [ + "/mock-api/**", // API management UI + "/traffic/**", // Traffic monitoring UI + "/admin/**", // Admin UI + "/" // Dashboard + ], + publicRoutes: [ + "/login", + "/logout", + "/callback", + "/health", + "/static/**" + ] + }, + api: { + patterns: [ + "/api/**" // All dynamic APIs + ], + defaultBehavior: 'allow' + }, + routing: { + bypassCentralAuth: [ + "/api/**" // APIs bypass central auth + ], + requireCentralAuth: [ + "/mock-api/**", // UI always needs central auth + "/traffic/**", + "/admin/**" + ] + } +}; +``` + +### API-Specific Configuration + +Each API endpoint can be configured with its own authentication: + +```typescript +// Example API configuration +const apiConfig = { + id: "user-api", + path: "/users", + method: "GET", + auth: { + type: "api_key", + apiKey: "secret-key-123", + headerName: "X-API-Key", + apiKeyInQuery: false + }, + // ... other config +}; +``` + +## Implementation Details + +### Middleware Chain + +1. **Routing Auth Middleware** (`routingAuthMiddleware`) + - Determines authentication strategy based on route + - Applies central auth only to UI routes + - Bypasses central auth for API routes + +2. **Require Auth Middleware** (`requireAuthMiddleware`) + - Enforces authentication requirements + - Redirects unauthenticated users to login for UI routes + - Skips enforcement for API routes (handled separately) + +3. **Dynamic API Auth Middleware** (`dynamicApiAuthMiddleware`) + - Called only for API routes + - Validates authentication based on API configuration + - Returns 401 if authentication fails + +### Request Flow + +#### UI Route Request +``` +Request → Routing Auth → Central Auth Check → Require Auth → Route Handler +``` + +#### API Route Request +``` +Request → Routing Auth (bypass) → API Handler → Dynamic API Auth → Response +``` + +## Security Considerations + +### UI Routes +- Always protected by central authentication +- Session-based authentication with Auth0 integration +- Automatic redirect to login for unauthenticated users +- HTMX-compatible authentication flow + +### API Routes +- Authentication method defined per API +- No session requirements - stateless authentication +- Configurable authentication strength per endpoint +- Support for multiple authentication schemes + +### Token Management +- Central auth uses session cookies and JWT tokens +- API auth uses various token types based on configuration +- No token sharing between central and API authentication + +## Examples + +### Creating an API with Bearer Token Auth + +```typescript +const api = await repo.createApi({ + path: "/secure-data", + method: "GET", + auth: { + type: "bearer", + token: "my-secret-bearer-token" + }, + response: { + type: "json", + data: { message: "Secure data" } + } +}); +``` + +### Making Authenticated API Requests + +```bash +# Bearer token +curl -H "Authorization: Bearer my-secret-bearer-token" \ + http://localhost:8000/api/secure-data + +# API Key in header +curl -H "X-API-Key: my-api-key" \ + http://localhost:8000/api/data + +# API Key in query +curl "http://localhost:8000/api/data?api_key=my-api-key" + +# Basic auth +curl -u username:password \ + http://localhost:8000/api/protected +``` + +## Monitoring and Logging + +### Authentication Events +- Central auth events logged with `[Introspect]` prefix +- API auth events logged with `[API Auth]` prefix +- Routing decisions logged with `[Routing]` prefix + +### Traffic Logs +- All API requests logged with authentication timing +- Auth failures recorded with error details +- Performance metrics include auth overhead + +### Debugging +- Enable detailed logging by checking console output +- Authentication failures include specific error messages +- Timing information available for performance analysis + +## Migration from Previous System + +The new system maintains backward compatibility: + +1. **Existing UI routes**: Continue using central authentication automatically +2. **Existing API configurations**: Honor existing authentication settings +3. **New APIs**: Can use any supported authentication type + +No changes required to existing API configurations or client code. + +## Benefits + +1. **Separation of Concerns**: UI and API authentication are independent +2. **Flexibility**: Each API can define its own security requirements +3. **Scalability**: APIs can be consumed without central authentication overhead +4. **Security**: UI remains protected while APIs are configurable +5. **Compliance**: Different authentication strengths for different data sensitivity levels \ No newline at end of file diff --git a/README_AUTH.md b/README_AUTH.md new file mode 100644 index 0000000..d8a47a7 --- /dev/null +++ b/README_AUTH.md @@ -0,0 +1,154 @@ +# Autenticação e Autorização Centralizada com Auth0 + +Este documento descreve a arquitetura, as melhores práticas e os passos de integração do Auth0 como mecanismo de autenticação e autorização para todo o portfólio de aplicações (internas e externas) da empresa. + +## 1. Visão Geral + +- **Auth0 como Provedor de Identidade (IDP):** Será responsável pela autenticação (AuthN) e autorização (AuthZ) centralizadas. +- **Tenants Separados:** + - Tenant Corporativo: para aplicações internas e SSO de funcionários. + - Tenant de Clientes: para a SaaS LIS, isolando dados e configurações de segurança. +- **Universal Login:** Uso do Universal Login customizado para garantir experiência única e marca consistente. +- **API Gateway de Autenticação:** Camada intermediária que expõe apenas as operações necessárias (login, refresh, gestão de usuários, atribuição de roles) e valida tokens. + +## 2. Estrutura de Tenants + +| Tenant | Finalidade | Domínio Customizado | +|---------------------|------------------------------------|--------------------------------| +| Corporativo | Aplicações internas e SSO | auth.empresa.com | +| Clientes (SaaS LIS) | Clientes externos da SaaS | auth.lis.empresa.com | + +## 3. Fluxo de Autenticação + +1. O cliente (SPA, Mobile, .NET, etc.) redireciona o usuário para o Universal Login. +2. Auth0 autentica e decide em qual tenant operar (baseado em domínio, parâmetros ou subdomínio). +3. O Auth0 retorna o ID Token e o Access Token ao cliente. +4. O cliente inclui o Access Token nas requisições ao API Gateway. +5. O Gateway valida o token (verifica assinatura, expiração, escopos e roles). +6. O Gateway aplica RBAC via middleware e encaminha a chamada aos microserviços. + +## 4. Camada de API Gateway + +- **EndPoints Expostos:** + - `/login`: inicia fluxo OIDC (redirect). + - `/logout`: encerra a sessão. + - `/refresh`: renova tokens (refresh tokens rotativos). + - `/users`: criação, atualização, remoção de usuários. + - `/roles`: atribuição e remoção de roles. + - `/introspect`: introspecção de tokens. +- **Responsabilidades:** + - Encapsular a Management API do Auth0. + - Aplicar políticas de segurança (rate limit, CORS, etc.). + - Fornecer SDK cliente leve (JS/TS, .NET, etc.) para integração. + +## 5. Integração de Clientes + +### 5.1 TypeScript / React + +```ts +import createAuth0Client from '@auth0/auth0-spa-js'; + +const auth0 = await createAuth0Client({ + domain: 'auth.empresa.com', + client_id: 'CLIENT_ID', + redirect_uri: window.location.origin, + audience: 'API_GATEWAY_AUDIENCE', +}); + +// Exemplo de login +await auth0.loginWithRedirect(); + +// Após callback, obtém token silenciosamente +const token = await auth0.getTokenSilently(); +``` + +### 5.2 .NET Core 6+ + +```csharp +builder.Services.AddAuth0WebAppAuthentication(options => { + options.Domain = "auth.empresa.com"; + options.ClientId = Configuration["Auth0:ClientId"]; + options.ClientSecret = Configuration["Auth0:ClientSecret"]; + options.Scope = "openid profile email"; +}); + +// Protegendo APIs: +builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) + .AddJwtBearer(options => { + options.Authority = "https://auth.empresa.com/"; + options.Audience = "API_GATEWAY_AUDIENCE"; + }); +``` + +## 6. Gerenciamento de Sessões e Tokens + +- **Access Tokens Curto Prazo:** 5-15 minutos. +- **Refresh Tokens Rotativos:** habilitar Refresh Token Rotation. +- **Armazenamento Seguro:** usar cookies HTTP-only e same-site=strict ou storage seguro. +- **Timeouts:** configurar idle timeout e absolute timeout no Auth0. + +## 7. RBAC e Permissões + +- Definir Roles e Permissões no painel do Auth0. +- Incluir claims de roles em `app_metadata.roles` no ID/Access Token. +- No Gateway, usar middleware para verificar roles antes de permitir o acesso. + +## 8. Regras e Extensões + +- **MFA:** obrigatório para contas administrativas. +- **Actions:** personalizar o fluxo (ex.: adicionar claims, sincronizar dados). +- **Logs e Monitoramento:** configurar alertas e Webhooks. + +## 9. Referências + +- https://auth0.com/docs +- https://auth0.com/docs/architecture +- https://auth0.com/docs/quickstart + +--- + +> Para visualizar o diagrama de arquitetura, veja `docs/auth_architecture.mmd`. + +## 10. Gerenciamento de Aplicações Clientes + +Nesta interface de administração, você pode gerenciar as aplicações internas que consumirão nosso sistema de autenticação central: + +- **Acessar o menu "Apps"**: no menu principal, clique em "Apps" para ver a lista de aplicações registradas. +- **Criar Novo App**: informe o nome da aplicação, uma descrição opcional e as URLs de callback (separadas por vírgula). O sistema criará um `Client ID` e um `Client Secret`. +- **Visualizar Credenciais**: após a criação, será exibido o `Client Secret` apenas uma vez. Guarde-o em local seguro. +- **Editar App**: atualize nome, descrição ou URLs de callback. +- **Excluir App**: remova o acesso de uma aplicação, invalidando seu `Client ID` e `Client Secret`. + +### Exemplos de Integração de Apps Internas + +#### Deno (Hono) +```ts +import { Hono } from "hono/mod.ts"; + +const app = new Hono(); + +app.get("/login", (c) => { + // Redireciona para o provedor de autenticação central, passando return_to + const redirectTo = encodeURIComponent("https://minha-app-frontend.com/callback"); + return c.redirect(`/login?return_to=${redirectTo}`); +}); + +app.get("/callback", async (c) => { + // Após o callback, o usuário será redirecionado de volta ao URL configurado em return_to + return c.text("Autenticado com sucesso!"); +}); +``` + +#### HTMX +```html + +``` + +> **Nota:** Em suas aplicações, use sempre o `Client ID` cadastrado e configure o callback no provedor de autenticação para corresponder à URL utilizada. + +Auth server is running in localhost:8888 \ No newline at end of file diff --git a/README_AUTHENTICATION_ARCHITECTURE.md b/README_AUTHENTICATION_ARCHITECTURE.md new file mode 100644 index 0000000..9b5624e --- /dev/null +++ b/README_AUTHENTICATION_ARCHITECTURE.md @@ -0,0 +1,310 @@ +# Authentication Architecture - Clean Separation of API and UI Authentication + +This document describes the robust authentication architecture implemented to ensure proper separation between API authentication (which returns HTTP errors) and UI authentication (which redirects to login screens). + +## Architecture Overview + +The system implements a **dual authentication strategy** with strict separation of concerns: + +### 🔒 **UI Authentication (Pages/Screens)** +- **Purpose**: Protects administrative interfaces, dashboards, and management screens +- **Mechanism**: Central authentication via Auth0 integration +- **Behavior**: Redirects unauthenticated users to login screens +- **Scope**: `/mock-api/**`, `/traffic/**`, `/admin/**`, `/` + +### 🔑 **API Authentication (Dynamic Endpoints)** +- **Purpose**: Protects individual API endpoints with configurable authentication +- **Mechanism**: Dynamic authentication based on each API's configuration +- **Behavior**: Returns HTTP 401/403 errors for authentication failures +- **Scope**: `/api/**`, `/rest/api/**` + +## Key Principles + +### 1. **Strict Route Separation** +- API routes NEVER trigger login redirects +- UI routes NEVER return plain HTTP errors without redirects +- Each route type has dedicated authentication flows + +### 2. **Clean Architecture** +- Authentication logic is encapsulated in dedicated services +- Middleware follows single responsibility principle +- Clear separation of authentication concerns + +### 3. **Security-First Design** +- APIs use stateless authentication (no sessions) +- UI uses session-based authentication +- No cross-contamination between authentication methods + +## Implementation Details + +### Authentication Service Layer + +#### `ApiAuthService` +```typescript +class ApiAuthService { + async authenticate(context: Context, api: MockApi): Promise +} +``` + +**Responsibilities:** +- Validates API-specific authentication methods +- Returns structured results (success/error/statusCode/timing) +- Supports multiple authentication types (Bearer, API Key, Basic, JWT, OAuth, etc.) + +### Middleware Layer + +#### 1. `apiRouteProtectionMiddleware` +**Purpose**: Prevents any accidental redirects on API endpoints +```typescript +// Safety net - overrides redirect behavior for API routes +c.redirect = (url: string) => c.json({ error: 'Unauthorized' }, { status: 401 }) +``` + +#### 2. `routingAuthMiddleware` +**Purpose**: Determines authentication strategy based on route +```typescript +if (shouldBypassCentralAuth(path)) { + c.set('isApiRoute', true) // Mark as API route +} else { + c.set('isApiRoute', false) // Mark as UI route + await authIntrospectionMiddleware(c, next) +} +``` + +#### 3. `requireAuthMiddleware` +**Purpose**: Enforces authentication requirements with proper behavior +```typescript +if (isApiRoute) { + // Skip central auth - APIs handle their own + await next() +} else { + // Check authentication and redirect if needed + if (!isAuthenticated) return c.redirect('/login') +} +``` + +#### 4. `dynamicApiAuthMiddleware` +**Purpose**: Handles API-specific authentication +```typescript +const authService = new ApiAuthService() +const result = await authService.authenticate(c, api) +if (!result.success) { + return c.json({ error: 'Unauthorized' }, { status: result.statusCode }) +} +``` + +## Authentication Flow Diagrams + +### UI Route Authentication Flow +``` +Request → API Protection → Routing Auth → Central Auth → Require Auth → UI Handler + ↓ ↓ ↓ ↓ + Skip if UI Apply central Introspect Redirect if + auth for UI token unauthenticated +``` + +### API Route Authentication Flow +``` +Request → API Protection → Routing Auth → API Handler → Dynamic API Auth → Response + ↓ ↓ ↓ ↓ + Override redirect Skip central Find API Validate per + for API routes auth for APIs config API config +``` + +## Supported API Authentication Types + +### 1. **None** (`auth.type: 'none'`) +```javascript +// No authentication required +fetch('/api/public-endpoint') +``` + +### 2. **Bearer Token** (`auth.type: 'bearer'`) +```javascript +fetch('/api/secure-endpoint', { + headers: { + 'Authorization': 'Bearer your-token-here' + } +}) +``` + +### 3. **API Key** (`auth.type: 'api_key'`) +```javascript +// Header-based +fetch('/api/secure-endpoint', { + headers: { + 'X-API-Key': 'your-api-key' + } +}) + +// Query parameter-based +fetch('/api/secure-endpoint?api_key=your-api-key') +``` + +### 4. **Basic Authentication** (`auth.type: 'basic'`) +```javascript +fetch('/api/secure-endpoint', { + headers: { + 'Authorization': 'Basic ' + btoa('username:password') + } +}) +``` + +### 5. **JWT Token** (`auth.type: 'jwt'`) +```javascript +fetch('/api/secure-endpoint', { + headers: { + 'Authorization': 'Bearer your-jwt-token' + } +}) +``` + +### 6. **Custom Header** (`auth.type: 'custom_header'`) +```javascript +fetch('/api/secure-endpoint', { + headers: { + 'X-Custom-Auth': 'your-custom-value' + } +}) +``` + +### 7. **OAuth/Client Credentials** (`auth.type: 'oauth'`) +```javascript +fetch('/api/secure-endpoint', { + headers: { + 'Authorization': 'Bearer your-oauth-token' + } +}) +``` + +## Configuration Examples + +### Creating an API with Authentication +```typescript +const apiConfig = { + path: "/users", + method: "GET", + auth: { + type: "api_key", + apiKey: "secret-key-123", + headerName: "X-API-Key", + apiKeyInQuery: false + }, + response: { + type: "json", + data: { users: [] } + } +} +``` + +### Route Configuration +```typescript +// src/config/auth.ts +export const authConfig = { + central: { + protectedRoutes: ["/mock-api/**", "/traffic/**", "/admin/**"], + publicRoutes: ["/login", "/static/**"] + }, + api: { + patterns: ["/api/**", "/rest/api/**"], + defaultBehavior: 'allow' + }, + routing: { + bypassCentralAuth: ["/api/**", "/rest/api/**"], + requireCentralAuth: ["/mock-api/**", "/traffic/**"] + } +} +``` + +## Error Handling + +### API Authentication Errors +```json +{ + "error": "Unauthorized", + "message": "Bearer token required in Authorization header", + "timestamp": "2023-10-01T12:00:00Z", + "path": "/api/secure-endpoint", + "method": "POST" +} +``` + +### UI Authentication Errors +- **HTMX Requests**: `HX-Redirect` header to login page +- **Regular Requests**: HTTP 302 redirect to login page + +## Security Considerations + +### API Security +- ✅ Stateless authentication (no server-side sessions) +- ✅ Configurable authentication per endpoint +- ✅ Support for multiple authentication schemes +- ✅ Detailed error messages for debugging +- ✅ Request/response logging for audit trails + +### UI Security +- ✅ Session-based authentication with Auth0 +- ✅ Automatic token introspection +- ✅ Secure cookie handling +- ✅ HTMX-compatible authentication flow + +### General Security +- ✅ No authentication method cross-contamination +- ✅ Strict route-based access control +- ✅ Comprehensive logging and monitoring +- ✅ Protection against accidental redirects on APIs + +## Testing Authentication + +### Testing API Endpoints +```bash +# Test Bearer token authentication +curl -H "Authorization: Bearer valid-token" \ + http://localhost:8000/api/secure-endpoint + +# Test API key authentication +curl -H "X-API-Key: valid-api-key" \ + http://localhost:8000/api/secure-endpoint + +# Test unauthenticated request (should return 401) +curl http://localhost:8000/api/secure-endpoint +``` + +### Testing UI Routes +```bash +# Test authenticated access (should redirect to login) +curl -i http://localhost:8000/mock-api + +# Test with valid session (should return 200) +curl -i -H "Cookie: session=valid-session-token" \ + http://localhost:8000/mock-api +``` + +## Monitoring and Debugging + +### Log Patterns +- `[API Protection]`: API route protection middleware +- `[Routing]`: Route-based authentication decisions +- `[Auth]`: UI authentication checks +- `[API Auth Service]`: API authentication attempts +- `[Introspect]`: Central authentication introspection + +### Common Issues + +#### Issue: API returning login redirects +**Solution**: Check that route is properly configured in `bypassCentralAuth` + +#### Issue: UI not redirecting to login +**Solution**: Verify route is in `requireCentralAuth` configuration + +#### Issue: Authentication not working +**Solution**: Check API configuration and ensure proper headers/tokens + +## Conclusion + +This architecture ensures: +- 🔒 **Complete separation** of API and UI authentication +- 🚫 **No accidental redirects** on API endpoints +- ✅ **Proper HTTP errors** for API authentication failures +- 🔄 **Seamless login flow** for UI authentication +- 🏗️ **Clean, maintainable code** following SOLID principles \ No newline at end of file diff --git a/README_CHUNKING_FIX.md b/README_CHUNKING_FIX.md new file mode 100644 index 0000000..62810d9 --- /dev/null +++ b/README_CHUNKING_FIX.md @@ -0,0 +1,123 @@ +# Traffic Log Chunking Fix + +## Problem Resolved + +Fixed the "Value too large (max 65536 bytes)" error that occurred when calling exposed APIs via Postman. The error was happening when storing traffic logs in Deno KV because large API responses were exceeding the storage limit. + +## Root Cause + +- **Issue**: Traffic logs containing large API responses (>65KB) couldn't be stored in Deno KV +- **Location**: `MockApiRepository.storeTrafficLog()` method in `src/services/mockApiService.ts` +- **Impact**: API calls with large responses were failing with 500 errors + +## Solution Implemented + +### 1. **Traffic Log Chunking** +- Extended the existing chunking mechanism to traffic logs +- Large response bodies are automatically chunked into smaller pieces +- Chunks are stored separately and reassembled when retrieved + +### 2. **Smart Chunking Strategy** +```typescript +// Three-tier approach: +1. Normal storage: Logs < 65KB stored normally +2. Response chunking: Large response bodies (>32KB) are chunked +3. Truncation fallback: Other large data is truncated if chunking doesn't help +``` + +### 3. **Automatic Reconstruction** +- Traffic logs are automatically reconstructed when retrieved +- No changes needed to existing UI or API consumers +- Transparent to users - they see complete data + +## Technical Details + +### Storage Strategy +```typescript +// Large response body chunking +if (responseBodySize > MAX_VALUE_SIZE / 2) { + // Split response into chunks + const chunks = ChunkingUtils.chunkResponseData(responseBody); + // Store chunks separately with keys like: traffic-{logId}:0, traffic-{logId}:1 +} +``` + +### Retrieval Strategy +```typescript +// Automatic reconstruction in getTrafficLogs() +private async reconstructTrafficLog(log: TrafficLog): Promise { + if (log.response.body.__chunked) { + // Retrieve and combine all chunks + return reconstructedLog; + } + return log; // Return as-is if not chunked +} +``` + +### Cleanup Strategy +```typescript +// Traffic log cleanup includes chunk cleanup +async clearTrafficLogs(): Promise { + // Delete main logs AND their associated chunks +} +``` + +## Benefits + +1. **No More 500 Errors**: Large API responses no longer cause storage failures +2. **Transparent Operation**: Users see complete data without knowing about chunking +3. **Automatic Fallback**: Multiple strategies ensure data is always stored +4. **Performance Optimized**: Only chunks data when necessary +5. **Memory Efficient**: Doesn't load all chunks unless needed + +## What's Fixed + +- ✅ **Large API responses** can now be logged without errors +- ✅ **Traffic monitoring** works for all API sizes +- ✅ **Postman calls** to large-response APIs now succeed +- ✅ **Performance metrics** are captured for all requests +- ✅ **Debugging capabilities** maintained for large responses + +## Configuration + +The chunking is automatic and requires no configuration: + +```typescript +// Constants in mockApiService.ts +const MAX_VALUE_SIZE = 60000; // Conservative limit below 65536 +const CHUNK_SIZE = 50000; // Chunk size for large data +``` + +## Monitoring + +Look for these log messages to see chunking in action: + +``` +Traffic log {id} is too large ({size} bytes), chunking response body... +Cleaned up {count} chunks for traffic log {id} +Missing chunk for traffic log: {chunkKey} +``` + +## Before vs After + +### Before (Failing) +``` +TypeError: Value too large (max 65536 bytes) + at MockApiRepository.storeTrafficLog +``` + +### After (Working) +``` +✅ Traffic log stored successfully (chunked into 3 parts) +✅ API response: 200 OK +✅ Performance metrics captured +``` + +## Backward Compatibility + +- ✅ **Existing traffic logs**: Continue working normally +- ✅ **Small responses**: No change in behavior +- ✅ **API contracts**: No breaking changes +- ✅ **UI components**: Show complete data transparently + +The fix is production-ready and handles edge cases gracefully. \ No newline at end of file diff --git a/README_CROSS_ORIGIN_AUTH.md b/README_CROSS_ORIGIN_AUTH.md new file mode 100644 index 0000000..2a3adda --- /dev/null +++ b/README_CROSS_ORIGIN_AUTH.md @@ -0,0 +1,173 @@ +# Cross-Origin API Authentication Bypass + +## Problem Solved + +Fixed the issue where API calls from external domains (like Postman, third-party applications, or other websites) were still requiring authentication when they should be publicly accessible. + +## Overview + +The system now supports **automatic authentication bypass** for cross-origin API requests, allowing external applications to call your exposed APIs without requiring any authentication tokens. + +## Key Features + +### 1. **Cross-Origin Detection** +- Automatically detects when API calls come from different domains +- Compares `Origin` header with `Host` header +- Bypasses API authentication for cross-origin requests + +### 2. **External Domain Bypass** +- Configurable trusted domains that don't require authentication +- Supports wildcard domain matching (`*.example.com`) +- Default configuration trusts all domains (`*`) + +### 3. **Flexible Configuration** +```typescript +// src/config/auth.ts +api: { + skipAuthForCrossOrigin: true, // Skip auth for cross-origin requests + skipAuthForExternalDomains: true, // Skip auth for external domains + trustedDomains: ['*'] // Trust all domains (or specify specific ones) +} +``` + +## How It Works + +### Before (Problematic) +``` +External Request → API Endpoint → API Authentication Check → ❌ 401 Unauthorized +``` + +### After (Fixed) +``` +External Request → API Endpoint → Cross-Origin Check → ✅ Skip Auth → Success +``` + +## Configuration Options + +### Trust All Domains (Default) +```typescript +api: { + trustedDomains: ['*'] // Allow any external domain +} +``` + +### Trust Specific Domains +```typescript +api: { + trustedDomains: [ + 'postman.com', + 'your-app.com', + '*.trusted-domain.com' + ] +} +``` + +### Disable Cross-Origin Bypass +```typescript +api: { + skipAuthForCrossOrigin: false, + skipAuthForExternalDomains: false +} +``` + +## Detection Logic + +The system uses multiple methods to detect external requests: + +1. **Origin Header**: Compares request origin with host +2. **Referer Header**: Checks if request comes from external site +3. **Domain Matching**: Validates against trusted domain list + +## Use Cases + +### ✅ **Postman/Insomnia Testing** +- No need to configure authentication tokens +- Direct API testing without setup + +### ✅ **Third-Party Integrations** +- External applications can consume APIs directly +- No authentication overhead for public APIs + +### ✅ **JavaScript/AJAX Calls** +- Cross-origin web applications can call APIs +- No CORS authentication issues + +### ✅ **Mobile Applications** +- Native mobile apps can call APIs without tokens +- Simplified integration for external developers + +## Security Considerations + +### UI Routes Still Protected +- Administrative interfaces remain protected by central Auth0 +- Only API endpoints can bypass authentication +- Full separation between UI and API security + +### Configurable Trust Levels +- Can restrict to specific domains if needed +- Wildcard support for domain families +- Easy to disable if not needed + +### Internal Requests Still Validated +- Same-origin requests still follow API authentication rules +- Only external/cross-origin requests bypass auth +- Maintains security for internal API usage + +## Logging + +Monitor cross-origin authentication bypass with these log messages: + +``` +[API Auth] Skipping authentication for cross-origin/external request +[API Auth] Request URL=..., Auth type=bearer +``` + +## Examples + +### Postman Request +```bash +# No authentication headers needed for cross-origin calls +curl https://mockapi.iliberty.com.br/api/rest/v1/wsemisdoctofunc +``` + +### JavaScript Cross-Origin +```javascript +// External website calling your API +fetch('https://mockapi.iliberty.com.br/api/data') + .then(response => response.json()) + .then(data => console.log(data)); +``` + +### Mobile App Integration +```swift +// iOS app calling API without authentication +let url = URL(string: "https://mockapi.iliberty.com.br/api/users")! +URLSession.shared.dataTask(with: url) { data, response, error in + // Handle response +}.resume() +``` + +## Migration + +### Automatic +- Existing API configurations work unchanged +- Cross-origin bypass is automatically enabled +- No breaking changes to existing functionality + +### Customization +If you need tighter security: + +1. Edit `src/config/auth.ts` +2. Set `skipAuthForCrossOrigin: false` +3. Configure specific `trustedDomains` +4. Restart the application + +## Benefits + +1. **Simplified Integration**: External applications don't need authentication setup +2. **Better Testing**: Postman and similar tools work out of the box +3. **Wider Adoption**: Easier for third parties to consume your APIs +4. **Flexible Security**: Can be configured per deployment environment +5. **Maintained Protection**: UI screens remain fully protected + +The system now correctly distinguishes between UI access (always protected) and API access (configurable per request origin). \ No newline at end of file diff --git a/README_REST_API_FIX.md b/README_REST_API_FIX.md new file mode 100644 index 0000000..50aef81 --- /dev/null +++ b/README_REST_API_FIX.md @@ -0,0 +1,90 @@ +# REST API Route Fix + +## Problem +External applications were unable to call API endpoints with paths like `/rest/api/v1/wsemisdoctofunc` because the system was treating these routes as UI routes requiring central authentication, instead of API routes that should bypass central auth. + +## Root Cause +The authentication configuration and route handlers only supported `/api/*` patterns but not `/rest/api/*` patterns. When a request came to `/rest/api/v1/wsemisdoctofunc`, it was: + +1. **Treated as central auth route**: The routing middleware classified it as requiring central authentication +2. **Missing route handler**: No handler existed for `/rest/api/*` paths +3. **Cross-origin bypass not working**: Since it wasn't classified as an API route, cross-origin bypass didn't apply + +## Solution +Extended the authentication system to support both `/api/*` and `/rest/api/*` patterns: + +### 1. Updated Authentication Configuration (`src/config/auth.ts`) +```typescript +// Added /rest/api/** to API patterns +api: { + patterns: [ + "/api/**", + "/rest/api/**" // <- Added this + ], + // ... rest of config +}, + +// Added /rest/api/** to bypass central auth +routing: { + bypassCentralAuth: [ + "/api/**", + "/rest/api/**" // <- Added this + ], + // ... rest of config +} +``` + +### 2. Added Route Handler (`src/main.tsx`) +Created a reusable `handleDynamicApiEndpoint` function and added a new route handler: + +```typescript +// New handler for /rest/api/* routes +app.all("/rest/api/*", async (c) => { + return await handleDynamicApiEndpoint(c, "/rest/api"); +}); +``` + +### 3. Updated Layout Middleware +Added `/rest/api/` to the list of paths that bypass the layout middleware: + +```typescript +if ( + path.startsWith('/api/') || + path.startsWith('/rest/api/') || // <- Added this + // ... other conditions +) { + await next(); +} +``` + +## Behavior After Fix +Now both path patterns work identically: + +- **`/api/auth/accesstoken`** ✅ Bypasses central auth, uses cross-origin bypass +- **`/rest/api/v1/wsemisdoctofunc`** ✅ Bypasses central auth, uses cross-origin bypass + +## Testing +External applications can now successfully call endpoints like: +- `POST /rest/api/v1/wsemisdoctofunc` +- `GET /rest/api/v2/someendpoint` +- Any `/rest/api/*` pattern + +The system will: +1. Skip central authentication +2. Apply cross-origin bypass (if configured) +3. Use the API's own authentication settings +4. Return proper responses without redirects + +## Log Output (Success) +``` +[Routing] Path: /rest/api/v1/wsemisdoctofunc, Strategy: api +[Routing] Route bypasses central auth: /rest/api/v1/wsemisdoctofunc +[API Auth] Skipping authentication for cross-origin/external request +``` + +vs. Previous (Failure): +``` +[Routing] Path: /rest/api/v1/wsemisdoctofunc, Strategy: central +[Routing] Applying central auth for: /rest/api/v1/wsemisdoctofunc +[Auth] Unauthenticated access to protected route: /rest/api/v1/wsemisdoctofunc +``` \ No newline at end of file diff --git a/README_TRAFFIC_LOG_FIX_V2.md b/README_TRAFFIC_LOG_FIX_V2.md new file mode 100644 index 0000000..239a01d --- /dev/null +++ b/README_TRAFFIC_LOG_FIX_V2.md @@ -0,0 +1,141 @@ +# Traffic Logging Fix V2 - Complete Solution + +## Problem +Large API responses (>65KB) were causing the entire API request to fail with "Value too large (max 65536 bytes)" errors, even though the API response was generated correctly. The issue was in the traffic logging system. + +## Root Cause Analysis +1. **API Response Working**: The API lookup and response generation worked perfectly +2. **Traffic Logging Failing**: Large responses (961KB in your case) exceeded Deno KV's 65KB limit +3. **Chunking Insufficient**: Even after chunking the response body, the traffic log metadata was still too large +4. **Blocking Failure**: Traffic logging failures were causing the entire API request to return 500 errors + +## Comprehensive Solution + +### 1. Enhanced Chunking Strategy (`src/services/mockApiService.ts`) + +**Three-Tier Approach:** +```typescript +// Tier 1: Minimal chunked log (remove unnecessary data) +const chunkedLog: TrafficLog = { + ...log, + response: { + status: log.response.status, + headers: log.response.headers, + body: { __chunked: true, chunkKeys: chunkKeys, ... } + }, + request: { + method: log.request.method, + path: log.request.path, + headers: {}, // Remove headers to save space + query: log.request.query, + body: truncatedRequestBody + } +}; + +// Tier 2: Ultra-minimal log (if Tier 1 still too large) +const minimalLog: TrafficLog = { + id: log.id, + timestamp: log.timestamp, + request: { method: log.request.method, path: log.request.path }, + response: { + status: log.response.status, + body: { __chunked: true, chunkKeys: chunkKeys } + }, + performance: log.performance +}; + +// Tier 3: Essential log (ultimate fallback) +const essentialLog = { + id: log.id, + timestamp: log.timestamp, + request: { method: log.request.method, path: log.request.path }, + response: { + status: log.response.status, + body: { __chunked: true, chunkKeys: chunkKeys } + } +}; +``` + +### 2. Non-Blocking Traffic Logging (`src/main.tsx`) + +**Critical Change**: Made traffic logging non-blocking so API responses work even if logging fails: + +```typescript +// Log traffic (non-blocking - don't let logging failures affect API response) +try { + await repo.storeTrafficLog({...}); +} catch (error) { + console.error(`Traffic logging failed for ${method} ${path}:`, error); + // Continue with API response even if logging fails +} +``` + +### 3. Deno Deploy Compatibility (`src/services/mockApiService.ts`) + +**Fixed Directory Creation**: Only attempt to create data directory in local development: + +```typescript +// In Deno Deploy, we don't need a data directory - KV is managed +// Only try to create directory in local development +if (!Deno.env.get("DENO_DEPLOYMENT_ID")) { + try { + await Deno.mkdir("./data", { recursive: true }); + } catch (e) { + console.warn("Could not create data directory (this is normal in Deno Deploy):", ...); + } +} +``` + +## Behavior After Fix + +### ✅ Success Scenarios +1. **Small responses (<65KB)**: Stored normally +2. **Medium responses (65KB-500KB)**: Response body chunked, minimal metadata stored +3. **Large responses (>500KB)**: Ultra-minimal log with chunked response body +4. **Extreme responses (>1MB)**: Essential log only, but API response still works + +### ✅ Failure Recovery +- If chunking fails → Try minimal log +- If minimal log fails → Try essential log +- If essential log fails → Log error but continue API response +- **API response always works** regardless of logging issues + +## Expected Log Output (Success) + +``` +Traffic log abc123 is too large (961448 bytes), chunking response body... +Chunked traffic log abc123 is still too large (128000 bytes), creating minimal log... +Saved essential traffic log abc123 +``` + +vs. Previous (Failure): +``` +Traffic log abc123 is too large (961448 bytes), chunking response body... +TypeError: Value too large (max 65536 bytes) +→ 500 Internal Server Error +``` + +## Testing Results + +Your API calls should now: +1. ✅ **Return proper responses** (200 OK with data) +2. ✅ **Work from external applications** (no more 500 errors) +3. ✅ **Log traffic when possible** (with chunking for large responses) +4. ✅ **Continue working even if logging fails** (non-blocking) + +## Performance Impact + +- **Minimal**: Only affects traffic logging, not API response generation +- **Smart chunking**: Only chunks when necessary +- **Graceful degradation**: Falls back to simpler logging if needed +- **Non-blocking**: API responses are never delayed by logging issues + +## Monitoring + +The system now provides detailed logging about chunking decisions: +- When chunking is applied +- When minimal logs are used +- When essential logs are used +- When logging fails (but API continues) + +This ensures you can monitor the health of your traffic logging system while maintaining 100% API availability. \ No newline at end of file diff --git a/data/mock-api-store b/data/mock-api-store new file mode 100644 index 0000000..4e86411 Binary files /dev/null and b/data/mock-api-store differ diff --git a/data/mock-api-store-shm b/data/mock-api-store-shm new file mode 100644 index 0000000..76987ca Binary files /dev/null and b/data/mock-api-store-shm differ diff --git a/data/mock-api-store-wal b/data/mock-api-store-wal new file mode 100644 index 0000000..5fa35cd Binary files /dev/null and b/data/mock-api-store-wal differ diff --git a/deno.json b/deno.json new file mode 100644 index 0000000..387b74c --- /dev/null +++ b/deno.json @@ -0,0 +1,41 @@ +{ + "tasks": { + "dev": "deno run --allow-net --allow-read --allow-write --unstable-kv src/main.tsx", + "debug": "deno run --unstable-kv --allow-all --inspect src/main.tsx", + "debug-brk": "deno run --unstable-kv --allow-all --inspect-brk src/main.tsx", + "start": "deno run --allow-net --allow-read --allow-write --allow-env --unstable-kv src/main.tsx", + "compile": "deno compile --allow-net --allow-read --allow-write --allow-env --unstable-kv --target x86_64-unknown-linux-gnu -o dist/server src/main.tsx", + "test": "deno test --allow-net --allow-read --allow-write --unstable-kv", + "deploy": "deployctl deploy --project=imockapi --unstable --watch src/main.tsx", + "deploy-ra5": "deployctl deploy --project=integrador-ra5 --unstable src/main.tsx", + "kv-list": "deno run --allow-read --allow-env --unstable-kv scripts/kv-list.ts", + "kv-get": "deno run --allow-read --allow-env --unstable-kv scripts/kv-get.ts", + "kv-inspect-log": "deno run --allow-read --allow-env --unstable-kv scripts/kv-inspect-log.ts", + "kv-list-logs": "deno run --allow-read --allow-env --unstable-kv scripts/kv-list-logs.ts", + "tailwind": "deno run -A npm:tailwindcss@3 -c tailwind.config.cjs -i ./static/input.css -o ./static/style.css" + }, + "imports": { + "oak/": "https://deno.land/x/oak@v17.1.4/", + "std/": "https://deno.land/std@0.202.0/", + "path-to-regexp": "https://deno.land/x/path_to_regexp@v6.2.1/index.ts", + "lz4": "https://deno.land/x/lz4@v0.1.3/mod.ts", + "ulid": "https://deno.land/x/ulid@v0.3.0/mod.ts", + "@hono/hono": "jsr:@hono/hono@^4", + "@hono/hono/": "jsr:@hono/hono@^4/", + "hono/": "https://deno.land/x/hono@v4.3.11/", + "hono/jsx": "https://deno.land/x/hono@v4.3.11/jsx/index.ts", + "hono/jsx/jsx-runtime": "https://deno.land/x/hono@v4.3.11/jsx/jsx-runtime.ts", + "hono/jsx-renderer": "https://deno.land/x/hono@v4.3.11/middleware/jsx-renderer/index.ts", + "hono/jsx-renderer/": "https://deno.land/x/hono@v4.3.11/middleware/jsx-renderer/" + }, + "compilerOptions": { + "jsx": "react-jsx", + "jsxImportSource": "hono/jsx" + }, + "deploy": { + "project": "api-gateway-new-iui", + "exclude": [], + "include": [], + "entrypoint": "src/main.tsx" + } +} \ No newline at end of file diff --git a/deno.jsonc b/deno.jsonc index 98e994d..415bafa 100644 --- a/deno.jsonc +++ b/deno.jsonc @@ -4,18 +4,50 @@ "lib": [ "deno.window" ], + "jsx": "react-jsx", + "jsxImportSource": "hono/jsx", "strict": true }, + "nodeModulesDir": true, + "importMap": "./import_map.json", "imports": { - "oak": "https://deno.land/x/oak@v12.6.1/mod.ts", - "oak/": "https://deno.land/x/oak@v12.6.1/" + "tailwindcss": "npm:tailwindcss@3", + "tailwindcss-animate": "npm:tailwindcss-animate@1.0.7", + "hono/": "https://deno.land/x/hono@v4.3.11/", + "hono/html.ts": "https://deno.land/x/hono@v4.3.11/helper/html/index.ts", + "hono/jsx-renderer.ts": "https://deno.land/x/hono@v4.3.11/middleware/jsx-renderer/index.ts", + "hono/jsx/index.ts": "https://deno.land/x/hono@v4.3.11/jsx/index.ts", + "hono/middleware.ts": "https://deno.land/x/hono@v4.3.11/middleware.ts", + "hono/mod.ts": "https://deno.land/x/hono@v4.3.11/mod.ts", + "hono/utils/html.ts": "https://deno.land/x/hono@v4.3.11/utils/html.ts", + "std/": "https://deno.land/std@0.224.0/" + }, + "tasks": { + "dev": "deno run -A npm:tailwindcss@3 -c tailwind.config.cjs -i ./static/input.css -o ./static/style.css && deno run --allow-net --allow-read --allow-env --allow-write --watch src/main.tsx", + "tailwind": "deno run -A npm:tailwindcss@3 -c tailwind.config.cjs -i ./static/input.css -o ./static/style.css --watch" }, "deploy": { - "project": "85b589c8-a15f-4d92-bc12-8b51ea285e3e", + "project": "YOUR_PROJECT_ID_HERE", + "entrypoint": "src/main.tsx", "exclude": [ - "**/node_modules" - ], - "include": [], - "entrypoint": "server.ts" + "node_modules/**", + "tailwind.config.cjs", + "static/input.css" + ] + }, + "lint": { + "rules": { + "tags": [ + "recommended" + ] + } + }, + "fmt": { + "options": { + "useTabs": false, + "lineWidth": 120, + "indentWidth": 2, + "singleQuote": true + } } } \ No newline at end of file diff --git a/deno.lock b/deno.lock index aae03de..1516c66 100644 --- a/deno.lock +++ b/deno.lock @@ -1,5 +1,5 @@ { - "version": "4", + "version": "5", "specifiers": { "jsr:@oak/commons@1": "1.0.0", "jsr:@std/assert@1": "1.0.9", @@ -13,7 +13,10 @@ "jsr:@std/media-types@1": "1.1.0", "jsr:@std/path@1": "1.0.8", "npm:@types/node@*": "22.5.4", - "npm:path-to-regexp@6.2.1": "6.2.1" + "npm:hono@*": "4.7.8", + "npm:path-to-regexp@6.2.1": "6.2.1", + "npm:tailwindcss-animate@1.0.7": "1.0.7_tailwindcss@3.4.17__postcss@8.5.3", + "npm:tailwindcss@3": "3.4.17_postcss@8.5.3" }, "jsr": { "@oak/commons@1.0.0": { @@ -59,23 +62,693 @@ } }, "npm": { + "@alloc/quick-lru@5.2.0": { + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==" + }, + "@isaacs/cliui@8.0.2": { + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dependencies": [ + "string-width@5.1.2", + "string-width-cjs@npm:string-width@4.2.3", + "strip-ansi@7.1.0", + "strip-ansi-cjs@npm:strip-ansi@6.0.1", + "wrap-ansi@8.1.0", + "wrap-ansi-cjs@npm:wrap-ansi@7.0.0" + ] + }, + "@jridgewell/gen-mapping@0.3.8": { + "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", + "dependencies": [ + "@jridgewell/set-array", + "@jridgewell/sourcemap-codec", + "@jridgewell/trace-mapping" + ] + }, + "@jridgewell/resolve-uri@3.1.2": { + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==" + }, + "@jridgewell/set-array@1.2.1": { + "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==" + }, + "@jridgewell/sourcemap-codec@1.5.0": { + "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==" + }, + "@jridgewell/trace-mapping@0.3.25": { + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "dependencies": [ + "@jridgewell/resolve-uri", + "@jridgewell/sourcemap-codec" + ] + }, + "@nodelib/fs.scandir@2.1.5": { + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dependencies": [ + "@nodelib/fs.stat", + "run-parallel" + ] + }, + "@nodelib/fs.stat@2.0.5": { + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==" + }, + "@nodelib/fs.walk@1.2.8": { + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dependencies": [ + "@nodelib/fs.scandir", + "fastq" + ] + }, + "@pkgjs/parseargs@0.11.0": { + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==" + }, "@types/node@22.5.4": { "integrity": "sha512-FDuKUJQm/ju9fT/SeX/6+gBzoPzlVCzfzmGkwKvRHQVxi4BntVbyIwf6a4Xn62mrvndLiml6z/UBXIdEVjQLXg==", "dependencies": [ "undici-types" ] }, + "ansi-regex@5.0.1": { + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "ansi-regex@6.1.0": { + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==" + }, + "ansi-styles@4.3.0": { + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": [ + "color-convert" + ] + }, + "ansi-styles@6.2.1": { + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==" + }, + "any-promise@1.3.0": { + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" + }, + "anymatch@3.1.3": { + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dependencies": [ + "normalize-path", + "picomatch" + ] + }, + "arg@5.0.2": { + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==" + }, + "balanced-match@1.0.2": { + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "binary-extensions@2.3.0": { + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==" + }, + "brace-expansion@2.0.1": { + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": [ + "balanced-match" + ] + }, + "braces@3.0.3": { + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dependencies": [ + "fill-range" + ] + }, + "camelcase-css@2.0.1": { + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==" + }, + "chokidar@3.6.0": { + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dependencies": [ + "anymatch", + "braces", + "glob-parent@5.1.2", + "is-binary-path", + "is-glob", + "normalize-path", + "readdirp" + ], + "optionalDependencies": [ + "fsevents" + ] + }, + "color-convert@2.0.1": { + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": [ + "color-name" + ] + }, + "color-name@1.1.4": { + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "commander@4.1.1": { + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==" + }, + "cross-spawn@7.0.6": { + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dependencies": [ + "path-key", + "shebang-command", + "which" + ] + }, + "cssesc@3.0.0": { + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "bin": true + }, + "didyoumean@1.2.2": { + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==" + }, + "dlv@1.1.3": { + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==" + }, + "eastasianwidth@0.2.0": { + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" + }, + "emoji-regex@8.0.0": { + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "emoji-regex@9.2.2": { + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + }, + "fast-glob@3.3.3": { + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dependencies": [ + "@nodelib/fs.stat", + "@nodelib/fs.walk", + "glob-parent@5.1.2", + "merge2", + "micromatch" + ] + }, + "fastq@1.19.1": { + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "dependencies": [ + "reusify" + ] + }, + "fill-range@7.1.1": { + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dependencies": [ + "to-regex-range" + ] + }, + "foreground-child@3.3.1": { + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dependencies": [ + "cross-spawn", + "signal-exit" + ] + }, + "fsevents@2.3.3": { + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "os": ["darwin"], + "scripts": true + }, + "function-bind@1.1.2": { + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==" + }, + "glob-parent@5.1.2": { + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": [ + "is-glob" + ] + }, + "glob-parent@6.0.2": { + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dependencies": [ + "is-glob" + ] + }, + "glob@10.4.5": { + "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", + "dependencies": [ + "foreground-child", + "jackspeak", + "minimatch", + "minipass", + "package-json-from-dist", + "path-scurry" + ], + "bin": true + }, + "hasown@2.0.2": { + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dependencies": [ + "function-bind" + ] + }, + "hono@4.7.8": { + "integrity": "sha512-PCibtFdxa7/Ldud9yddl1G81GjYaeMYYTq4ywSaNsYbB1Lug4mwtOMJf2WXykL0pntYwmpRJeOI3NmoDgD+Jxw==" + }, + "is-binary-path@2.1.0": { + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dependencies": [ + "binary-extensions" + ] + }, + "is-core-module@2.16.1": { + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dependencies": [ + "hasown" + ] + }, + "is-extglob@2.1.1": { + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==" + }, + "is-fullwidth-code-point@3.0.0": { + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==" + }, + "is-glob@4.0.3": { + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dependencies": [ + "is-extglob" + ] + }, + "is-number@7.0.0": { + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==" + }, + "isexe@2.0.0": { + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + }, + "jackspeak@3.4.3": { + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", + "dependencies": [ + "@isaacs/cliui" + ], + "optionalDependencies": [ + "@pkgjs/parseargs" + ] + }, + "jiti@1.21.7": { + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "bin": true + }, + "lilconfig@3.1.3": { + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==" + }, + "lines-and-columns@1.2.4": { + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==" + }, + "lru-cache@10.4.3": { + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==" + }, + "merge2@1.4.1": { + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==" + }, + "micromatch@4.0.8": { + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dependencies": [ + "braces", + "picomatch" + ] + }, + "minimatch@9.0.5": { + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dependencies": [ + "brace-expansion" + ] + }, + "minipass@7.1.2": { + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==" + }, + "mz@2.7.0": { + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "dependencies": [ + "any-promise", + "object-assign", + "thenify-all" + ] + }, + "nanoid@3.3.11": { + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "bin": true + }, + "normalize-path@3.0.0": { + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==" + }, + "object-assign@4.1.1": { + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==" + }, + "object-hash@3.0.0": { + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==" + }, + "package-json-from-dist@1.0.1": { + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==" + }, + "path-key@3.1.1": { + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==" + }, + "path-parse@1.0.7": { + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + }, + "path-scurry@1.11.1": { + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "dependencies": [ + "lru-cache", + "minipass" + ] + }, "path-to-regexp@6.2.1": { "integrity": "sha512-JLyh7xT1kizaEvcaXOQwOc2/Yhw6KZOvPf1S8401UyLk86CU79LN3vl7ztXGm/pZ+YjoyAJ4rxmHwbkBXJX+yw==" }, + "picocolors@1.1.1": { + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==" + }, + "picomatch@2.3.1": { + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==" + }, + "pify@2.3.0": { + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==" + }, + "pirates@4.0.7": { + "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==" + }, + "postcss-import@15.1.0_postcss@8.5.3": { + "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "dependencies": [ + "postcss", + "postcss-value-parser", + "read-cache", + "resolve" + ] + }, + "postcss-js@4.0.1_postcss@8.5.3": { + "integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==", + "dependencies": [ + "camelcase-css", + "postcss" + ] + }, + "postcss-load-config@4.0.2_postcss@8.5.3": { + "integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==", + "dependencies": [ + "lilconfig", + "postcss", + "yaml" + ], + "optionalPeers": [ + "postcss" + ] + }, + "postcss-nested@6.2.0_postcss@8.5.3": { + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "dependencies": [ + "postcss", + "postcss-selector-parser" + ] + }, + "postcss-selector-parser@6.1.2": { + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dependencies": [ + "cssesc", + "util-deprecate" + ] + }, + "postcss-value-parser@4.2.0": { + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" + }, + "postcss@8.5.3": { + "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==", + "dependencies": [ + "nanoid", + "picocolors", + "source-map-js" + ] + }, + "queue-microtask@1.2.3": { + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==" + }, + "read-cache@1.0.0": { + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dependencies": [ + "pify" + ] + }, + "readdirp@3.6.0": { + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dependencies": [ + "picomatch" + ] + }, + "resolve@1.22.10": { + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "dependencies": [ + "is-core-module", + "path-parse", + "supports-preserve-symlinks-flag" + ], + "bin": true + }, + "reusify@1.1.0": { + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==" + }, + "run-parallel@1.2.0": { + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dependencies": [ + "queue-microtask" + ] + }, + "shebang-command@2.0.0": { + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dependencies": [ + "shebang-regex" + ] + }, + "shebang-regex@3.0.0": { + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==" + }, + "signal-exit@4.1.0": { + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==" + }, + "source-map-js@1.2.1": { + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==" + }, + "string-width@4.2.3": { + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": [ + "emoji-regex@8.0.0", + "is-fullwidth-code-point", + "strip-ansi@6.0.1" + ] + }, + "string-width@5.1.2": { + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dependencies": [ + "eastasianwidth", + "emoji-regex@9.2.2", + "strip-ansi@7.1.0" + ] + }, + "strip-ansi@6.0.1": { + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": [ + "ansi-regex@5.0.1" + ] + }, + "strip-ansi@7.1.0": { + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dependencies": [ + "ansi-regex@6.1.0" + ] + }, + "sucrase@3.35.0": { + "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==", + "dependencies": [ + "@jridgewell/gen-mapping", + "commander", + "glob", + "lines-and-columns", + "mz", + "pirates", + "ts-interface-checker" + ], + "bin": true + }, + "supports-preserve-symlinks-flag@1.0.0": { + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==" + }, + "tailwindcss-animate@1.0.7_tailwindcss@3.4.17__postcss@8.5.3": { + "integrity": "sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==", + "dependencies": [ + "tailwindcss" + ] + }, + "tailwindcss@3.4.17_postcss@8.5.3": { + "integrity": "sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==", + "dependencies": [ + "@alloc/quick-lru", + "arg", + "chokidar", + "didyoumean", + "dlv", + "fast-glob", + "glob-parent@6.0.2", + "is-glob", + "jiti", + "lilconfig", + "micromatch", + "normalize-path", + "object-hash", + "picocolors", + "postcss", + "postcss-import", + "postcss-js", + "postcss-load-config", + "postcss-nested", + "postcss-selector-parser", + "resolve", + "sucrase" + ], + "bin": true + }, + "thenify-all@1.6.0": { + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "dependencies": [ + "thenify" + ] + }, + "thenify@3.3.1": { + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "dependencies": [ + "any-promise" + ] + }, + "to-regex-range@5.0.1": { + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dependencies": [ + "is-number" + ] + }, + "ts-interface-checker@0.1.13": { + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==" + }, "undici-types@6.19.8": { "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==" + }, + "util-deprecate@1.0.2": { + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + }, + "which@2.0.2": { + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dependencies": [ + "isexe" + ], + "bin": true + }, + "wrap-ansi@7.0.0": { + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": [ + "ansi-styles@4.3.0", + "string-width@4.2.3", + "strip-ansi@6.0.1" + ] + }, + "wrap-ansi@8.1.0": { + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dependencies": [ + "ansi-styles@6.2.1", + "string-width@5.1.2", + "strip-ansi@7.1.0" + ] + }, + "yaml@2.7.1": { + "integrity": "sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==", + "bin": true } }, "redirects": { "https://deno.land/x/oak/mod.ts": "https://deno.land/x/oak@v17.1.3/mod.ts" }, "remote": { + "https://deno.land/std@0.192.0/_util/asserts.ts": "178dfc49a464aee693a7e285567b3d0b555dc805ff490505a8aae34f9cfb1462", + "https://deno.land/std@0.192.0/async/abortable.ts": "fd682fa46f3b7b16b4606a5ab52a7ce309434b76f820d3221bdfb862719a15d7", + "https://deno.land/std@0.192.0/async/deadline.ts": "58f72a3cc0fcb731b2cc055ba046f4b5be3349ff6bf98f2e793c3b969354aab2", + "https://deno.land/std@0.192.0/async/debounce.ts": "adab11d04ca38d699444ac8a9d9856b4155e8dda2afd07ce78276c01ea5a4332", + "https://deno.land/std@0.192.0/async/deferred.ts": "42790112f36a75a57db4a96d33974a936deb7b04d25c6084a9fa8a49f135def8", + "https://deno.land/std@0.192.0/async/delay.ts": "73aa04cec034c84fc748c7be49bb15cac3dd43a57174bfdb7a4aec22c248f0dd", + "https://deno.land/std@0.192.0/async/mod.ts": "f04344fa21738e5ad6bea37a6bfffd57c617c2d372bb9f9dcfd118a1b622e576", + "https://deno.land/std@0.192.0/async/mux_async_iterator.ts": "70c7f2ee4e9466161350473ad61cac0b9f115cff4c552eaa7ef9d50c4cbb4cc9", + "https://deno.land/std@0.192.0/async/pool.ts": "f1b8d3df4d7fd3c73f8cbc91cc2e8b8e950910f1eab94230b443944d7584c657", + "https://deno.land/std@0.192.0/async/retry.ts": "6521c061a5ab24e8b1ae624bdc581c4243d1d574f99dc7f5a2a195c2241fb1b8", + "https://deno.land/std@0.192.0/async/tee.ts": "47e42d35f622650b02234d43803d0383a89eb4387e1b83b5a40106d18ae36757", + "https://deno.land/std@0.192.0/http/server.ts": "1b23463b5b36e4eebc495417f6af47a6f7d52e3294827a1226d2a1aab23d9d20", + "https://deno.land/std@0.193.0/_util/asserts.ts": "178dfc49a464aee693a7e285567b3d0b555dc805ff490505a8aae34f9cfb1462", + "https://deno.land/std@0.193.0/_util/os.ts": "d932f56d41e4f6a6093d56044e29ce637f8dcc43c5a90af43504a889cf1775e3", + "https://deno.land/std@0.193.0/async/abortable.ts": "fd682fa46f3b7b16b4606a5ab52a7ce309434b76f820d3221bdfb862719a15d7", + "https://deno.land/std@0.193.0/async/deadline.ts": "58f72a3cc0fcb731b2cc055ba046f4b5be3349ff6bf98f2e793c3b969354aab2", + "https://deno.land/std@0.193.0/async/debounce.ts": "adab11d04ca38d699444ac8a9d9856b4155e8dda2afd07ce78276c01ea5a4332", + "https://deno.land/std@0.193.0/async/deferred.ts": "42790112f36a75a57db4a96d33974a936deb7b04d25c6084a9fa8a49f135def8", + "https://deno.land/std@0.193.0/async/delay.ts": "73aa04cec034c84fc748c7be49bb15cac3dd43a57174bfdb7a4aec22c248f0dd", + "https://deno.land/std@0.193.0/async/mod.ts": "f04344fa21738e5ad6bea37a6bfffd57c617c2d372bb9f9dcfd118a1b622e576", + "https://deno.land/std@0.193.0/async/mux_async_iterator.ts": "70c7f2ee4e9466161350473ad61cac0b9f115cff4c552eaa7ef9d50c4cbb4cc9", + "https://deno.land/std@0.193.0/async/pool.ts": "f1b8d3df4d7fd3c73f8cbc91cc2e8b8e950910f1eab94230b443944d7584c657", + "https://deno.land/std@0.193.0/async/retry.ts": "b1ccf653954a4e52b3d9731e57d18b864e689a7462e78fb20440b11be9905080", + "https://deno.land/std@0.193.0/async/tee.ts": "47e42d35f622650b02234d43803d0383a89eb4387e1b83b5a40106d18ae36757", + "https://deno.land/std@0.193.0/bytes/copy.ts": "939d89e302a9761dcf1d9c937c7711174ed74c59eef40a1e4569a05c9de88219", + "https://deno.land/std@0.193.0/datetime/_common.ts": "f5c1cb784c616151a3d8198a4ab29f65b7fe5c20a105d8979bde9558c7b52910", + "https://deno.land/std@0.193.0/datetime/format.ts": "2d7a430ca9571e054ac181dcb950faf9ac23445e081dcb230ca37134e6eaad0c", + "https://deno.land/std@0.193.0/datetime/to_imf.ts": "8f9c0af8b167031ffe2e03da01a12a3b0672cc7562f89c61942a0ab0129771b2", + "https://deno.land/std@0.193.0/encoding/base64.ts": "144ae6234c1fbe5b68666c711dc15b1e9ee2aef6d42b3b4345bf9a6c91d70d0d", + "https://deno.land/std@0.193.0/http/_negotiation/common.ts": "14d1a52427ab258a4b7161cd80e1d8a207b7cc64b46e911780f57ead5f4323c6", + "https://deno.land/std@0.193.0/http/_negotiation/encoding.ts": "ff747d107277c88cb7a6a62a08eeb8d56dad91564cbcccb30694d5dc126dcc53", + "https://deno.land/std@0.193.0/http/_negotiation/language.ts": "7bcddd8db3330bdb7ce4fc00a213c5547c1968139864201efd67ef2d0d51887d", + "https://deno.land/std@0.193.0/http/_negotiation/media_type.ts": "58847517cd549384ad677c0fe89e0a4815be36fe7a303ea63cee5f6a1d7e1692", + "https://deno.land/std@0.193.0/http/cookie.ts": "934f92d871d50852dbd7a836d721df5a9527b14381db16001b40991d30174ee4", + "https://deno.land/std@0.193.0/http/cookie_map.ts": "d148a5eaf35f19905dd5104126fa47ac71105306dd42f129732365e43108b28a", + "https://deno.land/std@0.193.0/http/etag.ts": "6ad8abbbb1045aabf2307959a2c5565054a8bf01c9824ddee836b1ff22706a58", + "https://deno.land/std@0.193.0/http/http_errors.ts": "bbda34819060af86537cecc9dc8e045f877130808b7e7acde4197c5328e852d0", + "https://deno.land/std@0.193.0/http/http_status.ts": "8a7bcfe3ac025199ad804075385e57f63d055b2aed539d943ccc277616d6f932", + "https://deno.land/std@0.193.0/http/method.ts": "e66c2a015cb46c21ab0bb3589aa4fca43143a506cb324ffdfd42d2edef7bc0c4", + "https://deno.land/std@0.193.0/http/mod.ts": "525fb1b3b1e0d297facb08d8cf84c4908f8fadfc3f3f22809185510967279ef7", + "https://deno.land/std@0.193.0/http/negotiation.ts": "46e74a6bad4b857333a58dc5b50fe8e5a4d5267e97292293ea65f980bd918086", + "https://deno.land/std@0.193.0/http/server.ts": "1b23463b5b36e4eebc495417f6af47a6f7d52e3294827a1226d2a1aab23d9d20", + "https://deno.land/std@0.193.0/http/server_sent_event.ts": "1f3597d175e8935123306a24d7f4423a463667a70953d17b4115af1880459d55", + "https://deno.land/std@0.193.0/http/user_agent.ts": "6f4308670f261118cc6a1518bf37431a5b4f21322b4a4edf0963e182264ce404", + "https://deno.land/std@0.193.0/io/buffer.ts": "17f4410eaaa60a8a85733e8891349a619eadfbbe42e2f319283ce2b8f29723ab", + "https://deno.land/std@0.193.0/path/_constants.ts": "e49961f6f4f48039c0dfed3c3f93e963ca3d92791c9d478ac5b43183413136e0", + "https://deno.land/std@0.193.0/path/_interface.ts": "6471159dfbbc357e03882c2266d21ef9afdb1e4aa771b0545e90db58a0ba314b", + "https://deno.land/std@0.193.0/path/_util.ts": "d7abb1e0dea065f427b89156e28cdeb32b045870acdf865833ba808a73b576d0", + "https://deno.land/std@0.193.0/path/common.ts": "ee7505ab01fd22de3963b64e46cff31f40de34f9f8de1fff6a1bd2fe79380000", + "https://deno.land/std@0.193.0/path/glob.ts": "d479e0a695621c94d3fd7fe7abd4f9499caf32a8de13f25073451c6ef420a4e1", + "https://deno.land/std@0.193.0/path/mod.ts": "f065032a7189404fdac3ad1a1551a9ac84751d2f25c431e101787846c86c79ef", + "https://deno.land/std@0.193.0/path/posix.ts": "8b7c67ac338714b30c816079303d0285dd24af6b284f7ad63da5b27372a2c94d", + "https://deno.land/std@0.193.0/path/separator.ts": "0fb679739d0d1d7bf45b68dacfb4ec7563597a902edbaf3c59b50d5bcadd93b1", + "https://deno.land/std@0.193.0/path/win32.ts": "d186344e5583bcbf8b18af416d13d82b35a317116e6460a5a3953508c3de5bba", + "https://deno.land/std@0.193.0/yaml/_dumper/dumper.ts": "a2c937a53a2b0473125a31a330334cc3f30e98fd82f8143bc225583d1260890b", + "https://deno.land/std@0.193.0/yaml/_dumper/dumper_state.ts": "f0d0673ceea288334061ca34b63954c2bb5feb5bf6de5e4cfe9a942cdf6e5efe", + "https://deno.land/std@0.193.0/yaml/_error.ts": "b59e2c76ce5a47b1b9fa0ff9f96c1dd92ea1e1b17ce4347ece5944a95c3c1a84", + "https://deno.land/std@0.193.0/yaml/_loader/loader.ts": "47b9592efcb390b58b1903cc471bfdf1fc71a0d2d2b31e37b5cae7d8804c7aed", + "https://deno.land/std@0.193.0/yaml/_loader/loader_state.ts": "0841870b467169269d7c2dfa75cd288c319bc06f65edd9e42c29e5fced91c7a4", + "https://deno.land/std@0.193.0/yaml/_mark.ts": "dcd8585dee585e024475e9f3fe27d29740670fb64ebb970388094cad0fc11d5d", + "https://deno.land/std@0.193.0/yaml/_state.ts": "ef03d55ec235d48dcfbecc0ab3ade90bfae69a61094846e08003421c2cf5cfc6", + "https://deno.land/std@0.193.0/yaml/_type/binary.ts": "d34d8c8d8ed521e270cfede3401c425b971af4f6c69da1e2cb32b172d42c7da7", + "https://deno.land/std@0.193.0/yaml/_type/bool.ts": "5bfa75da84343d45347b521ba4e5aeace9fe6f53447405290d53315a3fc20e66", + "https://deno.land/std@0.193.0/yaml/_type/float.ts": "056bd3cb9c5586238b20517511014fb24b0e36f98f9f6073e12da308b6b9808a", + "https://deno.land/std@0.193.0/yaml/_type/function.ts": "ff574fe84a750695302864e1c31b93f12d14ada4bde79a5f93197fc33ad17471", + "https://deno.land/std@0.193.0/yaml/_type/int.ts": "563ad074f0fa7aecf6b6c3d84135bcc95a8269dcc15de878de20ce868fd773fa", + "https://deno.land/std@0.193.0/yaml/_type/map.ts": "7b105e4ab03a361c61e7e335a0baf4d40f06460b13920e5af3fb2783a1464000", + "https://deno.land/std@0.193.0/yaml/_type/merge.ts": "8192bf3e4d637f32567917f48bb276043da9cf729cf594e5ec191f7cd229337e", + "https://deno.land/std@0.193.0/yaml/_type/mod.ts": "060e2b3d38725094b77ea3a3f05fc7e671fced8e67ca18e525be98c4aa8f4bbb", + "https://deno.land/std@0.193.0/yaml/_type/nil.ts": "606e8f0c44d73117c81abec822f89ef81e40f712258c74f186baa1af659b8887", + "https://deno.land/std@0.193.0/yaml/_type/omap.ts": "cfe59a294726f5cea705c39a61fd2b08199cf48f4ccd6b040cb550ec0f38d0a1", + "https://deno.land/std@0.193.0/yaml/_type/pairs.ts": "0032fdfe57558d21696a4f8cf5b5cfd1f698743177080affc18629685c905666", + "https://deno.land/std@0.193.0/yaml/_type/regexp.ts": "1ce118de15b2da43b4bd8e4395f42d448b731acf3bdaf7c888f40789f9a95f8b", + "https://deno.land/std@0.193.0/yaml/_type/seq.ts": "95333abeec8a7e4d967b8c8328b269e342a4bbdd2585395549b9c4f58c8533a2", + "https://deno.land/std@0.193.0/yaml/_type/set.ts": "f28ba44e632ef2a6eb580486fd47a460445eeddbdf1dbc739c3e62486f566092", + "https://deno.land/std@0.193.0/yaml/_type/str.ts": "a67a3c6e429d95041399e964015511779b1130ea5889fa257c48457bd3446e31", + "https://deno.land/std@0.193.0/yaml/_type/timestamp.ts": "706ea80a76a73e48efaeb400ace087da1f927647b53ad6f754f4e06d51af087f", + "https://deno.land/std@0.193.0/yaml/_type/undefined.ts": "94a316ca450597ccbc6750cbd79097ad0d5f3a019797eed3c841a040c29540ba", + "https://deno.land/std@0.193.0/yaml/_utils.ts": "26b311f0d42a7ce025060bd6320a68b50e52fd24a839581eb31734cd48e20393", + "https://deno.land/std@0.193.0/yaml/mod.ts": "28ecda6652f3e7a7735ee29c247bfbd32a2e2fc5724068e9fd173ec4e59f66f7", + "https://deno.land/std@0.193.0/yaml/parse.ts": "1fbbda572bf3fff578b6482c0d8b85097a38de3176bf3ab2ca70c25fb0c960ef", + "https://deno.land/std@0.193.0/yaml/schema.ts": "96908b78dc50c340074b93fc1598d5e7e2fe59103f89ff81e5a49b2dedf77a67", + "https://deno.land/std@0.193.0/yaml/schema/core.ts": "fa406f18ceedc87a50e28bb90ec7a4c09eebb337f94ef17468349794fa828639", + "https://deno.land/std@0.193.0/yaml/schema/default.ts": "0047e80ae8a4a93293bc4c557ae8a546aabd46bb7165b9d9b940d57b4d88bde9", + "https://deno.land/std@0.193.0/yaml/schema/extended.ts": "0784416bf062d20a1626b53c03380e265b3e39b9409afb9f4cb7d659fd71e60d", + "https://deno.land/std@0.193.0/yaml/schema/failsafe.ts": "d219ab5febc43f770917d8ec37735a4b1ad671149846cbdcade767832b42b92b", + "https://deno.land/std@0.193.0/yaml/schema/json.ts": "5f41dd7c2f1ad545ef6238633ce9ee3d444dfc5a18101e1768bd5504bf90e5e5", + "https://deno.land/std@0.193.0/yaml/schema/mod.ts": "4472e827bab5025e92bc2eb2eeefa70ecbefc64b2799b765c69af84822efef32", + "https://deno.land/std@0.193.0/yaml/stringify.ts": "fffc09c65c68d3d63f8159e8cbaa3f489bc20a8e55b4fbb61a8c2e9f914d1d02", + "https://deno.land/std@0.193.0/yaml/type.ts": "1aabb8e0a3f4229ce0a3526256f68826d9bdf65a36c8a3890ead8011fcba7670", "https://deno.land/std@0.200.0/_util/os.ts": "d932f56d41e4f6a6093d56044e29ce637f8dcc43c5a90af43504a889cf1775e3", "https://deno.land/std@0.200.0/assert/assert.ts": "9a97dad6d98c238938e7540736b826440ad8c1c1e54430ca4c4e623e585607ee", "https://deno.land/std@0.200.0/assert/assertion_error.ts": "4d0bde9b374dfbcbe8ac23f54f567b77024fb67dbb1906a852d67fe050d42f56", @@ -193,6 +866,175 @@ "https://deno.land/std@0.200.0/streams/write_all.ts": "aec90152978581ea62d56bb53a5cbf487e6a89c902f87c5969681ffbdf32b998", "https://deno.land/std@0.200.0/streams/writer_from_stream_writer.ts": "07c7ee025151a190f37fc42cbb01ff93afc949119ebddc6e0d0df14df1bf6950", "https://deno.land/std@0.200.0/streams/zip_readable_streams.ts": "a9d81aa451240f79230add674809dbee038d93aabe286e2d9671e66591fc86ca", + "https://deno.land/std@0.202.0/assert/assert.ts": "9a97dad6d98c238938e7540736b826440ad8c1c1e54430ca4c4e623e585607ee", + "https://deno.land/std@0.202.0/assert/assertion_error.ts": "4d0bde9b374dfbcbe8ac23f54f567b77024fb67dbb1906a852d67fe050d42f56", + "https://deno.land/std@0.202.0/async/delay.ts": "a6142eb44cdd856b645086af2b811b1fcce08ec06bb7d50969e6a872ee9b8659", + "https://deno.land/std@0.202.0/collections/_utils.ts": "5114abc026ddef71207a79609b984614e66a63a4bda17d819d56b0e72c51527e", + "https://deno.land/std@0.202.0/collections/deep_merge.ts": "9db788ba56cb05b65c77166b789e58e125dff159b7f41bf4d19dc1cba19ecb8b", + "https://deno.land/std@0.202.0/encoding/base64.ts": "144ae6234c1fbe5b68666c711dc15b1e9ee2aef6d42b3b4345bf9a6c91d70d0d", + "https://deno.land/std@0.202.0/flags/mod.ts": "0948466fc437f017f00c0b972a422b3dc3317a790bcf326429d23182977eaf9f", + "https://deno.land/std@0.202.0/fmt/bytes.ts": "f29cf69e0791d375f9f5d94ae1f0641e5a03b975f32ddf86d70f70fdf37e7b6a", + "https://deno.land/std@0.202.0/fmt/colors.ts": "c51c4642678eb690dcf5ffee5918b675bf01a33fba82acf303701ae1a4f8c8d9", + "https://deno.land/std@0.202.0/http/cookie.ts": "c6079019fc15c781c302574f40fa2ac71c26b251e8f74eb236ea43e0424edcd7", + "https://deno.land/std@0.202.0/http/etag.ts": "807382795850cde5c437c74bcc09392bc0fc56de348fc1271f383f4b28935b9f", + "https://deno.land/std@0.202.0/http/file_server.ts": "6f5c4a28c36995f31544abb49b86bee6e7a2d34664cac3936ff08ccad1682d85", + "https://deno.land/std@0.202.0/http/http_status.ts": "8a7bcfe3ac025199ad804075385e57f63d055b2aed539d943ccc277616d6f932", + "https://deno.land/std@0.202.0/http/server.ts": "1b2403b3c544c0624ad23e8ca4e05877e65380d9e0d75d04957432d65c3d5f41", + "https://deno.land/std@0.202.0/http/util.ts": "4cf044067febaa26d0830e356b0f3a5f76d701a60d7ff7a516fad7b192f4c3a7", + "https://deno.land/std@0.202.0/media_types/_db.ts": "7606d83e31f23ce1a7968cbaee852810c2cf477903a095696cdc62eaab7ce570", + "https://deno.land/std@0.202.0/media_types/_util.ts": "0879b04cc810ff18d3dcd97d361e03c9dfb29f67d7fc4a9c6c9d387282ef5fe8", + "https://deno.land/std@0.202.0/media_types/content_type.ts": "ad98a5aa2d95f5965b2796072284258710a25e520952376ed432b0937ce743bc", + "https://deno.land/std@0.202.0/media_types/format_media_type.ts": "f5e1073c05526a6f5a516ac5c5587a1abd043bf1039c71cde1166aa4328c8baf", + "https://deno.land/std@0.202.0/media_types/get_charset.ts": "18b88274796fda5d353806bf409eb1d2ddb3f004eb4bd311662c4cdd8ac173db", + "https://deno.land/std@0.202.0/media_types/parse_media_type.ts": "31ccf2388ffab31b49500bb89fa0f5de189c8897e2ee6c9954f207637d488211", + "https://deno.land/std@0.202.0/media_types/type_by_extension.ts": "8c210d4e28ea426414dd8c61146eefbcc7e091a89ccde54bbbe883a154856afd", + "https://deno.land/std@0.202.0/media_types/vendor/mime-db.v1.52.0.ts": "6925bbcae81ca37241e3f55908d0505724358cda3384eaea707773b2c7e99586", + "https://deno.land/std@0.202.0/path/_constants.ts": "e49961f6f4f48039c0dfed3c3f93e963ca3d92791c9d478ac5b43183413136e0", + "https://deno.land/std@0.202.0/path/_extname.ts": "eaaa5aae1acf1f03254d681bd6a8ce42a9cb5b7ff2213a9d4740e8ab31283664", + "https://deno.land/std@0.202.0/path/_join.ts": "815f5e85b042285175b1492dd5781240ce126c23bd97bad6b8211fe7129c538e", + "https://deno.land/std@0.202.0/path/_normalize.ts": "a19ec8706b2707f9dd974662a5cd89fad438e62ab1857e08b314a8eb49a34d81", + "https://deno.land/std@0.202.0/path/_os.ts": "30b0c2875f360c9296dbe6b7f2d528f0f9c741cecad2e97f803f5219e91b40a2", + "https://deno.land/std@0.202.0/path/_relative.ts": "27bdeffb5311a47d85be26d37ad1969979359f7636c5cd9fcf05dcd0d5099dc5", + "https://deno.land/std@0.202.0/path/_resolve.ts": "7a3616f1093735ed327e758313b79c3c04ea921808ca5f19ddf240cb68d0adf6", + "https://deno.land/std@0.202.0/path/_util.ts": "4e191b1bac6b3bf0c31aab42e5ca2e01a86ab5a0d2e08b75acf8585047a86221", + "https://deno.land/std@0.202.0/path/extname.ts": "62c4b376300795342fe1e4746c0de518b4dc9c4b0b4617bfee62a2973a9555cf", + "https://deno.land/std@0.202.0/path/join.ts": "31c5419f23d91655b08ec7aec403f4e4cd1a63d39e28f6e42642ea207c2734f8", + "https://deno.land/std@0.202.0/path/relative.ts": "8bedac226afd360afc45d451a6c29fabceaf32978526bcb38e0c852661f66c61", + "https://deno.land/std@0.202.0/path/resolve.ts": "133161e4949fc97f9ca67988d51376b0f5eef8968a6372325ab84d39d30b80dc", + "https://deno.land/std@0.202.0/path/separator.ts": "40a3e9a4ad10bef23bc2cd6c610291b6c502a06237c2c4cd034a15ca78dedc1f", + "https://deno.land/std@0.202.0/streams/byte_slice_stream.ts": "c46d7c74836fc8c1a9acd9fe211cbe1bbaaee1b36087c834fb03af4991135c3a", + "https://deno.land/std@0.202.0/version.ts": "a39aa19f482555b66c041c6317bd8ce849401a3b580bd12e80fe0adf647b0ad1", + "https://deno.land/std@0.210.0/assert/assert.ts": "e265ad50a9341f3b40e51dd4cb41ab253d976943ba78a977106950e52e0302ab", + "https://deno.land/std@0.210.0/assert/assertion_error.ts": "26ed1863d905005f00785c89750c001c3522c5417e4f58f95044b8143cfc1593", + "https://deno.land/std@0.210.0/async/delay.ts": "d414b6ff5b597a3b8a90b1b860b675062a106ad0e311816256f4696aa40ec1a1", + "https://deno.land/std@0.210.0/bytes/concat.ts": "148a7575649e4a06246203f725f4878dce08690cc33c448f1000632e7a050449", + "https://deno.land/std@0.210.0/bytes/copy.ts": "939d89e302a9761dcf1d9c937c7711174ed74c59eef40a1e4569a05c9de88219", + "https://deno.land/std@0.210.0/datetime/_common.ts": "32ab92a6a9353e2f7ee23a30f0dfbd458b750e1c6fd71af1ec83f93a8f7c268a", + "https://deno.land/std@0.210.0/datetime/constants.ts": "76f642d01da7130ada14307f029cafe7fe931d17c863268ae185fa32d3ef3511", + "https://deno.land/std@0.210.0/datetime/day_of_year.ts": "2d50431735f4b1b171dcd8c339f991c3efca8c8d8618a3ebfe501a7aa0e1efd5", + "https://deno.land/std@0.210.0/datetime/difference.ts": "fab879a5a7caf44604c240898ed2c7cdd16f037a3bd6e0cb185994fafbd71e4b", + "https://deno.land/std@0.210.0/datetime/format.ts": "2d7a430ca9571e054ac181dcb950faf9ac23445e081dcb230ca37134e6eaad0c", + "https://deno.land/std@0.210.0/datetime/is_leap.ts": "706c3579a34d38111eea92c1b8683e859e5c5db9ec05f08a9b611ec888fbd787", + "https://deno.land/std@0.210.0/datetime/mod.ts": "365b3bd6809d7772346e8277b588ece59684e46ab0bf624223d4d3527370cd1d", + "https://deno.land/std@0.210.0/datetime/parse.ts": "b59f583e7fe5ef2105c6dd4a74825670c9f4e1e35462c047c6f0a207b5653aac", + "https://deno.land/std@0.210.0/datetime/week_of_year.ts": "663be3ac95630499625cd8416f5145705dd2f553071133646adfd1ea8381156d", + "https://deno.land/std@0.210.0/encoding/_util.ts": "f368920189c4fe6592ab2e93bd7ded8f3065b84f95cd3e036a4a10a75649dcba", + "https://deno.land/std@0.210.0/encoding/base64.ts": "cdc3810253462ccc7b2818429c1613e581f7999ff1ff5b0a6854e0cc38caffeb", + "https://deno.land/std@0.210.0/encoding/hex.ts": "a91232cc15aeb458289d22ed443dc2ba2e6f98080a11db3dfc96a0063c238cbe", + "https://deno.land/std@0.210.0/http/_negotiation/common.ts": "14d1a52427ab258a4b7161cd80e1d8a207b7cc64b46e911780f57ead5f4323c6", + "https://deno.land/std@0.210.0/http/_negotiation/encoding.ts": "ff747d107277c88cb7a6a62a08eeb8d56dad91564cbcccb30694d5dc126dcc53", + "https://deno.land/std@0.210.0/http/_negotiation/language.ts": "7bcddd8db3330bdb7ce4fc00a213c5547c1968139864201efd67ef2d0d51887d", + "https://deno.land/std@0.210.0/http/_negotiation/media_type.ts": "58847517cd549384ad677c0fe89e0a4815be36fe7a303ea63cee5f6a1d7e1692", + "https://deno.land/std@0.210.0/http/cookie.ts": "c6079019fc15c781c302574f40fa2ac71c26b251e8f74eb236ea43e0424edcd7", + "https://deno.land/std@0.210.0/http/cookie_map.ts": "5aa034d627ff79d3b13fb95d4e5f698c1d3d2c2b49e8d8aab284dd3331e1f0f5", + "https://deno.land/std@0.210.0/http/etag.ts": "259abf65316c728660e34a100dcb07a1303c37ab6ca3d4ee068503c18b4358b0", + "https://deno.land/std@0.210.0/http/http_status.ts": "719b7ee989d650d38bbcd7ccff25dfef1564ef8165103319f78e5541bef58330", + "https://deno.land/std@0.210.0/http/mod.ts": "a6f7a154e773833ded7d9360500ead9d1de5120f79272df0a891161b51e109ad", + "https://deno.land/std@0.210.0/http/negotiation.ts": "46e74a6bad4b857333a58dc5b50fe8e5a4d5267e97292293ea65f980bd918086", + "https://deno.land/std@0.210.0/http/server.ts": "59a47779624ff748a058c6959d75fc5ca9f334d32b327344a2eec20561880b58", + "https://deno.land/std@0.210.0/http/server_sent_event_stream.ts": "91a62d6c8fde557217f21e9cd759e2d439be8c20c9b699cf73feb5a0e76df338", + "https://deno.land/std@0.210.0/http/status.ts": "a1b712248767f486c7403b7c06ac2bf0dd2d42abdc4253aa858433464aa62ca9", + "https://deno.land/std@0.210.0/http/unstable_cookie_map.ts": "31b3d52595d3b414f0670ca3417b7e70098a3f59c73244c36982e92f886fc333", + "https://deno.land/std@0.210.0/http/unstable_signed_cookie.ts": "5461a8de10380968b7d12b43501705506db2e4325947b6815d17cb2d63ed47dc", + "https://deno.land/std@0.210.0/http/user_agent.ts": "601698836c44dcadf55043c949f2fe4bac4a022155c6fba5da820b46022e2031", + "https://deno.land/std@0.210.0/io/buf_reader.ts": "d0575c7786a5eb9b6f4ed560a400c987b5d1bac2724ad8c352a644b7baff9791", + "https://deno.land/std@0.210.0/io/buf_writer.ts": "6af65d3e243f8bb4ddbc921542ef8797e3bc128bccc43257fe081d57262ad48c", + "https://deno.land/std@0.210.0/io/buffer.ts": "b2ea4d33cd8d1f306d720a4768676382b9462fc0d0cf56b5f7bc2a33ea423b10", + "https://deno.land/std@0.210.0/io/copy_n.ts": "35f88a840aad8d158b5115f862455d01b717c402d1ea3f5d9c608dfdfbeb29fc", + "https://deno.land/std@0.210.0/io/limited_reader.ts": "cbcecd962fa9d292b5a226e657d3c9e60a374d19ae8a3bba9956e6ce4a08d760", + "https://deno.land/std@0.210.0/io/mod.ts": "61c2100d3eac23f0574cffb74257069a8308cf5183342d8c344fcf307e1d5b8c", + "https://deno.land/std@0.210.0/io/multi_reader.ts": "e7edd9157732776ba5483b2bc2597f7b3b27913207dbf411c79172c1fc8a884d", + "https://deno.land/std@0.210.0/io/read_delim.ts": "a079fb0f1a4b2aa397100a65b2c8443f64e36d66720843541d6c938db963c7de", + "https://deno.land/std@0.210.0/io/read_int.ts": "4e96b319f9b82b066c04e13f9f14ad4460bcaf367454844f6395b51820f5b74f", + "https://deno.land/std@0.210.0/io/read_lines.ts": "974a029207b55779ede17bcb60e31c59fddb9abbef51cf87d98ed31769b97cce", + "https://deno.land/std@0.210.0/io/read_long.ts": "b24d81075cd69660ad789948a8413c04038b007890f69418fd3d96dfc5609903", + "https://deno.land/std@0.210.0/io/read_range.ts": "2aa02e038312ba4b5aa282a74226fb6cf6ae9201d53d78585162df237298946b", + "https://deno.land/std@0.210.0/io/read_short.ts": "a2dd615728dbb5cf4a16e23ef12a0d208bd36ceff8dc062a34e0cd2140538f53", + "https://deno.land/std@0.210.0/io/read_string_delim.ts": "9df2a6eca0943518ec15b5b6f0876f62884d8cb51f4baa2212b396c1922f4c68", + "https://deno.land/std@0.210.0/io/slice_long_to_bytes.ts": "bb5aa0d705422b05cfe7c1d4b55716f3c143a30e3014212ee89c4cd23e146467", + "https://deno.land/std@0.210.0/io/string_reader.ts": "3751befe5e8b23fd7a3f87f96d771b61c92e4f52e8e046dc5834007869f84fa4", + "https://deno.land/std@0.210.0/io/string_writer.ts": "8024a4c1bb841e32c41ea7cec8f1248d5f73dd6af93b2a6c14dcc4bf4890ad21", + "https://deno.land/std@0.210.0/path/_common/assert_path.ts": "061e4d093d4ba5aebceb2c4da3318bfe3289e868570e9d3a8e327d91c2958946", + "https://deno.land/std@0.210.0/path/_common/basename.ts": "0d978ff818f339cd3b1d09dc914881f4d15617432ae519c1b8fdc09ff8d3789a", + "https://deno.land/std@0.210.0/path/_common/common.ts": "9e4233b2eeb50f8b2ae10ecc2108f58583aea6fd3e8907827020282dc2b76143", + "https://deno.land/std@0.210.0/path/_common/constants.ts": "e49961f6f4f48039c0dfed3c3f93e963ca3d92791c9d478ac5b43183413136e0", + "https://deno.land/std@0.210.0/path/_common/dirname.ts": "2ba7fb4cc9fafb0f38028f434179579ce61d4d9e51296fad22b701c3d3cd7397", + "https://deno.land/std@0.210.0/path/_common/format.ts": "11aa62e316dfbf22c126917f5e03ea5fe2ee707386555a8f513d27ad5756cf96", + "https://deno.land/std@0.210.0/path/_common/from_file_url.ts": "ef1bf3197d2efbf0297a2bdbf3a61d804b18f2bcce45548ae112313ec5be3c22", + "https://deno.land/std@0.210.0/path/_common/glob_to_reg_exp.ts": "50386887d6041f15741d0013a703ee63ef673983d465d3a0c9c190e95f8da4fe", + "https://deno.land/std@0.210.0/path/_common/normalize.ts": "2ba7fb4cc9fafb0f38028f434179579ce61d4d9e51296fad22b701c3d3cd7397", + "https://deno.land/std@0.210.0/path/_common/normalize_string.ts": "88c472f28ae49525f9fe82de8c8816d93442d46a30d6bb5063b07ff8a89ff589", + "https://deno.land/std@0.210.0/path/_common/relative.ts": "1af19d787a2a84b8c534cc487424fe101f614982ae4851382c978ab2216186b4", + "https://deno.land/std@0.210.0/path/_common/strip_trailing_separators.ts": "7ffc7c287e97bdeeee31b155828686967f222cd73f9e5780bfe7dfb1b58c6c65", + "https://deno.land/std@0.210.0/path/_common/to_file_url.ts": "a8cdd1633bc9175b7eebd3613266d7c0b6ae0fb0cff24120b6092ac31662f9ae", + "https://deno.land/std@0.210.0/path/_interface.ts": "6471159dfbbc357e03882c2266d21ef9afdb1e4aa771b0545e90db58a0ba314b", + "https://deno.land/std@0.210.0/path/_os.ts": "30b0c2875f360c9296dbe6b7f2d528f0f9c741cecad2e97f803f5219e91b40a2", + "https://deno.land/std@0.210.0/path/basename.ts": "04bb5ef3e86bba8a35603b8f3b69537112cdd19ce64b77f2522006da2977a5f3", + "https://deno.land/std@0.210.0/path/common.ts": "f4d061c7d0b95a65c2a1a52439edec393e906b40f1caf4604c389fae7caa80f5", + "https://deno.land/std@0.210.0/path/dirname.ts": "88a0a71c21debafc4da7a4cd44fd32e899462df458fbca152390887d41c40361", + "https://deno.land/std@0.210.0/path/extname.ts": "8c6d6112bce335b4d3d5a07cb0451816d0c2094c147049874fca2db5f707044b", + "https://deno.land/std@0.210.0/path/format.ts": "3457530cc85d1b4bab175f9ae73998b34fd456c830d01883169af0681b8894fb", + "https://deno.land/std@0.210.0/path/from_file_url.ts": "e7fa233ea1dff9641e8d566153a24d95010110185a6f418dd2e32320926043f8", + "https://deno.land/std@0.210.0/path/glob_to_regexp.ts": "74d7448c471e293d03f05ccb968df4365fed6aaa508506b6325a8efdc01d8271", + "https://deno.land/std@0.210.0/path/is_absolute.ts": "67232b41b860571c5b7537f4954c88d86ae2ba45e883ee37d3dec27b74909d13", + "https://deno.land/std@0.210.0/path/is_glob.ts": "567dce5c6656bdedfc6b3ee6c0833e1e4db2b8dff6e62148e94a917f289c06ad", + "https://deno.land/std@0.210.0/path/join.ts": "3ee91038e3eaa966897eddda43d5207d7cae5c2de8a658bdbd722e8f8f29206a", + "https://deno.land/std@0.210.0/path/join_globs.ts": "9b84d5103b63d3dbed4b2cf8b12477b2ad415c7d343f1488505162dc0e5f4db8", + "https://deno.land/std@0.210.0/path/mod.ts": "eff1d7b0617293bd90254d379a7266887dc6fbf5a00e0f450eeb854959379294", + "https://deno.land/std@0.210.0/path/normalize.ts": "aa95be9a92c7bd4f9dc0ba51e942a1973e2b93d266cd74f5ca751c136d520b66", + "https://deno.land/std@0.210.0/path/normalize_glob.ts": "674baa82e1c00b6cb153bbca36e06f8e0337cb8062db6d905ab5de16076ca46b", + "https://deno.land/std@0.210.0/path/parse.ts": "d87ff0deef3fb495bc0d862278ff96da5a06acf0625ca27769fc52ac0d3d6ece", + "https://deno.land/std@0.210.0/path/posix/_util.ts": "ecf49560fedd7dd376c6156cc5565cad97c1abe9824f4417adebc7acc36c93e5", + "https://deno.land/std@0.210.0/path/posix/basename.ts": "a630aeb8fd8e27356b1823b9dedd505e30085015407caa3396332752f6b8406a", + "https://deno.land/std@0.210.0/path/posix/common.ts": "e781d395dc76f6282e3f7dd8de13194abb8b04a82d109593141abc6e95755c8b", + "https://deno.land/std@0.210.0/path/posix/dirname.ts": "f48c9c42cc670803b505478b7ef162c7cfa9d8e751b59d278b2ec59470531472", + "https://deno.land/std@0.210.0/path/posix/extname.ts": "ee7f6571a9c0a37f9218fbf510c440d1685a7c13082c348d701396cc795e0be0", + "https://deno.land/std@0.210.0/path/posix/format.ts": "b94876f77e61bfe1f147d5ccb46a920636cd3cef8be43df330f0052b03875968", + "https://deno.land/std@0.210.0/path/posix/from_file_url.ts": "b97287a83e6407ac27bdf3ab621db3fccbf1c27df0a1b1f20e1e1b5acf38a379", + "https://deno.land/std@0.210.0/path/posix/glob_to_regexp.ts": "6ed00c71fbfe0ccc35977c35444f94e82200b721905a60bd1278b1b768d68b1a", + "https://deno.land/std@0.210.0/path/posix/is_absolute.ts": "159900a3422d11069d48395568217eb7fc105ceda2683d03d9b7c0f0769e01b8", + "https://deno.land/std@0.210.0/path/posix/is_glob.ts": "ec4fbc604b9db8487f7b56ab0e759b24a971ab6a45f7b0b698bc39b8b9f9680f", + "https://deno.land/std@0.210.0/path/posix/join.ts": "0c0d84bdc344876930126640011ec1b888e6facf74153ffad9ef26813aa2a076", + "https://deno.land/std@0.210.0/path/posix/join_globs.ts": "f4838d54b1f60a34a40625a3293f6e583135348be1b2974341ac04743cb26121", + "https://deno.land/std@0.210.0/path/posix/mod.ts": "f1b08a7f64294b7de87fc37190d63b6ce5b02889af9290c9703afe01951360ae", + "https://deno.land/std@0.210.0/path/posix/normalize.ts": "11de90a94ab7148cc46e5a288f7d732aade1d616bc8c862f5560fa18ff987b4b", + "https://deno.land/std@0.210.0/path/posix/normalize_glob.ts": "10a1840c628ebbab679254d5fa1c20e59106102354fb648a1765aed72eb9f3f9", + "https://deno.land/std@0.210.0/path/posix/parse.ts": "199208f373dd93a792e9c585352bfc73a6293411bed6da6d3bc4f4ef90b04c8e", + "https://deno.land/std@0.210.0/path/posix/relative.ts": "e2f230608b0f083e6deaa06e063943e5accb3320c28aef8d87528fbb7fe6504c", + "https://deno.land/std@0.210.0/path/posix/resolve.ts": "51579d83159d5c719518c9ae50812a63959bbcb7561d79acbdb2c3682236e285", + "https://deno.land/std@0.210.0/path/posix/separator.ts": "0b6573b5f3269a3164d8edc9cefc33a02dd51003731c561008c8bb60220ebac1", + "https://deno.land/std@0.210.0/path/posix/to_file_url.ts": "ac5499aa0c6e2c266019cba7d1f7e5a92b8e04983cd72be97f81adad185619a6", + "https://deno.land/std@0.210.0/path/posix/to_namespaced_path.ts": "c9228a0e74fd37e76622cd7b142b8416663a9b87db643302fa0926b5a5c83bdc", + "https://deno.land/std@0.210.0/path/relative.ts": "23d45ede8b7ac464a8299663a43488aad6b561414e7cbbe4790775590db6349c", + "https://deno.land/std@0.210.0/path/resolve.ts": "5b184efc87155a0af9fa305ff68a109e28de9aee81fc3e77cd01380f19daf867", + "https://deno.land/std@0.210.0/path/separator.ts": "1a21ffd408bfaa317bffff604e5a799f78a7a5571590bde6b9cdce7685953d74", + "https://deno.land/std@0.210.0/path/to_file_url.ts": "edaafa089e0bce386e1b2d47afe7c72e379ff93b28a5829a5885e4b6c626d864", + "https://deno.land/std@0.210.0/path/to_namespaced_path.ts": "cf8734848aac3c7527d1689d2adf82132b1618eff3cc523a775068847416b22a", + "https://deno.land/std@0.210.0/path/windows/_util.ts": "f32b9444554c8863b9b4814025c700492a2b57ff2369d015360970a1b1099d54", + "https://deno.land/std@0.210.0/path/windows/basename.ts": "8a9dbf7353d50afbc5b221af36c02a72c2d1b2b5b9f7c65bf6a5a2a0baf88ad3", + "https://deno.land/std@0.210.0/path/windows/common.ts": "e781d395dc76f6282e3f7dd8de13194abb8b04a82d109593141abc6e95755c8b", + "https://deno.land/std@0.210.0/path/windows/dirname.ts": "5c2aa541384bf0bd9aca821275d2a8690e8238fa846198ef5c7515ce31a01a94", + "https://deno.land/std@0.210.0/path/windows/extname.ts": "07f4fa1b40d06a827446b3e3bcc8d619c5546b079b8ed0c77040bbef716c7614", + "https://deno.land/std@0.210.0/path/windows/format.ts": "343019130d78f172a5c49fdc7e64686a7faf41553268961e7b6c92a6d6548edf", + "https://deno.land/std@0.210.0/path/windows/from_file_url.ts": "d53335c12b0725893d768be3ac6bf0112cc5b639d2deb0171b35988493b46199", + "https://deno.land/std@0.210.0/path/windows/glob_to_regexp.ts": "290755e18ec6c1a4f4d711c3390537358e8e3179581e66261a0cf348b1a13395", + "https://deno.land/std@0.210.0/path/windows/is_absolute.ts": "245b56b5f355ede8664bd7f080c910a97e2169972d23075554ae14d73722c53c", + "https://deno.land/std@0.210.0/path/windows/is_glob.ts": "ec4fbc604b9db8487f7b56ab0e759b24a971ab6a45f7b0b698bc39b8b9f9680f", + "https://deno.land/std@0.210.0/path/windows/join.ts": "e6600bf88edeeef4e2276e155b8de1d5dec0435fd526ba2dc4d37986b2882f16", + "https://deno.land/std@0.210.0/path/windows/join_globs.ts": "f4838d54b1f60a34a40625a3293f6e583135348be1b2974341ac04743cb26121", + "https://deno.land/std@0.210.0/path/windows/mod.ts": "d7040f461465c2c21c1c68fc988ef0bdddd499912138cde3abf6ad60c7fb3814", + "https://deno.land/std@0.210.0/path/windows/normalize.ts": "9deebbf40c81ef540b7b945d4ccd7a6a2c5a5992f791e6d3377043031e164e69", + "https://deno.land/std@0.210.0/path/windows/normalize_glob.ts": "344ff5ed45430495b9a3d695567291e50e00b1b3b04ea56712a2acf07ab5c128", + "https://deno.land/std@0.210.0/path/windows/parse.ts": "120faf778fe1f22056f33ded069b68e12447668fcfa19540c0129561428d3ae5", + "https://deno.land/std@0.210.0/path/windows/relative.ts": "026855cd2c36c8f28f1df3c6fbd8f2449a2aa21f48797a74700c5d872b86d649", + "https://deno.land/std@0.210.0/path/windows/resolve.ts": "5ff441ab18a2346abadf778121128ee71bda4d0898513d4639a6ca04edca366b", + "https://deno.land/std@0.210.0/path/windows/separator.ts": "ae21f27015f10510ed1ac4a0ba9c4c9c967cbdd9d9e776a3e4967553c397bd5d", + "https://deno.land/std@0.210.0/path/windows/to_file_url.ts": "8e9ea9e1ff364aa06fa72999204229952d0a279dbb876b7b838b2b2fea55cce3", + "https://deno.land/std@0.210.0/path/windows/to_namespaced_path.ts": "e0f4d4a5e77f28a5708c1a33ff24360f35637ba6d8f103d19661255ef7bfd50d", + "https://deno.land/std@0.224.0/dotenv/load.ts": "587b342f0f6a3df071331fe6ba1c823729ab68f7d53805809475e486dd4161d7", + "https://deno.land/std@0.224.0/dotenv/mod.ts": "0180eaeedaaf88647318811cdaa418cc64dc51fb08354f91f5f480d0a1309f7d", + "https://deno.land/std@0.224.0/dotenv/parse.ts": "09977ff88dfd1f24f9973a338f0f91bbdb9307eb5ff6085446e7c423e4c7ba0c", + "https://deno.land/std@0.224.0/dotenv/stringify.ts": "275da322c409170160440836342eaa7cf012a1d11a7e700d8ca4e7f2f8aa4615", "https://deno.land/x/cors@v1.2.2/abcCors.ts": "cdf83a7eaa69a1bf3ab910d18b9422217902fac47601adcaf0afac5a61845d48", "https://deno.land/x/cors@v1.2.2/attainCors.ts": "7d6aba0f942495cc31119604e0895c9bb8edd8f8baa7fe78e6c655bd0b4cbf59", "https://deno.land/x/cors@v1.2.2/cors.ts": "0e2d9167e3685f9bcf48f565e312b6e1883fa458f7337e5ce7bc2e3b29767980", @@ -201,6 +1043,161 @@ "https://deno.land/x/cors@v1.2.2/oakCors.ts": "1348dc7673c61b85d2e80559a7b44f8e0246eaa6bcc6ec744fafe5d9b13b5c71", "https://deno.land/x/cors@v1.2.2/opineCors.ts": "fb5790115c26b7061d84b8d6c17d258a1e241bcab75b0bc3ca1fdb2e57bc5072", "https://deno.land/x/cors@v1.2.2/types.ts": "97546633ccc7f0df7a29bacba5d91dc6f61decdd1b65258300244dba905d34b8", + "https://deno.land/x/hono@v3.11.7/adapter/deno/serve-static.ts": "ba10cf6aaf39da942b0d49c3b9877ddba69d41d414c6551d890beb1085f58eea", + "https://deno.land/x/hono@v3.11.7/client/client.ts": "ff340f58041203879972dd368b011ed130c66914f789826610869a90603406bf", + "https://deno.land/x/hono@v3.11.7/client/index.ts": "3ff4cf246f3543f827a85a2c84d66a025ac350ee927613629bda47e854bfb7ba", + "https://deno.land/x/hono@v3.11.7/client/types.ts": "ca165b8738d384361b927964466ecc8bc1436edad3d0414e30a28f40ba4ca496", + "https://deno.land/x/hono@v3.11.7/client/utils.ts": "053273c002963b549d38268a1b423ac8ca211a8028bdab1ed0b781a62aa5e661", + "https://deno.land/x/hono@v3.11.7/compose.ts": "37d6e33b7db80e4c43a0629b12fd3a1e3406e7d9e62a4bfad4b30426ea7ae4f1", + "https://deno.land/x/hono@v3.11.7/context.ts": "5cac561498e1f4af7a355673a047f07f47349056c5167ed9aec8a20cdcac8464", + "https://deno.land/x/hono@v3.11.7/helper/adapter/index.ts": "eea9b4caedbfa3a3b4a020bf46c88c0171a00008cd6c10708cd85a3e39d86e62", + "https://deno.land/x/hono@v3.11.7/helper/cookie/index.ts": "a05ce7e3bafe1f8c7f45d04abf79822716011be75904fe1aad2e99126fd985b9", + "https://deno.land/x/hono@v3.11.7/helper/html/index.ts": "a4ac61c54cd432e708dd019aced59273e5e053933f4804b0b5758d9916468b3e", + "https://deno.land/x/hono@v3.11.7/hono-base.ts": "ab40351c5198cedef9e235ca0a958a161fec822b62aa7fb1eaa36559dc05e0d5", + "https://deno.land/x/hono@v3.11.7/hono.ts": "2cc4c292e541463a4d6f83edbcea58048d203e9564ae62ec430a3d466b49a865", + "https://deno.land/x/hono@v3.11.7/http-exception.ts": "6071df078b5f76d279684d52fe82a590f447a64ffe1b75eb5064d0c8a8d2d676", + "https://deno.land/x/hono@v3.11.7/jsx/components.ts": "f69d385d768f2b6656615a2991514b610bfe6ac87e042fa9723d2b92dd92a62b", + "https://deno.land/x/hono@v3.11.7/jsx/index.ts": "4e447da487478dd6f7ceda92256cdeb3fb8ca42c336b22553c279a1927594941", + "https://deno.land/x/hono@v3.11.7/jsx/intrinsic-elements.ts": "03250beb610bda1c72017bc0912c2505ff764b7a8d869e7e4add40eb4cfec096", + "https://deno.land/x/hono@v3.11.7/jsx/jsx-dev-runtime.ts": "4085251851f4716f60171af485cac47622a681b2911eac239b14d7a85f963987", + "https://deno.land/x/hono@v3.11.7/jsx/jsx-runtime.ts": "dbd86dbb5afdc38589d79a5243aa697aa7b35eb55d3cebd1d4c775f42692b133", + "https://deno.land/x/hono@v3.11.7/jsx/streaming.ts": "37a6b23d1419e210e6063c7d315f984a993a4f42b39cbcd77323d1c0af75bc62", + "https://deno.land/x/hono@v3.11.7/middleware.ts": "57b2047c4b9d775a052a9c44a3b805802c1d1cb477ab9c4bb6185d27382d1b96", + "https://deno.land/x/hono@v3.11.7/middleware/basic-auth/index.ts": "5f88b1bc909d0db51fd72ec236db642271e3c597ac9ca2d8d191c0bb7d2ffdef", + "https://deno.land/x/hono@v3.11.7/middleware/bearer-auth/index.ts": "1bfe631db1661cd342a2220614af5e21455ebea11b8c3ed5f6df7ef8d02b9a54", + "https://deno.land/x/hono@v3.11.7/middleware/cache/index.ts": "0d3a742d0b1639e47f11da6ab66f755eb379a431b073391a94a9f551c5a2c430", + "https://deno.land/x/hono@v3.11.7/middleware/compress/index.ts": "c053a4c9bb605f0320e014b513cfd44c6cbde6ed49373fd659fa02d697f9df17", + "https://deno.land/x/hono@v3.11.7/middleware/cors/index.ts": "8ed6459d4d8990e5f398255aa139e3026f773abee8acd7e9dc1090fcf3f42e83", + "https://deno.land/x/hono@v3.11.7/middleware/etag/index.ts": "3392aabea4d02dfec51455c5919bff9aad76538b9fde375dd542fbc3f389dd3a", + "https://deno.land/x/hono@v3.11.7/middleware/jsx-renderer/index.ts": "8c12ac5b61608a4688e28794927990d1d07ca11de8b9e79bb85e33b1696d790c", + "https://deno.land/x/hono@v3.11.7/middleware/jwt/index.ts": "2779850fc1e16a41da03ba93430a08439002fa8cc0e122ee6f444a98172bc891", + "https://deno.land/x/hono@v3.11.7/middleware/logger/index.ts": "4baf9217b61f5e9e937c3e4e6cd87508c83603fcee77c33edba0a6ae2cc41ccd", + "https://deno.land/x/hono@v3.11.7/middleware/powered-by/index.ts": "6faba0cf042278d60b317b690640bb0b58747690cf280fa09024424c5174e66d", + "https://deno.land/x/hono@v3.11.7/middleware/pretty-json/index.ts": "2216ce4c9910be009fecac63367c3626b46137d4cf7cb9a82913e501104b4a88", + "https://deno.land/x/hono@v3.11.7/middleware/secure-headers/index.ts": "05dfc8fbb94a565efbb55633090b81157e97f23393ff80a23e299ad7ac222e34", + "https://deno.land/x/hono@v3.11.7/middleware/timing/index.ts": "241702aa10ab66cc832e8b556c57c236f3bf338a8817d802cb142eae0f852582", + "https://deno.land/x/hono@v3.11.7/mod.ts": "90114a97be9111b348129ad0143e764a64921f60dd03b8f3da529db98a0d3a82", + "https://deno.land/x/hono@v3.11.7/request.ts": "71a67261d14bba95e9a8b4782a1c1704d12d54a77390ce404741df15ab99a109", + "https://deno.land/x/hono@v3.11.7/router.ts": "880316f561918fc197481755aac2165fdbe2f530b925c5357a9f98d6e2cc85c7", + "https://deno.land/x/hono@v3.11.7/router/linear-router/index.ts": "8a2a7144c50b1f4a92d9ee99c2c396716af144c868e10608255f969695efccd0", + "https://deno.land/x/hono@v3.11.7/router/linear-router/router.ts": "bc63e8b5bc1dabc815306d50bebd1bb5877ffa3936ba2ad7550d093c95ee6bd1", + "https://deno.land/x/hono@v3.11.7/router/pattern-router/index.ts": "304a66c50e243872037ed41c7dd79ed0c89d815e17e172e7ad7cdc4bc07d3383", + "https://deno.land/x/hono@v3.11.7/router/pattern-router/router.ts": "a9a5a2a182cce8c3ae82139892cc0502be7dd8f579f31e76d0302b19b338e548", + "https://deno.land/x/hono@v3.11.7/router/reg-exp-router/index.ts": "52755829213941756159b7a963097bafde5cc4fc22b13b1c7c9184dc0512d1db", + "https://deno.land/x/hono@v3.11.7/router/reg-exp-router/node.ts": "5b3fb80411db04c65df066e69fedb2c8c0844753c2633d703336de84d569252c", + "https://deno.land/x/hono@v3.11.7/router/reg-exp-router/router.ts": "7f7af7ce45a4327f9ac7dbdee186f7ba9a24f2eff14c720e3f670be001e71780", + "https://deno.land/x/hono@v3.11.7/router/reg-exp-router/trie.ts": "852ce7207e6701e47fa30889a0d2b8bfcd56d8862c97e7bc9831e0a64bd8835f", + "https://deno.land/x/hono@v3.11.7/router/smart-router/index.ts": "74f9b4fe15ea535900f2b9b048581915f12fe94e531dd2b0032f5610e61c3bef", + "https://deno.land/x/hono@v3.11.7/router/smart-router/router.ts": "f1848a2a1eefa316a11853ae12e749552747771fb8a11fe713ae04ea6461140b", + "https://deno.land/x/hono@v3.11.7/router/trie-router/index.ts": "3eb75e7f71ba81801631b30de6b1f5cefb2c7239c03797e2b2cbab5085911b41", + "https://deno.land/x/hono@v3.11.7/router/trie-router/node.ts": "e9ea493da22913b2e60a88284c5edb5330506f2ceb0ac631909219bb139c4b60", + "https://deno.land/x/hono@v3.11.7/router/trie-router/router.ts": "54ced78d35676302c8fcdda4204f7bdf5a7cc907fbf9967c75674b1e394f830d", + "https://deno.land/x/hono@v3.11.7/types.ts": "82f95c64c13c21129130d7bb383956306e19d23b3e986c02c914d7aa08808d1d", + "https://deno.land/x/hono@v3.11.7/utils/body.ts": "7a16a6656331a96bcae57642f8d5e3912bd361cbbcc2c0d2157ecc3f218f7a92", + "https://deno.land/x/hono@v3.11.7/utils/buffer.ts": "9066a973e64498cb262c7e932f47eed525a51677b17f90893862b7279dc0773e", + "https://deno.land/x/hono@v3.11.7/utils/cookie.ts": "19920ba6756944aae1ad8585c3ddeaa9df479733f59d05359db096f7361e5e4b", + "https://deno.land/x/hono@v3.11.7/utils/crypto.ts": "bda0e141bbe46d3a4a20f8fbcb6380d473b617123d9fdfa93e4499410b537acc", + "https://deno.land/x/hono@v3.11.7/utils/encode.ts": "3b7c7d736123b5073542b34321700d4dbf5ff129c138f434bb2144a4d425ee89", + "https://deno.land/x/hono@v3.11.7/utils/filepath.ts": "18461b055a914d6da85077f453051b516281bb17cf64fa74bf5ef604dc9d2861", + "https://deno.land/x/hono@v3.11.7/utils/html.ts": "4d2f3975238819fa756e0e51cb7090702136b1e3c54c5049694e26c62d2fcd84", + "https://deno.land/x/hono@v3.11.7/utils/http-status.ts": "e0c4343ea7717c314dc600131e16b636c29d61cfdaf9df93b267258d1729d1a0", + "https://deno.land/x/hono@v3.11.7/utils/jwt/index.ts": "5e4b82a42eb3603351dfce726cd781ca41cb57437395409d227131aec348d2d5", + "https://deno.land/x/hono@v3.11.7/utils/jwt/jwt.ts": "02ff7bbf1298ffcc7a40266842f8eac44b6c136453e32d4441e24d0cbfba3a95", + "https://deno.land/x/hono@v3.11.7/utils/jwt/types.ts": "58ddf908f76ba18d9c62ddfc2d1e40cc2e306bf987409a6169287efa81ce2546", + "https://deno.land/x/hono@v3.11.7/utils/mime.ts": "0105d2b5e8e91f07acc70f5d06b388313995d62af23c802fcfba251f5a744d95", + "https://deno.land/x/hono@v3.11.7/utils/stream.ts": "1789dcc73c5b0ede28f83d7d34e47ae432c20e680907cb3275a9c9187f293983", + "https://deno.land/x/hono@v3.11.7/utils/types.ts": "41c4e7d8028f3dec43ff7c26e9498fed53d9ec7c3b47071d066b40f7b7a8ef58", + "https://deno.land/x/hono@v3.11.7/utils/url.ts": "5fc3307ef3cb2e6f34ec2a03e3d7f2126c6a9f5f0eab677222df3f0e40bd7567", + "https://deno.land/x/hono@v3.11.7/validator/index.ts": "6c986e8b91dcf857ecc8164a506ae8eea8665792a4ff7215471df669c632ae7c", + "https://deno.land/x/hono@v3.11.7/validator/validator.ts": "f6139f0b6eb2040bc9f7ed4148905d5affc898235952772b2d6585fdae8d4731", + "https://deno.land/x/hono@v4.3.11/adapter/deno/serve-static.ts": "db226d30f08f1a8bb77653ead42a911357b2f8710d653e43c01eccebb424b295", + "https://deno.land/x/hono@v4.3.11/client/client.ts": "dcda3887257fa3164db7b32c56665c6e757f0ef047a14f3f9599ef41725c1525", + "https://deno.land/x/hono@v4.3.11/client/index.ts": "30def535310a37bede261f1b23d11a9758983b8e9d60a6c56309cee5f6746ab2", + "https://deno.land/x/hono@v4.3.11/client/types.ts": "73fbec704cf968ca5c5bba10aa1131758c52ab31a78301451c79cfc47368d43c", + "https://deno.land/x/hono@v4.3.11/client/utils.ts": "8be84b49c5c7952666875a8e901fde3044c85c853ea6ba3a7e2c0468478459c0", + "https://deno.land/x/hono@v4.3.11/compose.ts": "37d6e33b7db80e4c43a0629b12fd3a1e3406e7d9e62a4bfad4b30426ea7ae4f1", + "https://deno.land/x/hono@v4.3.11/context.ts": "facfd749d823a645039571d66d9d228f5ae6836818b65d3b6c4c6891adfe071e", + "https://deno.land/x/hono@v4.3.11/helper/adapter/index.ts": "ff7e11eb1ca1fbd74ca3c46cd1d24014582f91491ef6d3846d66ed1cede18ec4", + "https://deno.land/x/hono@v4.3.11/helper/cookie/index.ts": "689c84eae410f0444a4598f136a4f859b9122ec6f790dff74412d34405883db8", + "https://deno.land/x/hono@v4.3.11/helper/html/index.ts": "48a0ddc576c10452db6c3cab03dd4ee6986ab61ebdc667335b40a81fa0487f69", + "https://deno.land/x/hono@v4.3.11/hono-base.ts": "fd7e9c1bba1e13119e95158270011784da3a7c3014c149ba0700e700f840ae0d", + "https://deno.land/x/hono@v4.3.11/hono.ts": "23edd0140bf0bd5a68c14ae96e5856a5cec6b844277e853b91025e91ea74f416", + "https://deno.land/x/hono@v4.3.11/http-exception.ts": "f5dd375e61aa4b764eb9b99dd45a7160f8317fd36d3f79ae22585b9a5e8ad7c5", + "https://deno.land/x/hono@v4.3.11/jsx/base.ts": "33f1c302c8f72ae948abd9c3ef85f4b3be6525251a13b95fd18fe2910b7d4a0d", + "https://deno.land/x/hono@v4.3.11/jsx/children.ts": "26ead0f151faba5307883614b5b064299558f06798c695c432f32acbb1127d56", + "https://deno.land/x/hono@v4.3.11/jsx/components.ts": "f79ab215f59388f01a69e2d6ec0b841fd3b42ba38e0ee7c93a525cdf06e159f9", + "https://deno.land/x/hono@v4.3.11/jsx/constants.ts": "984e0797194be1fbc935cb688c8d0a60c112b21bc59301be5354c02232f18820", + "https://deno.land/x/hono@v4.3.11/jsx/context.ts": "2b7a86e6b35da171fab27aa05f09748bb3eba64b26c037ea1da655c07e8f6bc1", + "https://deno.land/x/hono@v4.3.11/jsx/dom/components.ts": "733da654edb3d4c178a4479649fac2c64e79069e37e848add0c3a49f90e7f2d7", + "https://deno.land/x/hono@v4.3.11/jsx/dom/context.ts": "06209d14553398750c69252cc826082018cefa277f5c82cbe58d7261c8a2d81e", + "https://deno.land/x/hono@v4.3.11/jsx/dom/jsx-dev-runtime.ts": "ba87562d14b77dd5f2a3cc30d41b1eb5edb0800e5f4a7337b5b87b2e66f8a099", + "https://deno.land/x/hono@v4.3.11/jsx/dom/jsx-runtime.ts": "6a50a65306771a9000030f494d92a5fdeeb055112e0126234b2fd9179de1d4f5", + "https://deno.land/x/hono@v4.3.11/jsx/dom/render.ts": "7db816d40de58c60e1cbdab64ac3f170b1e30696ed61ad449bbb823f60b46146", + "https://deno.land/x/hono@v4.3.11/jsx/dom/utils.ts": "5d3e8c14996902db9c1223041fb21480fa0e921a4ccdc59f8c7571c08b7810f2", + "https://deno.land/x/hono@v4.3.11/jsx/hooks/index.ts": "b7e0f0a754f31a1e1fbe0ac636b38b031603eb0ae195c32a30769a11d79fb871", + "https://deno.land/x/hono@v4.3.11/jsx/index.ts": "fe3e582c2a4e24e5f8b6027925bddccaae0283747d8f0161eb6f5a34616edd11", + "https://deno.land/x/hono@v4.3.11/jsx/intrinsic-elements.ts": "21c3a8f6ba07f0d7d7c0ec7293c79c26b9b62df2894e26cb6c17b6c7ec381264", + "https://deno.land/x/hono@v4.3.11/jsx/jsx-dev-runtime.ts": "6a8d2d976858adec5e703a009a6f606c4e2ac9d74a21b720ee78bf492749ea23", + "https://deno.land/x/hono@v4.3.11/jsx/jsx-runtime.ts": "59a357099522aee816b292f80c362769963ba3fb65a921f58b4ba0e50d1c05a7", + "https://deno.land/x/hono@v4.3.11/jsx/streaming.ts": "5e5dde9a546041353b9a3860fc9020471f762813f10e1290009ab6bd40e7bdcf", + "https://deno.land/x/hono@v4.3.11/jsx/types.ts": "51c2bdbb373860e2570ad403546a7fdbbb1cf00a47ce7ed10b2aece922031ac4", + "https://deno.land/x/hono@v4.3.11/jsx/utils.ts": "4b8299d402ba5395472c552d1fe3297ee60112bfc32e0ef86cfe8e40086f7d54", + "https://deno.land/x/hono@v4.3.11/middleware.ts": "2e7c6062e36b0e5f84b44a62e7b0e1cef33a9827c19937c648be4b63e1b7d7c6", + "https://deno.land/x/hono@v4.3.11/middleware/basic-auth/index.ts": "2c8cb563f3b89df1a7a2232be37377c3df6194af38613dc0a823c6595816fc66", + "https://deno.land/x/hono@v4.3.11/middleware/bearer-auth/index.ts": "b3b7469bc0eb9543c6c47f3ff67de879210dd73063307a61536042ff30e8720e", + "https://deno.land/x/hono@v4.3.11/middleware/body-limit/index.ts": "3fefeaf7e6e576aa1b33f2694072d2eaab692842acd29cb360d98e20eebfe5aa", + "https://deno.land/x/hono@v4.3.11/middleware/cache/index.ts": "5e6273e5c9ea73ef387b25923ab23274c220b29d7c981b62ac0be26d6a1aa3d8", + "https://deno.land/x/hono@v4.3.11/middleware/compress/index.ts": "98c403a5fe7e9c5f5d776350b422b0a125fb34696851b8b14f825b9b7b06f2ac", + "https://deno.land/x/hono@v4.3.11/middleware/cors/index.ts": "976eb9ce8cefc214b403a2939503a13177cec76223274609a07ca554e0dc623b", + "https://deno.land/x/hono@v4.3.11/middleware/csrf/index.ts": "077bb0ce299d79d0d232cb9e462aaa4eaa901164f1310f74a7630f7e6cfe74e8", + "https://deno.land/x/hono@v4.3.11/middleware/etag/index.ts": "95e0270ea349cf00537ee6e58985a4cc7dba44091ca8e2dc42b6d8b2f01bcfe7", + "https://deno.land/x/hono@v4.3.11/middleware/jsx-renderer/index.ts": "229322c66ebc7f426cd2d71f282438025b4ee7ce8cb8e97e87c7efbc94530c19", + "https://deno.land/x/hono@v4.3.11/middleware/jwt/index.ts": "fce4e2db52b4816bfe6bb3a468bd596ab4705527bee1edf679bc28ca53b28ba3", + "https://deno.land/x/hono@v4.3.11/middleware/logger/index.ts": "52a2e968890ada2c11ce89a7a783692c5767b8ed7fb23ccf6b559d255d13ccbc", + "https://deno.land/x/hono@v4.3.11/middleware/method-override/index.ts": "bc13bdcf70c777b72b1300a5cca1b51a8bd126e0d922b991d89e96fe7c694b5b", + "https://deno.land/x/hono@v4.3.11/middleware/powered-by/index.ts": "6faba0cf042278d60b317b690640bb0b58747690cf280fa09024424c5174e66d", + "https://deno.land/x/hono@v4.3.11/middleware/pretty-json/index.ts": "2216ce4c9910be009fecac63367c3626b46137d4cf7cb9a82913e501104b4a88", + "https://deno.land/x/hono@v4.3.11/middleware/secure-headers/index.ts": "f2e4c3858d26ff47bc6909513607e6a3c31184aabe78fb272ed08e1d62a750f0", + "https://deno.land/x/hono@v4.3.11/middleware/serve-static/index.ts": "14b760bbbc4478cc3a7fb9728730bc6300581c890365b7101b80c16e70e4b21e", + "https://deno.land/x/hono@v4.3.11/middleware/timing/index.ts": "6fddbb3e47ae875c16907cf23b9bb503ec2ad858406418b5f38f1e7fbca8c6f6", + "https://deno.land/x/hono@v4.3.11/middleware/trailing-slash/index.ts": "419cf0af99a137f591b72cc71c053e524fe3574393ce81e0e9dbce84a4046e24", + "https://deno.land/x/hono@v4.3.11/mod.ts": "35fd2a2e14b52365e0ad66f168b067363fd0a60d75cbcb1b01685b04de97d60e", + "https://deno.land/x/hono@v4.3.11/request.ts": "7b08602858e642d1626c3106c0bedc2aa8d97e30691a079351d9acef7c5955e6", + "https://deno.land/x/hono@v4.3.11/router.ts": "880316f561918fc197481755aac2165fdbe2f530b925c5357a9f98d6e2cc85c7", + "https://deno.land/x/hono@v4.3.11/router/linear-router/index.ts": "8a2a7144c50b1f4a92d9ee99c2c396716af144c868e10608255f969695efccd0", + "https://deno.land/x/hono@v4.3.11/router/linear-router/router.ts": "928d29894e4b45b047a4f453c7f1745c8b1869cd68447e1cb710c7bbf99a4e29", + "https://deno.land/x/hono@v4.3.11/router/pattern-router/index.ts": "304a66c50e243872037ed41c7dd79ed0c89d815e17e172e7ad7cdc4bc07d3383", + "https://deno.land/x/hono@v4.3.11/router/pattern-router/router.ts": "1b5f68e6af942579d3a40ee834294fea3d1f05fd5f70514e46ae301dd0107e46", + "https://deno.land/x/hono@v4.3.11/router/reg-exp-router/index.ts": "52755829213941756159b7a963097bafde5cc4fc22b13b1c7c9184dc0512d1db", + "https://deno.land/x/hono@v4.3.11/router/reg-exp-router/node.ts": "7efaa6f4301efc2aad0519c84973061be8555da02e5868409293a1fd98536aaf", + "https://deno.land/x/hono@v4.3.11/router/reg-exp-router/router.ts": "632f2fa426b3e45a66aeed03f7205dad6d13e8081bed6f8d1d987b6cad8fb455", + "https://deno.land/x/hono@v4.3.11/router/reg-exp-router/trie.ts": "852ce7207e6701e47fa30889a0d2b8bfcd56d8862c97e7bc9831e0a64bd8835f", + "https://deno.land/x/hono@v4.3.11/router/smart-router/index.ts": "74f9b4fe15ea535900f2b9b048581915f12fe94e531dd2b0032f5610e61c3bef", + "https://deno.land/x/hono@v4.3.11/router/smart-router/router.ts": "dc22a8505a0f345476f07dca3054c0c50a64d7b81c9af5a904476490dfd5cbb4", + "https://deno.land/x/hono@v4.3.11/router/trie-router/index.ts": "3eb75e7f71ba81801631b30de6b1f5cefb2c7239c03797e2b2cbab5085911b41", + "https://deno.land/x/hono@v4.3.11/router/trie-router/node.ts": "d3e00e8f1ba7fb26896459d5bba882356891a07793387c4655d1864c519a91de", + "https://deno.land/x/hono@v4.3.11/router/trie-router/router.ts": "54ced78d35676302c8fcdda4204f7bdf5a7cc907fbf9967c75674b1e394f830d", + "https://deno.land/x/hono@v4.3.11/types.ts": "b561c3ee846121b33c2d81331246cdedf7781636ed72dad7406677105b4275de", + "https://deno.land/x/hono@v4.3.11/utils/body.ts": "774cb319dfbe886a9d39f12c43dea15a39f9d01e45de0323167cdd5d0aad14d4", + "https://deno.land/x/hono@v4.3.11/utils/buffer.ts": "2fae689954b427b51fb84ad02bed11a72eae96692c2973802b3b4c1e39cd5b9c", + "https://deno.land/x/hono@v4.3.11/utils/color.ts": "10575c221f48bc806887710da8285f859f51daf9e6878bbdf99cb406b8494457", + "https://deno.land/x/hono@v4.3.11/utils/cookie.ts": "662529d55703d2c0bad8736cb1274eb97524c0ef7882d99254fc7c8fa925b46c", + "https://deno.land/x/hono@v4.3.11/utils/crypto.ts": "bda0e141bbe46d3a4a20f8fbcb6380d473b617123d9fdfa93e4499410b537acc", + "https://deno.land/x/hono@v4.3.11/utils/encode.ts": "311dfdfae7eb0b6345e9680f7ebbb3a692e872ed964e2029aca38567af8d1f33", + "https://deno.land/x/hono@v4.3.11/utils/filepath.ts": "a83e5fe87396bb291a6c5c28e13356fcbea0b5547bad2c3ba9660100ff964000", + "https://deno.land/x/hono@v4.3.11/utils/html.ts": "6ea4f6bf41587a51607dff7a6d2865ef4d5001e4203b07e5c8a45b63a098e871", + "https://deno.land/x/hono@v4.3.11/utils/http-status.ts": "f5b820f2793e45209f34deddf147b23e3133a89eb4c57dc643759a504706636b", + "https://deno.land/x/hono@v4.3.11/utils/jwt/index.ts": "3b66f48cdd3fcc2caed5e908ca31776e11b1c30391008931276da3035e6ba1e9", + "https://deno.land/x/hono@v4.3.11/utils/jwt/jwa.ts": "6874cacd8b6dde386636b81b5ea2754f8e4c61757802fa908dd1ce54b91a52fa", + "https://deno.land/x/hono@v4.3.11/utils/jwt/jws.ts": "878fa7d1966b0db20ae231cfee279ba2bb198943e949049cab3f5845cd5ee2d1", + "https://deno.land/x/hono@v4.3.11/utils/jwt/jwt.ts": "80452edc3498c6670a211fdcd33cfc4d5c00dfac79aa9f403b0623dedc039554", + "https://deno.land/x/hono@v4.3.11/utils/jwt/types.ts": "b6659ac85e7f8fcdd8cdfc7d51f5d1a91107ad8dfb647a8e4ea9c80f0f02afee", + "https://deno.land/x/hono@v4.3.11/utils/jwt/utf8.ts": "17c507f68f23ccb82503ea6183e54b5f748a6fe621eb60994adfb4a8c2a3f561", + "https://deno.land/x/hono@v4.3.11/utils/mime.ts": "d1fc2c047191ccb01d736c6acf90df731324536298181dba0ecc2259e5f7d661", + "https://deno.land/x/hono@v4.3.11/utils/types.ts": "050bfa9dc6d0cc4b7c5069944a8bd60066c2f9f95ee69833623ad104f11f92bf", + "https://deno.land/x/hono@v4.3.11/utils/url.ts": "855169632c61d03703bd08cafb27664ba3fdb352892f01687d5cce8fd49e3cb1", + "https://deno.land/x/hono@v4.3.11/validator/index.ts": "6c986e8b91dcf857ecc8164a506ae8eea8665792a4ff7215471df669c632ae7c", + "https://deno.land/x/hono@v4.3.11/validator/validator.ts": "53f3d2ad442e22f0bc2d85b7d8d90320d4e5ecf5fdd58882f906055d33a18e13", "https://deno.land/x/oak@v12.6.1/application.ts": "3028d3f6fa5ee743de013881550d054372c11d83c45099c2d794033786d27008", "https://deno.land/x/oak@v12.6.1/body.ts": "1899761b97fc9d776f3710b2637fb047ba29b968609afc6c0e5219b1108e703c", "https://deno.land/x/oak@v12.6.1/buf_reader.ts": "26640736541598dbd9f2b84a9d0595756afff03c9ca55b66eef1911f7798b56d", @@ -257,5 +1254,10 @@ "https://deno.land/x/oak@v17.1.3/utils/streams.ts": "3da73b94681f8d27a82cc67df3f91090ec0bd6c3e9ab957af588d41ab585d923", "https://deno.land/x/oak@v17.1.3/utils/type_guards.ts": "a8dbb5ab7424f0355b121537d2454f927e0ca9949262fb67ac4fbefbd5880313", "https://deno.land/x/path_to_regexp@v6.2.1/index.ts": "894060567837bae8fc9c5cbd4d0a05e9024672083d5883b525c031eea940e556" + }, + "workspace": { + "dependencies": [ + "jsr:@hono/hono@4" + ] } } diff --git a/index.html b/index.html deleted file mode 100644 index 87b1ba0..0000000 --- a/index.html +++ /dev/null @@ -1,268 +0,0 @@ - - - - - - MockAPI Studio - - - - - - - - - - - - -
-
- -
-
- - - - - - - - - - - - \ No newline at end of file diff --git a/script.js b/script.js deleted file mode 100644 index eaf24a0..0000000 --- a/script.js +++ /dev/null @@ -1,490 +0,0 @@ -let editor; // Monaco editor instance - -// Initialize Monaco Editor -require.config({ paths: { vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.43.0/min/vs' }}); -require(['vs/editor/editor.main'], function() { - editor = monaco.editor.create(document.getElementById('editor-container'), { - value: '{\n "message": "Success"\n}', - language: 'json', - theme: 'vs-dark', - minimap: { enabled: false }, - automaticLayout: true - }); -}); - -// Initialize Materialize components -document.addEventListener('DOMContentLoaded', function() { - // Initialize all modals - const modals = document.querySelectorAll('.modal'); - M.Modal.init(modals, { - onOpenStart: function(modal) { - // Reset forms when modal opens - if (modal.id === 'importModal') { - // Reset import form - document.getElementById('importFile').value = ''; - document.getElementById('importPreview').style.display = 'none'; - document.getElementById('importBtn').disabled = true; - window.apisToImport = null; - } - }, - onCloseEnd: function(modal) { - if (modal.id === 'createModal') { - resetForm(); - } - } - }); - - // Initialize select inputs - const selects = document.querySelectorAll('select'); - M.FormSelect.init(selects); - - // Initialize tabs - const tabs = document.querySelectorAll('.tabs'); - M.Tabs.init(tabs); - - // Add event listeners - document.getElementById('authType').addEventListener('change', updateAuthFields); - - // Add file input listener - const importFileInput = document.getElementById('importFile'); - if (importFileInput) { - importFileInput.addEventListener('change', handleFileImport); - } - - // Enable import button if file is selected - const importBtn = document.getElementById('importBtn'); - if (importBtn) { - importBtn.disabled = false; - } - - // Load initial API list - loadApis(); -}); - -// Update auth fields based on selected auth type -function updateAuthFields() { - const authType = document.getElementById('authType').value; - const authFields = document.getElementById('authFields'); - authFields.innerHTML = ''; - - switch(authType) { - case 'bearer': - authFields.innerHTML = ` -
- - -
- `; - break; - case 'oauth': - authFields.innerHTML = ` -
-
- -
-
-
-
- - -
-
- - -
-
- - `; - // Add toggle listener for OAuth fields - document.getElementById('tokenEndpoint')?.addEventListener('change', function(e) { - document.getElementById('oauthFields').style.display = e.target.checked ? 'none' : 'block'; - document.getElementById('tokenEndpointFields').style.display = e.target.checked ? 'block' : 'none'; - }); - break; - case 'client_credentials': - authFields.innerHTML = ` -
- - -
-
- - -
- `; - break; - case 'api_key': - authFields.innerHTML = ` -
- - -
- `; - break; - case 'custom_header': - authFields.innerHTML = ` -
- - -
-
- - -
- `; - break; - } - - // Reinitialize Materialize inputs - const inputs = authFields.querySelectorAll('input'); - inputs.forEach(input => M.updateTextFields()); -} - -// Load and display existing APIs -async function loadApis() { - try { - const response = await fetch('/apis'); - const apis = await response.json(); - - const apiList = document.getElementById('apiList'); - apiList.innerHTML = ''; - - apis.forEach(api => { - apiList.innerHTML += ` -
-
-
- ${api.method} - ${api.path} -

Auth: ${api.auth.type}

-
- ${window.location.origin}${api.path} -
-
-
- Edit - Delete - Test -
-
-
- `; - }); - } catch (error) { - M.toast({html: 'Error loading APIs: ' + error.message, classes: 'red'}); - } -} - -// Save API (Create/Update) -async function saveApi() { - try { - const id = document.getElementById('editApiId').value; - const isEdit = !!id; - - const authType = document.getElementById('authType').value; - let auth = { type: authType }; - - // Add auth details based on type - switch(authType) { - case 'bearer': - auth.token = document.getElementById('token').value; - break; - case 'oauth': - const isTokenEndpoint = document.getElementById('tokenEndpoint')?.checked; - if (isTokenEndpoint) { - auth.tokenEndpoint = true; - auth.allowedClientId = document.getElementById('allowedClientId').value; - auth.allowedClientSecret = document.getElementById('allowedClientSecret').value; - // Add allowed scopes - const allowedScopes = document.getElementById('allowedScopes').value; - auth.allowedScopes = allowedScopes ? allowedScopes.split(' ').filter(Boolean) : []; - } else { - auth.token = document.getElementById('token').value; - // Add required scopes - const requiredScopes = document.getElementById('requiredScopes').value; - auth.requiredScopes = requiredScopes ? requiredScopes.split(' ').filter(Boolean) : []; - } - break; - case 'client_credentials': - auth.clientId = document.getElementById('clientId').value; - auth.clientSecret = document.getElementById('clientSecret').value; - break; - case 'api_key': - auth.apiKey = document.getElementById('apiKey').value; - break; - case 'custom_header': - auth.headerName = document.getElementById('headerName').value; - auth.headerValue = document.getElementById('headerValue').value; - break; - } - - const mockApi = { - path: document.getElementById('path').value, - method: document.getElementById('method').value, - auth, - statusCode: parseInt(document.getElementById('statusCode').value), - response: JSON.parse(editor.getValue()) - }; - - const url = isEdit ? `/apis/${id}` : '/apis'; - const method = isEdit ? 'PUT' : 'POST'; - - const response = await fetch(url, { - method, - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(mockApi) - }); - - if (!response.ok) throw new Error('Failed to save API'); - - M.toast({html: `API ${isEdit ? 'updated' : 'created'} successfully!`, classes: 'green'}); - loadApis(); - const modal = M.Modal.getInstance(document.getElementById('createModal')); - modal.close(); - resetForm(); - } catch (error) { - M.toast({html: 'Error saving API: ' + error.message, classes: 'red'}); - } -} - -// Edit API -async function editApi(id) { - try { - const response = await fetch(`/apis/${id}`); - const api = await response.json(); - - document.getElementById('editApiId').value = api.id; - document.getElementById('path').value = api.path; - document.getElementById('method').value = api.method; - document.getElementById('authType').value = api.auth.type; - document.getElementById('statusCode').value = api.statusCode; - editor.setValue(JSON.stringify(api.response, null, 2)); - - // Update select dropdowns - M.FormSelect.init(document.querySelectorAll('select')); - M.updateTextFields(); - - // Update auth fields - updateAuthFields(); - - // Fill auth fields - switch(api.auth.type) { - case 'bearer': - document.getElementById('token').value = api.auth.token || ''; - break; - case 'oauth': - if (api.auth.tokenEndpoint) { - document.getElementById('tokenEndpoint').checked = true; - document.getElementById('allowedClientId').value = api.auth.allowedClientId || ''; - document.getElementById('allowedClientSecret').value = api.auth.allowedClientSecret || ''; - document.getElementById('allowedScopes').value = api.auth.allowedScopes?.join(' ') || ''; - // Trigger change event to show/hide appropriate fields - document.getElementById('tokenEndpoint').dispatchEvent(new Event('change')); - } else { - document.getElementById('token').value = api.auth.token || ''; - document.getElementById('requiredScopes').value = api.auth.requiredScopes?.join(' ') || ''; - } - break; - case 'client_credentials': - document.getElementById('clientId').value = api.auth.clientId || ''; - document.getElementById('clientSecret').value = api.auth.clientSecret || ''; - break; - case 'api_key': - document.getElementById('apiKey').value = api.auth.apiKey || ''; - break; - case 'custom_header': - document.getElementById('headerName').value = api.auth.headerName || ''; - document.getElementById('headerValue').value = api.auth.headerValue || ''; - break; - } - - M.updateTextFields(); - - // Open modal - M.Modal.getInstance(document.getElementById('createModal')).open(); - } catch (error) { - M.toast({html: 'Error loading API: ' + error.message, classes: 'red'}); - } -} - -// Delete API -async function deleteApi(id) { - if (!confirm('Are you sure you want to delete this API?')) return; - - try { - const response = await fetch(`/apis/${id}`, { - method: 'DELETE' - }); - - if (!response.ok) throw new Error('Failed to delete API'); - - M.toast({html: 'API deleted successfully!', classes: 'green'}); - loadApis(); - } catch (error) { - M.toast({html: 'Error deleting API: ' + error.message, classes: 'red'}); - } -} - -// Copy endpoint URL -function copyEndpoint() { - const endpoint = document.getElementById('fullEndpoint').textContent; - navigator.clipboard.writeText(endpoint); - M.toast({html: 'Endpoint URL copied!', classes: 'green'}); -} - -// Add this new function to reset the form -function resetForm() { - document.getElementById('apiForm').reset(); - document.getElementById('editApiId').value = ''; - editor.setValue('{\n "message": "Success"\n}'); - - // Reset auth fields - document.getElementById('authType').value = 'none'; - document.getElementById('authFields').innerHTML = ''; - - // Reinitialize select inputs - M.FormSelect.init(document.querySelectorAll('select')); - M.updateTextFields(); -} - -// Move the file import handler to a named function -async function handleFileImport(e) { - const file = e.target.files[0]; - if (!file) { - document.getElementById('importBtn').disabled = true; - return; - } - - try { - const text = await file.text(); - const apis = JSON.parse(text); - - if (!Array.isArray(apis)) { - throw new Error('File must contain an array of APIs'); - } - - const previewDiv = document.getElementById('importPreview'); - const apiCount = document.getElementById('apiCount'); - const previewList = document.getElementById('apiPreviewList'); - const importBtn = document.getElementById('importBtn'); - - apiCount.textContent = apis.length; - previewList.innerHTML = apis.map(api => ` -
- ${api.method} - ${api.path} -

- Auth: ${api.auth?.type || 'none'}
- Status: ${api.statusCode || 200} -

-
- `).join(''); - - previewDiv.style.display = 'block'; - importBtn.disabled = false; - - // Store APIs for import - window.apisToImport = apis; - } catch (error) { - M.toast({html: 'Invalid JSON file: ' + error.message, classes: 'red'}); - console.error('Import error:', error); - document.getElementById('importBtn').disabled = true; - } -} - -// Import APIs -async function importApis() { - const apis = window.apisToImport; - if (!apis) return; - - const importBtn = document.getElementById('importBtn'); - const originalText = importBtn.textContent; - importBtn.disabled = true; - importBtn.innerHTML = 'syncImporting...'; - - try { - let imported = 0; - let failed = 0; - - for (const api of apis) { - try { - const response = await fetch('/apis', { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify({ - path: api.path, - method: api.method, - auth: api.auth || { type: 'none' }, - response: api.response, - statusCode: api.statusCode || 200 - }) - }); - - if (!response.ok) throw new Error(`Failed to import API: ${api.path}`); - imported++; - } catch (error) { - console.error('Error importing API:', error); - failed++; - } - } - - if (failed > 0) { - M.toast({ - html: `Imported ${imported} APIs, ${failed} failed`, - classes: 'orange' - }); - } else { - M.toast({ - html: `Successfully imported ${imported} APIs`, - classes: 'green' - }); - } - - // Refresh the API list - loadApis(); - - // Close the modal - const modal = M.Modal.getInstance(document.getElementById('importModal')); - modal.close(); - - // Reset the form - document.getElementById('importFile').value = ''; - document.getElementById('importPreview').style.display = 'none'; - window.apisToImport = null; - } catch (error) { - M.toast({html: 'Import failed: ' + error.message, classes: 'red'}); - } finally { - importBtn.disabled = false; - importBtn.textContent = originalText; - } -} - -// Helper function for method colors -function getMethodColor(method) { - const colors = { - GET: 'green', - POST: 'blue', - PUT: 'orange', - DELETE: 'red', - PATCH: 'purple' - }; - return colors[method?.toUpperCase()] || 'grey'; -} \ No newline at end of file diff --git a/server.ts b/server.ts deleted file mode 100644 index 75ba444..0000000 --- a/server.ts +++ /dev/null @@ -1,536 +0,0 @@ -/// - -import { Application, Router } from "https://deno.land/x/oak/mod.ts"; -import { oakCors } from "https://deno.land/x/cors@v1.2.2/mod.ts"; - -// Types for our mock API system -interface MockApi { - id: string; - path: string; - method: string; - auth: { - type: "none" | "bearer" | "oauth" | "client_credentials" | "api_key" | "custom_header"; - token?: string; - clientId?: string; - clientSecret?: string; - apiKey?: string; - headerName?: string; - headerValue?: string; - tokenEndpoint?: boolean; - allowedClientId?: string; - allowedClientSecret?: string; - allowedScopes?: string[]; // Available scopes for this endpoint - requiredScopes?: string[]; // Required scopes to access this endpoint - }; - response: any; - statusCode: number; - createdAt: Date; - updatedAt: Date; -} - -// After the MockApi interface, add a new interface for tokens -interface OAuthToken { - access_token: string; - refresh_token: string; - expires_at: number; - client_id: string; - scopes: string[]; // Granted scopes -} - -// Initialize Deno KV -const kv = await Deno.openKv(); - -// Helper functions for KV operations -async function getAllApis(): Promise { - const apis: MockApi[] = []; - const entries = kv.list({ prefix: ["apis"] }); - for await (const entry of entries) { - apis.push(entry.value as MockApi); - } - return apis; -} - -async function getApiById(id: string): Promise { - const result = await kv.get(["apis", id]); - return result.value as MockApi | null; -} - -// Add this helper function to parse path parameters -function matchPath(templatePath: string, actualPath: string): { match: boolean; params: Record } { - const templateParts = templatePath.split('/'); - const actualParts = actualPath.split('/'); - const params: Record = {}; - - if (templateParts.length !== actualParts.length) { - return { match: false, params }; - } - - for (let i = 0; i < templateParts.length; i++) { - const template = templateParts[i]; - const actual = actualParts[i]; - - // Check if it's a parameter - if (template.startsWith('{') && template.endsWith('}')) { - const paramName = template.slice(1, -1); - params[paramName] = actual; - continue; - } - - // Regular path segment comparison - if (template !== actual) { - return { match: false, params }; - } - } - - return { match: true, params }; -} - -// Update the findApiByPathAndMethod function -async function findApiByPathAndMethod(path: string, method: string): Promise<{ api: MockApi | null; params: Record }> { - const apis = await getAllApis(); - - for (const api of apis) { - const { match, params } = matchPath(api.path, path); - if (match && api.method === method) { - return { api, params }; - } - } - - return { api: null, params: {} }; -} - -// Add a new KV collection for tokens -async function storeToken(token: OAuthToken): Promise { - await kv.set(["tokens", token.access_token], token); -} - -async function getToken(access_token: string): Promise { - const result = await kv.get(["tokens", access_token]); - return result.value as OAuthToken | null; -} - -const router = new Router(); - -// Add this logging middleware at the top of the routes -router.use(async (ctx, next) => { - const start = Date.now(); - const { method, url, headers } = ctx.request; - - console.log('\n=== Incoming Request (Raw) ==='); - console.log('Method:', method); - console.log('URL:', url.pathname); - console.log('Content-Type:', headers.get('content-type')); - console.log('Headers:', Object.fromEntries(headers.entries())); - - // Log raw body if available, **except** for `/token` endpoints - if (method === 'POST' && !url.pathname.endsWith('/token')) { - try { - const jsonBody = await ctx.request.body.json(); - console.log('JSON Body:', jsonBody); - } catch (error) { - console.error('Error reading body:', error); - } - } - - await next(); - - const ms = Date.now() - start; - console.log('\n=== Response ==='); - console.log(`Status: ${ctx.response.status}`); - console.log(`Response Time: ${ms}ms`); - console.log('Response Body:', ctx.response.body); - console.log('==================\n'); -}); - -// Static file middleware -const staticFileMiddleware = async (ctx: any, next: any) => { - const path = ctx.request.url.pathname; - if (path === "/" || path === "/index.html") { - try { - const content = await Deno.readTextFile("./index.html"); - ctx.response.type = "text/html"; - ctx.response.body = content; - return; - } catch (err) { - console.error("Error reading index.html:", err); - } - } else if (path === "/script.js") { - try { - const content = await Deno.readTextFile("./script.js"); - ctx.response.type = "application/javascript"; - ctx.response.body = content; - return; - } catch (err) { - console.error("Error reading script.js:", err); - } - } - await next(); -}; - -// List all mock APIs -router.get("/apis", async (ctx) => { - const apis = await getAllApis(); - ctx.response.body = apis; -}); - -// Get single mock API -router.get("/apis/:id", async (ctx) => { - const id = ctx.params.id; - const api = await getApiById(id); - - if (!api) { - ctx.response.status = 404; - ctx.response.body = { error: "API not found" }; - return; - } - - ctx.response.body = api; -}); - -// Create new mock API -router.post("/apis", async (ctx) => { - const body = await ctx.request.body.json(); - const id = crypto.randomUUID(); - - const mockApi: MockApi = { - id, - path: body.path.startsWith("/") ? body.path : `/${body.path}`, - method: body.method.toUpperCase(), - auth: body.auth, - response: body.response, - statusCode: body.statusCode || 200, - createdAt: new Date(), - updatedAt: new Date() - }; - - await kv.set(["apis", id], mockApi); - ctx.response.body = mockApi; -}); - -// Update existing mock API -router.put("/apis/:id", async (ctx) => { - const id = ctx.params.id; - const body = await ctx.request.body.json(); - - const existingApi = await getApiById(id); - if (!existingApi) { - ctx.response.status = 404; - ctx.response.body = { error: "API not found" }; - return; - } - - const mockApi: MockApi = { - ...existingApi, - path: body.path.startsWith("/") ? body.path : `/${body.path}`, - method: body.method.toUpperCase(), - auth: body.auth, - response: body.response, - statusCode: body.statusCode || 200, - updatedAt: new Date() - }; - - await kv.set(["apis", id], mockApi); - ctx.response.body = mockApi; -}); - -// Delete mock API -router.delete("/apis/:id", async (ctx) => { - const id = ctx.params.id; - await kv.delete(["apis", id]); - ctx.response.status = 204; -}); - -// Replace the array-style route with individual routes -router.post("/oauth/token", handleTokenRequest); -router.post("/api/token", handleTokenRequest); - -// Move the handler logic to a separate function -async function handleTokenRequest(ctx: any) { - try { - let body; - const contentType = ctx.request.headers.get('content-type'); - - // Parse body based on content type - if (contentType?.includes('application/x-www-form-urlencoded')) { - const rawBody = await ctx.request.body.text(); - console.log('Raw request body:', rawBody); - body = Object.fromEntries(new URLSearchParams(rawBody)); - } else { - // Attempt to parse as JSON - try { - body = await ctx.request.body.json(); - } catch { - // Fallback to form data if JSON parsing fails - const rawBody = await ctx.request.body.text(); - body = Object.fromEntries(new URLSearchParams(rawBody)); - } - } - - console.log('Parsed body:', body); - - let { grant_type, client_id, client_secret, scope } = body; - - // Try to get credentials from Basic Auth header - const authHeader = ctx.request.headers.get('authorization'); - if (authHeader?.startsWith('Basic ')) { - const base64Credentials = authHeader.split(' ')[1]; - const credentials = atob(base64Credentials).split(':'); - client_id = client_id || credentials[0]; - client_secret = client_secret || credentials[1]; - } - - if (!grant_type) { - ctx.response.status = 400; - ctx.response.body = { error: "invalid_request" }; - return; - } - - if (grant_type === "client_credentials") { - const apis = await getAllApis(); - const matchingApi = apis.find(api => - api.auth.type === "oauth" && - api.auth.tokenEndpoint && - (!client_id || api.auth.allowedClientId === client_id) && - (!client_secret || api.auth.allowedClientSecret === client_secret) - ); - - if (!matchingApi) { - ctx.response.status = 401; - ctx.response.body = { - error: "invalid_client", - error_description: "Client credentials are invalid" - }; - return; - } - - // Handle scopes - const requestedScopes = scope ? scope.split(' ') : []; - const allowedScopes = matchingApi.auth.allowedScopes || []; - - // Validate requested scopes - const invalidScopes = requestedScopes.filter( - (s: string) => !allowedScopes.includes(s) - ); - if (invalidScopes.length > 0) { - ctx.response.status = 400; - ctx.response.body = { - error: "invalid_scope", - error_description: `Invalid scopes requested: ${invalidScopes.join(', ')}` - }; - return; - } - - // Use allowed scopes if none requested - const grantedScopes = requestedScopes.length > 0 ? requestedScopes : allowedScopes; - - const token: OAuthToken = { - access_token: crypto.randomUUID(), - refresh_token: crypto.randomUUID(), - expires_at: Date.now() + 3600000, - client_id, - scopes: grantedScopes - }; - - await storeToken(token); - - ctx.response.body = { - access_token: token.access_token, - token_type: "Bearer", - expires_in: 3600, - scope: grantedScopes.join(' ') - }; - } else { - ctx.response.status = 400; - ctx.response.body = { - error: "unsupported_grant_type", - error_description: "Only client_credentials grant type is supported" - }; - } - } catch (error) { - console.error('Body parsing error:', error); - ctx.response.status = 400; - ctx.response.body = { error: "invalid_request", error_description: "Could not parse request body" }; - return; - } -} - -// Update the validateAuth function to handle OAuth token validation -async function validateAuth(ctx: any, mockApi: MockApi) { - console.log('\n=== Auth Validation Details ==='); - console.log('Auth Type:', mockApi.auth.type); - console.log('Headers:', Object.fromEntries(ctx.request.headers.entries())); - - const headers = ctx.request.headers; - - switch (mockApi.auth.type) { - case "bearer": - const authHeader = headers.get("Authorization"); - console.log('Received Bearer Token:', authHeader?.replace('Bearer ', '')); - console.log('Expected Bearer Token:', mockApi.auth.token); - if (!authHeader || authHeader !== `Bearer ${mockApi.auth.token}`) { - ctx.response.status = 401; - ctx.response.body = { error: "Invalid bearer token" }; - return false; - } - break; - - case "oauth": - const oauthHeader = headers.get("Authorization"); - console.log('Received OAuth Token:', oauthHeader?.replace('Bearer ', '')); - if (!oauthHeader) { - ctx.response.status = 401; - ctx.response.body = { error: "Missing OAuth token" }; - return false; - } - - const token = oauthHeader.replace("Bearer ", ""); - const storedToken = await getToken(token); - - console.log('Stored Token Details:', storedToken ? { - client_id: storedToken.client_id, - scopes: storedToken.scopes, - expires_at: new Date(storedToken.expires_at).toISOString() - } : 'No stored token found'); - - if (mockApi.auth.requiredScopes) { - console.log('Required Scopes:', mockApi.auth.requiredScopes); - } - - if (!storedToken || storedToken.expires_at < Date.now()) { - ctx.response.status = 401; - ctx.response.body = { error: "Invalid or expired OAuth token" }; - return false; - } - - // Validate scopes - if (mockApi.auth.requiredScopes && mockApi.auth.requiredScopes.length > 0) { - const hasRequiredScopes = mockApi.auth.requiredScopes.every( - (scope: string) => storedToken.scopes.includes(scope) - ); - - console.log('Scope Validation:', { - required: mockApi.auth.requiredScopes, - provided: storedToken.scopes, - valid: hasRequiredScopes - }); - - if (!hasRequiredScopes) { - ctx.response.status = 403; - ctx.response.body = { - error: "insufficient_scope", - error_description: `Required scopes: ${mockApi.auth.requiredScopes.join(' ')}` - }; - return false; - } - } - break; - - case "client_credentials": - const clientId = headers.get("client-id"); - const clientSecret = headers.get("client-secret"); - console.log('Client Credentials:', { - received: { clientId, clientSecret }, - expected: { - clientId: mockApi.auth.clientId, - clientSecret: mockApi.auth.clientSecret - } - }); - if (clientId !== mockApi.auth.clientId || clientSecret !== mockApi.auth.clientSecret) { - ctx.response.status = 401; - ctx.response.body = { error: "Invalid client credentials" }; - return false; - } - break; - - case "api_key": - const apiKey = headers.get("x-api-key"); - console.log('API Key:', { - received: apiKey, - expected: mockApi.auth.apiKey - }); - if (apiKey !== mockApi.auth.apiKey) { - ctx.response.status = 401; - ctx.response.body = { error: "Invalid API key" }; - return false; - } - break; - - case "custom_header": - const customHeader = headers.get(mockApi.auth.headerName!); - console.log('Custom Header:', { - name: mockApi.auth.headerName, - received: customHeader, - expected: mockApi.auth.headerValue - }); - if (customHeader !== mockApi.auth.headerValue) { - ctx.response.status = 401; - ctx.response.body = { error: "Invalid custom header" }; - return false; - } - break; - } - - console.log('Authentication Result: Success'); - return true; -} - -// Update the dynamic route handler -router.all("/:path(.*)", async (ctx) => { - const path = ctx.params.path; - const method = ctx.request.method; - - console.log("Requested path:", path); - console.log("Requested method:", method); - - const { api: mockApi, params } = await findApiByPathAndMethod(`/${path}`, method); - - if (!mockApi) { - ctx.response.status = 404; - ctx.response.body = { error: "Mock API not found" }; - return; - } - - const isAuthValid = await validateAuth(ctx, mockApi); - if (!isAuthValid) return; - - // Process response with path parameters - let response = mockApi.response; - if (typeof response === 'object') { - // Replace path parameters in the response - response = JSON.parse(JSON.stringify(response)); // Deep clone - const replaceParams = (obj: any) => { - for (const key in obj) { - if (typeof obj[key] === 'string') { - // Check if the value matches any parameter - for (const paramName in params) { - if (obj[key] === `{${paramName}}` || obj[key].toString() === params[paramName]) { - obj[key] = params[paramName]; - } - } - } else if (typeof obj[key] === 'object' && obj[key] !== null) { - replaceParams(obj[key]); - } - } - }; - replaceParams(response); - } - - ctx.response.status = mockApi.statusCode; - ctx.response.body = response; -}); - -const app = new Application(); - -// Apply CORS -app.use(oakCors()); - -// Apply static file middleware -app.use(staticFileMiddleware); - -// Apply router -app.use(router.routes()); -app.use(router.allowedMethods()); - -// Start the server -console.log("Mock API server running on http://localhost:8000"); -await app.listen({ port: 8000 }); \ No newline at end of file diff --git a/settings.json b/settings.json new file mode 100644 index 0000000..ecb2906 --- /dev/null +++ b/settings.json @@ -0,0 +1,9 @@ +{ + "cursor.cpp.autocomplete": true, + "cursor.general.enableAutoSave": true, + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.fixAll.eslint": true + }, + "typescript.preferences.strict": true + } \ No newline at end of file diff --git a/src/components/MockApiForm.tsx b/src/components/MockApiForm.tsx new file mode 100644 index 0000000..e227342 --- /dev/null +++ b/src/components/MockApiForm.tsx @@ -0,0 +1,1334 @@ +/// +/** @jsxImportSource hono/jsx */ +import type { MockApi } from "../types/MockApi.ts"; + +interface MockApiFormProps { + api?: MockApi; + action: string; + baseUrl?: string; +} + +// Utility function to safely get input elements with null checks +function getInputElement(id: string): HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null { + const element = document.getElementById(id); + return element as HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null; +} + +// FIRST_EDIT: Declare global window functions for TS +declare global { + interface Window { + addHeaderRow: () => void; + handleTestRequest: () => void; + validateForm: () => boolean; + validateField: (field: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement) => boolean; + showValidationError: (field: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, message: string) => void; + clearValidationError: (field: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement) => void; + } +} + +export function MockApiForm({ api, action, baseUrl = "" }: MockApiFormProps) { + const isEdit = Boolean(api); + const defaultJsonResponse = '{\n "message": "Success",\n "data": {}\n}'; + + // Format the currentResponse for display + const responseValue = isEdit + ? api?.response.type === 'json' + ? typeof api?.response.data === 'string' + ? api.response.data + : JSON.stringify(api?.response.data, null, 2) + : String(api?.response.data || '') + : defaultJsonResponse; + + // Use the URL's origin as the base URL for API requests + const apiBaseUrl = `${baseUrl}/api`; + + // Format JSON helper function + const formatJsonBody = () => { + const textarea = getInputElement('body'); + if (!textarea) return; + try { + const json = JSON.parse(textarea.value); + textarea.value = JSON.stringify(json, null, 2); + } catch (e) { + alert('JSON inválido. Não foi possível formatar.'); + } + }; + + // Insert mock data helper function + const insertMockData = () => { + const textarea = getInputElement('body'); + const responseTypeEl = getInputElement('responseType'); + + if (!textarea || !responseTypeEl) return; + + const responseType = responseTypeEl.value; + + if (responseType === 'json') { + textarea.value = JSON.stringify({ + success: true, + data: { + id: "{{uuid}}", + name: "Example Item", + createdAt: "{{date}}", + attributes: ["feature1", "feature2"], + metadata: { + version: "1.0", + api: "{{req.path}}" + } + }, + pagination: { + page: 1, + totalPages: 5, + totalItems: 100, + itemsPerPage: 20 + } + }, null, 2); + } else if (responseType === 'text') { + textarea.value = "Success! Request processed at {{date}}"; + } else if (responseType === 'html') { + textarea.value = "

Example Response

This is a sample HTML response.

"; + } else if (responseType === 'xml') { + textarea.value = '\n\n success\n \n Example\n \n'; + } + }; + + return ( +
+
+
+
+

+ {isEdit ? "Editar API" : "Criar Nova API"} +

+

Configure sua API mock com facilidade

+
+
+ + +
+
+ +
+
+
+ {/* Hidden fields to store existing API values for dynamic fields */} + {isEdit && api?.auth && ( + <> + {api.auth.type === 'bearer' && ( + + )} + {api.auth.type === 'api_key' && ( + <> + + + + + )} + {api.auth.type === 'custom_header' && ( + <> + + + + )} + {api.auth.type === 'basic' && ( + <> + + + + )} + {(api.auth.type === 'oauth' || api.auth.type === 'client_credentials') && ( + <> + + + + + )} + {api.auth.type === 'jwt' && ( + <> + + + + )} + + )} + + {/* Hidden fields for CORS settings */} + {isEdit && api?.cors?.enabled && ( + <> + + + + + + )} + +
+ {/* Left column - Main configuration */} +
+ {/* Configuração Básica Accordion */} +
+ +
+ + settings + + Configuração Básica +
+ expand_more + +
+
+ {/* Path */} +
+ +
+ /api + +
+ +
+
+ + {/* Method */} +
+ + + +
+
+ + {/* Description */} +
+ + +
+ + {/* Active Toggle */} +
+ + +
+
+
+ + {/* Segurança e Autenticação Accordion */} +
+ +
+ + security + + Segurança e Autenticação +
+ expand_more + +
+
+
+ + +
+
+ + +
+ +
+ {/* Auth fields will be loaded dynamically */} +
+ Sem configurações adicionais necessárias para este tipo de autenticação. +
+
+ +
+ {/* CORS fields will be loaded dynamically */} +
+ CORS desabilitado para esta API. +
+
+
+
+
+ + {/* Metadata Accordion */} +
+ +
+ + label + + Metadados +
+ expand_more + +
+
+
+ + +
+
+ + +

Separados por vírgula

+
+
+
+
+
+ + {/* Right column - Response and Behavior */} +
+ {/* Resposta Accordion */} +
+ +
+ + code + + Resposta +
+ expand_more + +
+
+
+ + +
+
+ + +
+
+ + +
+
+ +
+ +
+ +
+ + +
+
+ +
+ info +

+ Suporte para variáveis: {'{{req.path}}'}, + {'{{req.method}}'}, + {'{{date}}'}, etc. +

+
+
+
+
+ + {/* Comportamento e Simulação Accordion */} +
+ +
+ + tune + + Comportamento e Simulação +
+ expand_more + +
+
+
+ + + +
+
+ +
+
+ + +
+
+ 0ms5s10s +
+
+
+ +
+
+ + +
+ +
+ + +
+ 0%50%100% +
+
+ + {/* New Error Codes Configuration Section */} +
+ + +
+ {[400, 401, 403, 404, 409, 422, 429, 500, 502, 503, 504].map(code => { + const isChecked = api?.simulation?.errorStatuses?.includes(code) ?? true; + return ( +
+ + +
+ ); + })} +
+ +
+ + Configuração avançada de erros + +
+

+ Configure respostas personalizadas para cada código de erro simulado. Deixe em branco para usar o padrão. +

+ + {/* Hidden field to store serialized error responses */} + + +
+
+ + +
+
+ +
+ +
+ +
+
+ +
+ +
+ +
+
+ +
+ +
+
+
+
+
+ + {/* Tips card */} +
+

+ lightbulb + Dicas de Simulação +

+
    +
  • + check_circle + Use delay para simular APIs lentas e testar timeouts +
    • +
  • + check_circle + Simule erros de rede para testar a resiliência do seu app +
    • +
  • + check_circle + Combine com códigos de status diferentes para simular cenários reais +
    • +
+
+
+
+
+
+
+ + {/* Action buttons */} +
+ {isEdit && ( + + )} + + close + Cancelar + + +
+
+ + {isEdit && ( +
+ )} +
+ + {/* Templates Tab Content */} +
+
+

Templates de API

+ +
+
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/users'; + methodInput.value = 'GET'; + descriptionInput.value = 'Lista todos os usuários'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + users: [ + { id: 1, name: "João Silva", email: "joao@example.com", role: "admin" }, + { id: 2, name: "Maria Souza", email: "maria@example.com", role: "user" }, + { id: 3, name: "Carlos Pereira", email: "carlos@example.com", role: "user" } + ], + pagination: { + page: 1, + perPage: 10, + total: 3, + pages: 1 + } + }, null, 2); + } + }} + > +
+

API de Usuários

+ CRUD +
+

Endpoints completos para gerenciar usuários (listar, obter, criar, atualizar, excluir)

+
+ +
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/auth'; + methodInput.value = 'GET'; + descriptionInput.value = 'Login, logout, refresh token e registro de usuários'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + success: true, + data: { + token: "{{token}}", + refreshToken: "{{refreshToken}}", + user: { + id: "{{userId}}", + name: "{{userName}}", + email: "{{userEmail}}", + role: "{{userRole}}" + } + } + }, null, 2); + } + }} + > +
+

Autenticação

+ Auth +
+

Endpoints para login, logout, refresh token e registro de usuários

+
+ +
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/products'; + methodInput.value = 'GET'; + descriptionInput.value = 'Listar produtos, filtrar categorias, obter detalhes e preços'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + products: [ + { id: 1, name: "Product 1", category: "Category A", price: 10.00 }, + { id: 2, name: "Product 2", category: "Category B", price: 15.00 }, + { id: 3, name: "Product 3", category: "Category A", price: 20.00 } + ], + pagination: { + page: 1, + perPage: 10, + total: 3, + pages: 1 + } + }, null, 2); + } + }} + > +
+

Produtos

+ E-commerce +
+

API para listar produtos, filtrar categorias, obter detalhes e preços

+
+
+ + {/* Templates de integrações comuns */} +
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/financeiro/pagamentos'; + methodInput.value = 'GET'; + descriptionInput.value = 'Listar transações financeiras'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + transacoes: [ + { id: 1, valor: 1500.50, data: "{{date}}", status: "liquidado" }, + { id: 2, valor: 750.00, data: "{{date}}", status: "pendente" } + ] + }, null, 2); + } + }} + > +
+

ERP Financeiro

+ Financeiro +
+

Integração de transações, saldos e movimentações financeiras

+
+
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/estoque/itens'; + methodInput.value = 'GET'; + descriptionInput.value = 'Listar itens de estoque'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + itens: [ + { id: 1, produto: "Camiseta", quantidade: 100, localizacao: "A1" }, + { id: 2, produto: "Calça", quantidade: 50, localizacao: "B2" } + ] + }, null, 2); + } + }} + > +
+

ERP Estoque

+ Estoque +
+

Gerenciamento de itens, quantidades e localizações

+
+
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/crm/contatos'; + methodInput.value = 'GET'; + descriptionInput.value = 'Listar contatos do CRM'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + contatos: [ + { id: 1, nome: "Ana", email: "ana@empresa.com", empresa: "ACME" }, + { id: 2, nome: "Bruno", email: "bruno@empresa.com", empresa: "Globex" } + ] + }, null, 2); + } + }} + > +
+

CRM - Contatos

+ CRM +
+

Integração de contatos e leads do CRM

+
+
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/rh/folha_ponto'; + methodInput.value = 'GET'; + descriptionInput.value = 'Dados de folha de ponto de funcionários'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + registros: [ + { funcionarioId: 1, data: "{{date}}", entrada: "08:00", saida: "17:00" }, + { funcionarioId: 2, data: "{{date}}", entrada: "09:00", saida: "18:00" } + ] + }, null, 2); + } + }} + > +
+

RH - Folha de Ponto

+ RH +
+

Integração de registros de ponto e horários

+
+
{ + const pathInput = getInputElement('path'); + const methodInput = getInputElement('method'); + const descriptionInput = getInputElement('description'); + const statusCodeInput = getInputElement('statusCode'); + const responseTypeInput = getInputElement('responseType'); + const bodyInput = getInputElement('body'); + if (pathInput && methodInput && descriptionInput && + statusCodeInput && responseTypeInput && bodyInput) { + pathInput.value = '/webhook/pagamentos'; + methodInput.value = 'POST'; + descriptionInput.value = 'Receber notificações de pagamentos'; + statusCodeInput.value = '200'; + responseTypeInput.value = 'json'; + bodyInput.value = JSON.stringify({ + sucesso: true, + evento: "pagamento_recebido", + transacaoId: "{{uuid}}", + valor: 99.90, + data: "{{date}}" + }, null, 2); + } + }} + > +
+

Webhook de Pagamentos

+ Pagamentos +
+

Receber notificações de pagamento em tempo real

+
+
+

Dica: Como usar templates

+

Clique em um template para preencher automaticamente os campos do formulário com exemplos predefinidos. Você pode então personalizar conforme necessário antes de criar a API.

+
+
+
+
+
+ + {/* External script tags */} + + + + + + +
+ ); +} \ No newline at end of file diff --git a/src/components/MockApiList.tsx b/src/components/MockApiList.tsx new file mode 100644 index 0000000..fdaf570 --- /dev/null +++ b/src/components/MockApiList.tsx @@ -0,0 +1,631 @@ +/** @jsxImportSource hono/jsx */ +// Removed: import { jsx, Fragment } from 'hono/jsx'; // Unused +import type { MockApi } from '../types/MockApi.ts'; + +interface MockApiListProps { + apis: MockApi[]; + // other props as needed +} + +function getAuthBadge(auth: MockApi['auth']) { + if (auth.type === 'none') return null; + + const colors: Record = { + 'bearer': 'bg-indigo-100 text-indigo-800', + 'oauth': 'bg-purple-100 text-purple-800', + 'client_credentials': 'bg-purple-100 text-purple-800', + 'api_key': 'bg-blue-100 text-blue-800', + 'custom_header': 'bg-teal-100 text-teal-800', + 'basic': 'bg-orange-100 text-orange-800', + 'jwt': 'bg-violet-100 text-violet-800' + }; + + const labels: Record = { + 'bearer': 'Bearer', + 'oauth': 'OAuth', + 'client_credentials': 'Client Creds', + 'api_key': 'API Key', + 'custom_header': 'Header', + 'basic': 'Basic', + 'jwt': 'JWT' + }; + + return ( + + {labels[auth.type] || auth.type} + + ); +} + +export function SearchControls({ apis }: MockApiListProps) { + // Group APIs by category for the dropdown + const categories = new Map(); + apis.forEach(api => { + const category = api.category || 'Sem Categoria'; + if (!categories.has(category)) { + categories.set(category, []); + } + categories.get(category)!.push(api); + }); + + // Extract unique tags + const allTags = new Set(); + apis.forEach(api => { + if (api.tags) { + api.tags.forEach(tag => allTags.add(tag)); + } + }); + + // Add state for selected APIs using a global variable for SSR/HTMX compatibility + // We'll use a hidden input and a form for export + + return ( +
+
+ {/* Search Input */} +
+
+ search +
+ +
+ + {/* Method Filter */} +
+ +
+ expand_more +
+
+ + {/* Category Filter */} +
+ +
+ expand_more +
+
+ + {/* Import/Export Buttons */} +
+ + + +
+ + {/* New API Button */} +
+ + add + Nova API + +
+
+ + {/* Tags */} + {allTags.size > 0 && ( +
+ {Array.from(allTags).map(tag => ( + + #{tag} + + ))} +
+ )} + + {/* Import API Modal */} + +
+ ); +} + +export function ApiResults({ apis }: MockApiListProps) { + // Group APIs by category + const categories = new Map(); + apis.forEach(api => { + const category = api.category || 'Sem Categoria'; + if (!categories.has(category)) { + categories.set(category, []); + } + categories.get(category)!.push(api); + }); + + // Add state for selected APIs + // Selection state will be handled by DOM/JS, not React state + + if (apis.length === 0) { + return ( +
+

Nenhuma API encontrada

+

Tente ajustar seus filtros ou criar uma nova API

+ + add + Criar primeira API + +
+ ); + } + + return ( +
+ {/* Remove global select all checkbox */} + {Array.from(categories.entries()).map(([category, categoryApis]) => ( +
+
+

{category}

+ + {categoryApis.length} + +
+ +
+ + + + + + + + + + + + {categoryApis.map((api) => ( + + + + + + + ))} + +
+ + MétodoAPIAutenticaçãoAções
+ + +
+
{api.description || api.path}
+
+ {'/api/' + (api.path.startsWith('/') ? api.path.slice(1) : api.path)} +
+ {api.tags && api.tags.length > 0 && ( +
+ {api.tags.map(tag => ( + + #{tag} + + ))} +
+ )} +
+ 		+ {getAuthBadge(api.auth)} + +
+ + edit + +
+ +
+ + + download + +
+
+
+
+ ))} + {/* Inline Test API Modal */} + +
+ ); +} + +export function MockApiListPage({ apis }: MockApiListProps) { + return ( + <> + + + + + ); +} \ No newline at end of file diff --git a/src/components/MockApiPage.tsx b/src/components/MockApiPage.tsx new file mode 100644 index 0000000..42c63cb --- /dev/null +++ b/src/components/MockApiPage.tsx @@ -0,0 +1,133 @@ +/** @jsxImportSource hono/jsx */ + +import type { MockApi, TrafficLog } from '../types/MockApi.ts'; +import { SearchControls, ApiResults } from './MockApiList.tsx'; + +interface MockApiPageProps { + apis: MockApi[]; + logs: TrafficLog[]; +} + +export function MockApiPage({ apis, logs }: MockApiPageProps) { + // Metrics for dashboard tiles + const totalApis = apis.length; + const totalRequests = logs.length; + const methodCounts: Record = {}; + apis.forEach(api => { + methodCounts[api.method] = (methodCounts[api.method] || 0) + 1; + }); + const statusCounts: Record = {}; + logs.forEach(log => { + const group = Math.floor(log.response.status / 100) * 100; + statusCounts[group] = (statusCounts[group] || 0) + 1; + }); + + return ( +
+ {/* Dashboard Tiles */} +
+ {/* Total de APIs */} +
+
+
+

Total de APIs

+

{totalApis}

+
+
+ api +
+
+
+ + Ver todas + arrow_forward + +
+
+ {/* Requisições */} +
+
+
+

Requisições

+

{totalRequests}

+
+
+ sync +
+
+
+ + Ver logs + arrow_forward + +
+
+ {/* Métodos HTTP */} +
+
+
+

Métodos HTTP

+
+ {Object.entries(methodCounts).map(([method, count]) => ( + + {method} ({count}) + + ))} +
+
+
+ http +
+
+
+ + Ver detalhes + arrow_forward + +
+
+ {/* Status HTTP */} +
+
+
+

Status HTTP

+
+ {Object.entries(statusCounts).map(([status, count]) => ( + + {status}s ({count}) + + ))} +
+
+
+ assistant +
+
+
+ + Ver detalhes + arrow_forward + +
+
+
+
+ +
+
+ +
+ {/* Include external script to enable select-all and export-button logic */} + +
+ ); +} \ No newline at end of file diff --git a/src/components/NewLayout.tsx b/src/components/NewLayout.tsx new file mode 100644 index 0000000..5eba927 --- /dev/null +++ b/src/components/NewLayout.tsx @@ -0,0 +1,311 @@ +/** @jsxImportSource hono/jsx */ +// Removed: import { jsx, Fragment } from 'hono/jsx'; // Unused +import type { User } from '../types/User.ts'; // Keep if User prop is planned +import type { JSXNode } from 'hono/jsx/index.ts'; + +interface NewLayoutProps { + title: string; + children: JSXNode | JSXNode[]; + user?: User; + isAuthenticated?: boolean; + extraHead?: JSXNode; + activePath?: string; + breadcrumbs?: Array<{ href?: string; label: string }>; +} + +// Removed user from destructuring as it's not used yet, also extraHead, fullWidth, hideHeader +export function NewLayout({ children, title, activePath = '/', breadcrumbs, extraHead, user, isAuthenticated }: NewLayoutProps) { + // For demonstration, create a mock user - in a real app this would come from your authentication system + // user and isAuthenticated come from central auth introspection middleware + + // Helper to generate nav link classes with special handling for home path + const navLinkClass = (path: string) => { + // For home path, only highlight if exact match + if (path === '/') { + return `nav-link flex items-center gap-1.5 px-3 py-1.5 rounded-md transition-colors ${ + activePath === '/' ? 'text-white bg-white/10' : 'text-gray-300 hover:text-white' + }`; + } + // For other paths, use startsWith to match nested routes + return `nav-link flex items-center gap-1.5 px-3 py-1.5 rounded-md transition-colors ${ + activePath.startsWith(path) ? 'text-white bg-white/10' : 'text-gray-300 hover:text-white' + }`; + }; + + return ( + + + + + {title} - Mock API Studio + + + + + + + + {extraHead} + + + + {/* Header */} +
+
+ +
+ +
+ + {/* Main Content */} +
+ {breadcrumbs && breadcrumbs.length > 0 ? ( +
+ +
+ ) : null} + + {children} +
+ + {/* Footer */} +
+
+ © {new Date().getFullYear()} Mock API Studio - iLiberty. Todos os direitos reservados. +
+
+ + {/* Scripts */} + + + + + + + + ); +} \ No newline at end of file diff --git a/src/config.ts b/src/config.ts new file mode 100644 index 0000000..1b31040 --- /dev/null +++ b/src/config.ts @@ -0,0 +1,13 @@ +import "https://deno.land/std@0.224.0/dotenv/load.ts"; + +export const config = { + authGateway: { + url: Deno.env.get("AUTH_GATEWAY_URL") ?? "http://localhost:8888", + clientId: Deno.env.get("AUTH_CLIENT_ID") ?? "", + clientSecret: Deno.env.get("AUTH_CLIENT_SECRET") ?? "", + redirectUri: Deno.env.get("AUTH_REDIRECT_URI") ?? "", + }, + server: { + port: Number(Deno.env.get("PORT") ?? "8000"), + }, +}; \ No newline at end of file diff --git a/src/config/auth.ts b/src/config/auth.ts new file mode 100644 index 0000000..3322ef2 --- /dev/null +++ b/src/config/auth.ts @@ -0,0 +1,238 @@ +/** + * Authentication configuration for the API Gateway + * Defines which routes use central auth vs API-specific auth + */ + +export interface AuthConfig { + central: CentralAuthConfig; + api: ApiAuthConfig; + routing: RoutingConfig; +} + +export interface CentralAuthConfig { + /** Auth0 URL for central authentication */ + gatewayUrl: string; + /** Routes that require central authentication */ + protectedRoutes: string[]; + /** Routes that are publicly accessible (no auth required) */ + publicRoutes: string[]; +} + +export interface ApiAuthConfig { + /** Route patterns that use API-specific authentication */ + patterns: string[]; + /** Default authentication behavior for APIs */ + defaultBehavior: 'deny' | 'allow'; + /** Skip API authentication for cross-origin requests */ + skipAuthForCrossOrigin: boolean; + /** Skip API authentication for external domains */ + skipAuthForExternalDomains: boolean; + /** Trusted domains that don't require API authentication */ + trustedDomains: string[]; +} + +export interface RoutingConfig { + /** Routes that bypass central auth completely */ + bypassCentralAuth: string[]; + /** Routes that always require central auth regardless of other settings */ + requireCentralAuth: string[]; +} + +/** + * Default authentication configuration + */ +export const authConfig: AuthConfig = { + central: { + gatewayUrl: Deno.env.get("CENTRAL_AUTH_URL") || "http://localhost:8888", + protectedRoutes: [ + "/mock-api/**", + "/traffic/**", + "/admin/**", + "/" + ], + publicRoutes: [ + "/login", + "/logout", + "/callback", + "/health", + "/static/**", + "/favicon.ico" + ] + }, + api: { + // API routes that use their own authentication + patterns: [ + "/api/**", + "/rest/api/**" + ], + defaultBehavior: 'allow', + // Skip API authentication for cross-origin requests + skipAuthForCrossOrigin: true, + // Skip API authentication for external domains + skipAuthForExternalDomains: true, + // Trusted domains that don't require API authentication + trustedDomains: ['*'] // Allow all domains + }, + routing: { + // Routes that completely bypass central authentication + bypassCentralAuth: [ + "/api/**", + "/rest/api/**" + ], + // Routes that must always use central authentication + requireCentralAuth: [ + "/mock-api/**", + "/traffic/**", + "/admin/**" + ] + } +}; + +/** + * Check if a route should bypass central authentication + */ +export function shouldBypassCentralAuth(path: string): boolean { + return authConfig.routing.bypassCentralAuth.some(pattern => { + if (pattern.endsWith('/**')) { + const basePath = pattern.slice(0, -3); + return path.startsWith(basePath); + } + return path === pattern; + }); +} + +/** + * Check if a route requires central authentication + */ +export function requiresCentralAuth(path: string): boolean { + // First check if it should bypass central auth completely + if (shouldBypassCentralAuth(path)) { + return false; + } + + // Check if it's in the public routes + const isPublic = authConfig.central.publicRoutes.some(pattern => { + if (pattern.endsWith('/**')) { + const basePath = pattern.slice(0, -3); + return path.startsWith(basePath); + } + return path === pattern; + }); + + if (isPublic) { + return false; + } + + // Check if it's explicitly required to use central auth + const isRequired = authConfig.routing.requireCentralAuth.some(pattern => { + if (pattern.endsWith('/**')) { + const basePath = pattern.slice(0, -3); + return path.startsWith(basePath); + } + return path === pattern; + }); + + return isRequired; +} + +/** + * Check if a route should use API-specific authentication + */ +export function usesApiAuth(path: string): boolean { + return authConfig.api.patterns.some(pattern => { + if (pattern.endsWith('/**')) { + const basePath = pattern.slice(0, -3); + return path.startsWith(basePath); + } + return path === pattern; + }); +} + +/** + * Check if API authentication should be skipped for cross-origin requests + */ +export function shouldSkipApiAuthForCrossOrigin(request: Request): boolean { + if (!authConfig.api.skipAuthForCrossOrigin) { + return false; + } + + const origin = request.headers.get('Origin'); + const host = request.headers.get('Host'); + + // If there's an Origin header and it's different from the host, it's cross-origin + if (origin && host) { + try { + const originUrl = new URL(origin); + return originUrl.host !== host; + } catch { + return false; + } + } + + return false; +} + +/** + * Check if API authentication should be skipped for external domains + */ +export function shouldSkipApiAuthForExternalDomain(request: Request): boolean { + if (!authConfig.api.skipAuthForExternalDomains) { + return false; + } + + const origin = request.headers.get('Origin'); + const referer = request.headers.get('Referer'); + + // Check if origin or referer is from a trusted domain + if (authConfig.api.trustedDomains.includes('*')) { + return true; // Trust all domains + } + + const checkDomain = origin || referer; + if (checkDomain) { + try { + const url = new URL(checkDomain); + return authConfig.api.trustedDomains.some(domain => { + if (domain === '*') return true; + if (domain.startsWith('*.')) { + const baseDomain = domain.slice(2); + return url.hostname.endsWith(baseDomain); + } + return url.hostname === domain; + }); + } catch { + return false; + } + } + + return false; +} + +/** + * Check if API authentication should be skipped + */ +export function shouldSkipApiAuth(request: Request): boolean { + return shouldSkipApiAuthForCrossOrigin(request) || + shouldSkipApiAuthForExternalDomain(request); +} + +/** + * Get the authentication strategy for a given route + */ +export function getAuthStrategy(path: string): 'central' | 'api' | 'public' { + if (shouldBypassCentralAuth(path)) { + return 'api'; + } + + if (authConfig.central.publicRoutes.some(pattern => { + if (pattern.endsWith('/**')) { + const basePath = pattern.slice(0, -3); + return path.startsWith(basePath); + } + return path === pattern; + })) { + return 'public'; + } + + return 'central'; +} \ No newline at end of file diff --git a/src/controllers/proxyController.ts b/src/controllers/proxyController.ts new file mode 100644 index 0000000..5b8c576 --- /dev/null +++ b/src/controllers/proxyController.ts @@ -0,0 +1,23 @@ +import type { Context } from "hono/mod.ts"; +import { getCookies } from "std/http/cookie.ts"; +import { config } from "../config.ts"; + +const CENTRAL_AUTH_URL = config.authGateway.url; + +export async function proxyIntrospectController(c: Context) { + console.log('[Proxy-introspect] Extracting session token from cookies'); + const cookies = getCookies(c.req.raw.headers); + const token = cookies.session; + console.log('[Proxy-introspect] session token=', token ? token.slice(0,8)+'...' : 'none'); + // Forward as Bearer token to central auth gateway + const gatewayRes = await fetch(`${CENTRAL_AUTH_URL}/api/introspect`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'Authorization': `Bearer ${token}` + } + }); + const data = await gatewayRes.json(); + console.log('[Proxy-introspect] gateway status=', gatewayRes.status, 'body=', data); + return c.json(data, { status: gatewayRes.status }); +} \ No newline at end of file diff --git a/src/controllers/rootController.tsx b/src/controllers/rootController.tsx new file mode 100644 index 0000000..1aa317e --- /dev/null +++ b/src/controllers/rootController.tsx @@ -0,0 +1,50 @@ +import { Context } from "hono/mod.ts"; +import type { Variables } from "../main.tsx"; +import type { TrafficLog } from "../types/MockApi.ts"; +import type { MockApi } from "../types/MockApi.ts"; + +/** + * Controller for the root dashboard route ('/') + * @param c Hono context + */ +export async function dashboardController(c: Context<{ Variables: Variables }>) { + const repo = c.get("mockApiRepository"); + const apis: MockApi[] = await repo.getAllApis(); + const logs: TrafficLog[] = (await repo.getTrafficLogs()).logs; + + // Calculate statistics + const _totalApis = apis.length; + const _totalRequests = logs.length; + + // Group APIs by method + const methodCounts: Record = {}; + apis.forEach((api: MockApi) => { + const method = api.method; + methodCounts[method] = (methodCounts[method] || 0) + 1; + }); + + // Group APIs by auth type + const authCounts: Record = {}; + apis.forEach((api: MockApi) => { + const authType = api.auth.type; + authCounts[authType] = (authCounts[authType] || 0) + 1; + }); + + // Get response code distribution + const statusCounts: Record = {}; + logs.forEach((log: TrafficLog) => { + const statusGroup = Math.floor(log.response.status / 100) * 100; + statusCounts[statusGroup] = (statusCounts[statusGroup] || 0) + 1; + }); + + // Get recent logs + const _recentLogs = logs.slice(0, 5); + + c.set("title", "MockAPI Studio - Dashboard"); + + return c.render( +
+ {/* TODO: Move dashboard JSX content here from main.tsx */} +
+ ); +} \ No newline at end of file diff --git a/src/deps.ts b/src/deps.ts new file mode 100644 index 0000000..4143d30 --- /dev/null +++ b/src/deps.ts @@ -0,0 +1,32 @@ +/** + * deps.ts - Central file for managing dependencies + */ + +// Export Deno types without importing missing modules +export type Kv = Deno.Kv; + +// Export other common utilities +export { + join, + dirname +} from "https://deno.land/std@0.193.0/path/mod.ts"; + +export { + basename +} from "https://deno.land/std@0.193.0/path/mod.ts"; + +export { + Status, + STATUS_TEXT +} from "https://deno.land/std@0.193.0/http/http_status.ts"; + +export { + encode as encodeBase64, + decode as decodeBase64 +} from "https://deno.land/std@0.193.0/encoding/base64.ts"; + +export { + format as formatDate +} from "https://deno.land/std@0.193.0/datetime/format.ts"; + +export { parse as parseYaml } from "https://deno.land/std@0.193.0/yaml/mod.ts"; \ No newline at end of file diff --git a/src/main.tsx b/src/main.tsx new file mode 100644 index 0000000..a233c89 --- /dev/null +++ b/src/main.tsx @@ -0,0 +1,1030 @@ +/** @jsxImportSource hono/jsx */ +// Import Hono TSX-based server (v4) +import { Hono, Context, Next } from "hono/mod.ts"; +import { serve } from "std/http/server.ts"; +import { staticFileMiddleware, staticLoggerMiddleware } from "./middleware/static.ts"; +import { loggerMiddleware } from "./middleware/logger.ts"; +import { applySimulation } from "./utils/simulation.ts"; +import { layoutMiddleware } from "./middleware/layout.tsx"; +import { authIntrospectionMiddleware, dynamicApiAuthMiddleware } from "./middleware/auth.ts"; +import { routingAuthMiddleware, requireAuthMiddleware, apiRouteProtectionMiddleware } from "./middleware/routing.ts"; +import { processTemplateString } from "./utils/templateString.ts"; +import { getRequestBody } from "./utils/requestBody.ts"; +import { proxyIntrospectController } from "./controllers/proxyController.ts"; + +import mockApiApp from "./routes/mockApi.tsx"; +import trafficLogsApp from "./routes/trafficLogs.tsx"; +import { MockApiRepository } from "./services/mockApiService.ts"; +import type { TrafficLog } from "./types/MockApi.ts"; +import { config } from "./config.ts"; +import type { MockApi } from "./types/MockApi.ts"; + +// Central auth service base URL from config +const CENTRAL_AUTH_URL = config.authGateway.url; + +// Define context variables +export type Variables = { + mockApiRepository: MockApiRepository; + user?: { id: string; name: string; isAdmin?: boolean }; + isAuthenticated?: boolean; + apiAuthenticated?: boolean; + authTime?: number; + authError?: string; + isApiRoute?: boolean; + title?: string; + layoutProps?: object; + breadcrumbs?: Array<{ href?: string; label: string }>; +}; + +// Root app +const app = new Hono<{ Variables: Variables }>(); + +// Logger middleware +app.use("*", loggerMiddleware); + +// Static assets - serve first to ensure they have priority +app.use("/static/*", staticFileMiddleware); +app.use("/static/*", staticLoggerMiddleware); + +// Repository setup +app.use("*", async (c: Context<{ Variables: Variables }>, next: Next) => { + c.set("mockApiRepository", new MockApiRepository()); + await next(); +}); + +// Proxy for client-side introspection +app.post('/api/introspect', proxyIntrospectController); + +// API route protection middleware (prevents redirects on API endpoints) +app.use("*", apiRouteProtectionMiddleware); + +// Routing-based authentication middleware +app.use("*", routingAuthMiddleware); + +// Redirect login to central auth +app.get('/login', (c) => { + const urlObj = new URL(c.req.url); + const returnToParam = urlObj.searchParams.get('return_to') || '/'; + const origin = urlObj.origin; + const target = returnToParam.startsWith('http://') || returnToParam.startsWith('https://') + ? returnToParam + : `${origin}${returnToParam}`; + const redirectUrl = `${CENTRAL_AUTH_URL}/login?return_to=${encodeURIComponent(target)}`; + console.log(`[Login] return_to=${returnToParam}, target=${target}, redirectUrl=${redirectUrl}, HTMX=${c.req.header('HX-Request')}`); + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', redirectUrl); + return c.text(''); + } + return c.redirect(redirectUrl); +}); + +// Logout route for HTMX support +app.post('/api/auth/logout', (c) => { + const urlObj = new URL(c.req.url); + const returnToParam = urlObj.searchParams.get('return_to') || '/'; + const origin = urlObj.origin; + const target = returnToParam.startsWith('http://') || returnToParam.startsWith('https://') + ? returnToParam + : `${origin}${returnToParam}`; + const logoutUrl = `${CENTRAL_AUTH_URL}/logout?return_to=${encodeURIComponent(target)}`; + console.log(`[Logout] return_to=${returnToParam}, target=${target}, logoutUrl=${logoutUrl}, HTMX=${c.req.header('HX-Request')}`); + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', logoutUrl); + return c.text(''); + } + return c.redirect(logoutUrl); +}); + +// Consumer callback: proxy Auth0 callback through the central gateway +app.get('/callback', async (c) => { + const urlObj = new URL(c.req.url); + const params = urlObj.searchParams; + const code = params.get('code'); + const state = params.get('state'); + const returnTo = params.get('return_to') || '/'; + console.log(`[Callback] incoming code=${code}, state=${state}, return_to=${returnTo}`); + const gatewayCallback = new URL(`${CENTRAL_AUTH_URL}/callback`); + if (code) gatewayCallback.searchParams.set('code', code); + if (state) gatewayCallback.searchParams.set('state', state); + gatewayCallback.searchParams.set('return_to', returnTo); + console.log(`[Callback] forwarding to gateway: ${gatewayCallback.toString()}`); + const gatewayRes = await fetch(gatewayCallback.toString(), { + headers: { cookie: c.req.header('cookie') || '' }, + redirect: 'manual', + }); + if (gatewayRes.status === 302) { + const location = gatewayRes.headers.get('location')!; + console.log(`[Callback] gateway issued redirect to ${location}`); + // Forward Set-Cookie headers from gateway to client + const responseHeaders = new Headers(); + gatewayRes.headers.forEach((value, key) => { + if (key.toLowerCase() === 'set-cookie') { + // Ensure cookie is valid across .iliberty.com.br subdomains + let cookie = value; + if (!/;\s*Domain=/i.test(cookie)) { + cookie += '; Domain=.iliberty.com.br'; + } + responseHeaders.append('Set-Cookie', cookie); + } + }); + responseHeaders.set('location', location); + return new Response(null, { status: 302, headers: responseHeaders }); + } + console.log(`[Callback] gateway responded status=${gatewayRes.status}, returning body`); + const bodyText = await gatewayRes.text(); + return new Response(bodyText, { status: gatewayRes.status }); +}); + +// Require authentication for protected routes (replaced with more comprehensive middleware) +app.use("*", requireAuthMiddleware); + +// Bypass layout for API routes and HTMX requests, apply layout otherwise +app.use("*", async (c: Context<{ Variables: Variables }>, next: Next) => { + const path = c.req.path; + if ( + path.startsWith('/api/') || + path.startsWith('/rest/api/') || + path.startsWith('/mock-api/export') || + c.req.header('HX-Request') === 'true' + ) { + await next(); + } else { + console.log(`Standard request: ${c.req.method} ${path} - Applying layout.`); + await layoutMiddleware(c, next); + } +}); + +// API Management Routes +app.route("/mock-api", mockApiApp); + +// Traffic Logs Routes +app.route("/traffic", trafficLogsApp); + +// API Endpoints for Traffic Logs +app.get("/api/traffic", async (c) => { + const repo = c.get("mockApiRepository"); + const logs = await repo.getTrafficLogs(); + return c.json(logs); +}); + +app.post("/api/traffic/clear", async (c) => { + const repo = c.get("mockApiRepository"); + const count = await repo.clearTrafficLogs(); + return c.json({ success: true, count }); +}); + +// Debug endpoint to list all APIs in KV +app.get("/api/debug/apis", async (c) => { + const repo = c.get("mockApiRepository"); + const apis = await repo.getAllApis(); + return c.json({ + total: apis.length, + apis: apis.map(api => ({ + id: api.id, + path: api.path, + method: api.method, + active: api.active, + createdAt: api.createdAt + })) + }); +}); + +/** + * Reusable handler for dynamic API endpoints + * Handles both /api/* and /rest/api/* routes + */ +async function handleDynamicApiEndpoint(c: Context<{ Variables: Variables }>, pathPrefix: string) { + const repo = c.get("mockApiRepository"); + const req = c.req; + const url = new URL(req.url); + const method = req.method; + + // Remove the path prefix to get the API path + const path = url.pathname.replace(new RegExp(`^${pathPrefix}`), "") || "/"; + + // Safely extract headers and query for logging without throwing + let safeHeaders: Record = {}; + try { + const hdrs = (req as unknown as { headers?: Headers }).headers; + if (hdrs && typeof hdrs.entries === 'function') { + safeHeaders = Object.fromEntries(hdrs.entries()); + } + } catch (_e) { + console.error('DEBUG: error extracting headers:', _e); + } + let safeQuery: Record = {}; + try { + safeQuery = Object.fromEntries(url.searchParams.entries()); + } catch (_e) { + console.error('DEBUG: error extracting query params:', _e); + } + + // Capture start time for performance metrics + const start = performance.now(); + + // Find matching API via index by path and method + const api = await repo.findApiByPathAndMethod(path, method); + console.log('DEBUG: findApiByPathAndMethod result:', api); + + // Handle preflight requests for CORS + if (method === "OPTIONS") { + const corsApi = api && api.cors?.enabled ? api : null; + + if (corsApi) { + const headers = new Headers(); + headers.set("Access-Control-Allow-Origin", corsApi.cors?.origins?.[0] || "*"); + headers.set("Access-Control-Allow-Methods", corsApi.cors?.allowedMethods?.join(", ") || "GET, POST, PUT, DELETE, PATCH, OPTIONS"); + headers.set("Access-Control-Allow-Headers", corsApi.cors?.allowedHeaders?.join(", ") || "Content-Type, Authorization"); + + if (corsApi.cors?.allowCredentials) { + headers.set("Access-Control-Allow-Credentials", "true"); + } + + if (corsApi.cors?.maxAge) { + headers.set("Access-Control-Max-Age", String(corsApi.cors.maxAge)); + } + + return new Response(null, { + status: 204, + headers + }); + } + } + + // 404 if no API found + if (!api) { + // Generate traffic log for 404 + await repo.storeTrafficLog({ + id: crypto.randomUUID(), + timestamp: Date.now(), + request: { + method, + path, + headers: safeHeaders, + query: safeQuery, + }, + response: { status: 404, headers: {}, body: "Not Found" }, + performance: { total: performance.now() - start, auth: 0, processing: performance.now() - start }, + mockApi: { id: "", path, method, auth: { type: "none" } }, + error: { message: "Endpoint not found" } + }); + + return c.text("Not Found", { status: 404 }); + } + + // Add CORS headers if enabled + const headers = new Headers(); + if (api.cors?.enabled) { + headers.set("Access-Control-Allow-Origin", api.cors.origins?.[0] || "*"); + + if (api.cors.allowCredentials) { + headers.set("Access-Control-Allow-Credentials", "true"); + } + + if (api.cors.exposedHeaders && api.cors.exposedHeaders.length > 0) { + headers.set("Access-Control-Expose-Headers", api.cors.exposedHeaders.join(", ")); + } + } + + // Use dynamic API authentication middleware + const authResult = await dynamicApiAuthMiddleware(c, api); + + // If authentication failed, return proper HTTP error response + if (!authResult.success) { + const authTime = authResult.authTime; + const authError = authResult.error || 'Authentication failed'; + const statusCode = authResult.statusCode || 401; + + // Generate traffic log for auth error + await repo.storeTrafficLog({ + id: crypto.randomUUID(), + timestamp: Date.now(), + request: { + method, + path, + headers: safeHeaders, + query: safeQuery, + }, + response: { + status: statusCode, + headers: Object.fromEntries(headers.entries()), + body: { error: "Unauthorized", message: authError } + }, + performance: { total: performance.now() - start, auth: authTime, processing: 0 }, + mockApi: { id: api.id, path: api.path, method: api.method, auth: api.auth }, + error: { message: authError } + }); + + // Return JSON error response for API endpoints + return c.json( + { + error: "Unauthorized", + message: authError, + timestamp: new Date().toISOString(), + path: path, + method: method + }, + { + status: statusCode, + headers: headers + } + ); + } + + // Get auth timing for metrics + const authTime = authResult.authTime; + + // --- Simulation logic (refactored) --- + const simulationResult = await applySimulation(api.simulation); + // Add simulation metadata headers + headers.set("X-MockAPI-Simulation-Delay", simulationResult.delayApplied.toString()); + headers.set("X-MockAPI-Simulation-Error-Chance", (api.simulation?.errorChance ?? 0).toString()); + if (simulationResult.simulatedError) { + // Indicate simulated error in headers + headers.set("X-MockAPI-Simulation-Error", "true"); + headers.set("X-MockAPI-Simulation-Error-Status", simulationResult.errorStatus?.toString() || ""); + + // Add any custom headers from the simulation result + if (simulationResult.errorHeaders) { + Object.entries(simulationResult.errorHeaders).forEach(([key, value]) => { + headers.set(key, value); + }); + } + + const errorStatus = simulationResult.errorStatus || 503; + const errorBody = simulationResult.errorBody || { error: "Service Unavailable", message: "A network error was simulated." }; + const totalTime = performance.now() - start; + await repo.storeTrafficLog({ + id: crypto.randomUUID(), + timestamp: Date.now(), + request: { + method, + path, + headers: safeHeaders, + query: safeQuery, + }, + response: { status: errorStatus, headers: {}, body: errorBody }, + performance: { total: totalTime, auth: authTime, processing: totalTime - authTime }, + mockApi: { id: api.id, path: api.path, method: api.method, auth: api.auth }, + error: { + message: "Simulated network error", + timing: { + configured: api.simulation?.delay, + actual: simulationResult.delayApplied, + total: totalTime + } + } + }); + return c.json(errorBody, { status: errorStatus, headers }); + } + + // Before final response, indicate no simulated error + headers.set("X-MockAPI-Simulation-Error", "false"); + + // Process dynamic response variables if needed + let responseData = api.response.data; + + // Process response data if it's dynamic + if (api.response.dynamic) { + if (api.response.type === "json" && typeof responseData === "object") { + const processJsonWithVariables = (obj: unknown): unknown => { + if (obj === null) return null; + + if (Array.isArray(obj)) { + return obj.map(item => processJsonWithVariables(item)); + } + + if (typeof obj === "object") { + const newObj: Record = {}; + for (const [key, value] of Object.entries(obj)) { + newObj[key] = processJsonWithVariables(value); + } + return newObj; + } + + if (typeof obj === "string") { + return processTemplateString(obj); + } + + return obj; + }; + + responseData = processJsonWithVariables(responseData); + } else if (typeof responseData === "string") { + responseData = processTemplateString(responseData); + } + } + + // Generate content type based on response type + if (!headers.has("Content-Type")) { + if (api.response.contentType) { + headers.set("Content-Type", api.response.contentType); + } else { + switch (api.response.type) { + case "json": + headers.set("Content-Type", "application/json"); + break; + case "text": + headers.set("Content-Type", "text/plain"); + break; + case "html": + headers.set("Content-Type", "text/html"); + break; + case "xml": + headers.set("Content-Type", "application/xml"); + break; + case "csv": + headers.set("Content-Type", "text/csv"); + break; + default: + headers.set("Content-Type", "application/octet-stream"); + } + } + } + + // Prepare response + const status = api.statusCode; + const totalTime = performance.now() - start; + const processingTime = totalTime - authTime; + + // Log traffic (non-blocking - don't let logging failures affect API response) + try { + await repo.storeTrafficLog({ + id: crypto.randomUUID(), + timestamp: Date.now(), + request: { + method, + path, + headers: safeHeaders, + query: safeQuery, + body: method === 'GET' ? null : await getRequestBody(c.req.raw) + }, + response: { + status, + headers: Object.fromEntries(headers.entries()), + body: responseData + }, + performance: { + total: totalTime, + auth: authTime, + processing: processingTime + }, + mockApi: { + id: api.id, + path: api.path, + method: api.method, + auth: api.auth + } + }); + } catch (error) { + console.error(`Traffic logging failed for ${method} ${path}:`, error); + // Continue with API response even if logging fails + } + + // Return response + if (api.response.type === "json") { + return c.json(responseData, { status, headers }); + } + return c.body(String(responseData), { status, headers }); +} + +// Mock API handler for dynamic endpoints +app.all("/api/*", async (c) => { + return await handleDynamicApiEndpoint(c, "/api"); +}); + +// Mock API handler for /rest/api/* endpoints +app.all("/rest/api/*", async (c) => { + return await handleDynamicApiEndpoint(c, "/rest/api"); +}); + +// Root route with dashboard +app.get("/", async (c) => { + const repo = c.get("mockApiRepository"); + const apis = await repo.getAllApis(); + const logs = (await repo.getTrafficLogs()).logs; + + // Calculate statistics + const totalApis = apis.length; + const totalRequests = logs.length; + + // Group APIs by method + const methodCounts: Record = {}; + apis.forEach(api => { + const method = api.method; + methodCounts[method] = (methodCounts[method] || 0) + 1; + }); + + // Group APIs by auth type + const authCounts: Record = {}; + apis.forEach(api => { + const authType = api.auth.type; + authCounts[authType] = (authCounts[authType] || 0) + 1; + }); + + // Get response code distribution + const statusCounts: Record = {}; + logs.forEach(log => { + const statusGroup = Math.floor(log.response.status / 100) * 100; + statusCounts[statusGroup] = (statusCounts[statusGroup] || 0) + 1; + }); + + // Get recent logs + const recentLogs = logs.slice(0, 5); + + c.set("title", "MockAPI Studio - Dashboard"); + + return c.render( +
+
+
+

MockAPI Studio

+

Uma ferramenta poderosa para simular APIs RESTful

+
+
+ + add + Nova API + +
+
+ + {/* Key Metrics */} +
+
+
+
+

Total de APIs

+

{totalApis}

+
+
+ api +
+
+
+ + Ver todas + arrow_forward + +
+
+ +
+
+
+

Requisições

+

{totalRequests}

+
+
+ sync +
+
+
+ + Ver logs + arrow_forward + +
+
+ +
+
+
+

Métodos HTTP

+
+ {Object.entries(methodCounts).slice(0, 4).map(([method, count]) => ( + + {method} ({count}) + + ))} +
+
+
+ http +
+
+
+ + Ver detalhes + arrow_forward + +
+
+ +
+
+
+

Status HTTP

+
+ {Object.entries(statusCounts).slice(0, 4).map(([statusGroup, count]) => ( + + {statusGroup}s ({count}) + + ))} +
+
+
+ assistant +
+
+
+ + Ver detalhes + arrow_forward + +
+
+
+ + {/* Main Content Area */} +
+ {/* Left column: Features */} +
+
+

Funcionalidades

+ +
+
+
+ cloud_sync +
+
+

APIs RESTful

+

Crie APIs com suporte a todos os métodos HTTP: GET, POST, PUT, DELETE, etc.

+
+
+ +
+
+ security +
+
+

Autenticação

+

Bearer Token, API Key, Basic Auth, OAuth, JWT e outros métodos de autenticação.

+
+
+ +
+
+ assessment +
+
+

Monitoramento

+

Acompanhe todas as requisições com logs detalhados e métricas de performance.

+
+
+ +
+
+ science +
+
+

Simulação

+

Simule latência, erros de rede e respostas personalizadas para testar cenários reais.

+
+
+ +
+
+ travel_explore +
+
+

CORS

+

Configure cabeçalhos CORS para permitir acesso de origens específicas.

+
+
+ +
+
+ auto_fix_high +
+
+

Respostas Dinâmicas

+

Crie respostas com dados dinâmicos usando variáveis e templates.

+
+
+
+
+ + {/* Recent APIs */} +
+
+

APIs Recentes

+ Ver todas +
+ + {apis.length === 0 ? ( +
+

Nenhuma API configurada ainda

+ Criar sua primeira API +
+ ) : ( +
+ + + + + + + + + + + {apis.slice(0, 5).map((api) => ( + + + + + + + ))} + +
MétodoPathStatusAções
+ + {api.method} + + +
/api{api.path}
+ 		+ = 200 && api.statusCode < 300 ? 'bg-green-100 text-green-800' : + api.statusCode >= 300 && api.statusCode < 400 ? 'bg-blue-100 text-blue-800' : + api.statusCode >= 400 && api.statusCode < 500 ? 'bg-yellow-100 text-yellow-800' : + 'bg-red-100 text-red-800'}` + }> + {api.statusCode} + + + + edit + + + play_arrow + +
+
+ )} +
+
+ + {/* Right column: Activity and Help */} +
+ {/* Recent Activity */} +
+

Atividade Recente

+ + {logs.length === 0 ? ( +
+

Nenhuma requisição processada ainda

+

As requisições aparecerão aqui quando suas APIs forem utilizadas

+
+ ) : ( +
+ {recentLogs.map((log) => ( +
+
+
+ + {log.request.method} + + = 200 && log.response.status < 300 ? 'bg-green-100 text-green-800' : + log.response.status >= 300 && log.response.status < 400 ? 'bg-blue-100 text-blue-800' : + log.response.status >= 400 && log.response.status < 500 ? 'bg-yellow-100 text-yellow-800' : + 'bg-red-100 text-red-800'}` + }> + {log.response.status} + +
+
+ {new Date(log.timestamp).toLocaleTimeString()} +
+
+
+ /api{log.request.path} +
+
+ Tempo: {log.performance.total.toFixed(2)}ms +
+
+ ))} + +
+ + Ver todos os logs + arrow_forward + +
+
+ )} +
+ + {/* Quick Start */} +
+

Guia Rápido

+ +
+
+
1
+
+

Crie uma API

+

Defina o método HTTP, caminho, código de status e a resposta desejada.

+
+
+ +
+
2
+
+

Configure opções avançadas

+

Adicione autenticação, configurações CORS e comportamentos de simulação.

+
+
+ +
+
3
+
+

Teste sua API

+

Acesse http://localhost:8000/api/seu-caminho ou use a aba "Testar API".

+
+
+ +
+
4
+
+

Monitore requisições

+

Acompanhe todas as requisições através dos logs de tráfego.

+
+
+
+ +
+ + Criar primeira API + +
+
+
+
+
+ ); +}); + +// Redirect / to /mock-api (comment this line since we now have a dashboard) +// app.get("/", (c) => c.redirect("/mock-api")); + +// Run the server +console.log(`Server running on http://localhost:${config.server.port}`); +serve(app.fetch, { port: config.server.port }); + +// Function to format date for traffic logs display +function formatDate(timestamp: number): string { + const date = new Date(timestamp); + return date.toLocaleString(); +} + +// Process traffic logs for the UI +function _processTrafficLogs(logs: TrafficLog[]): unknown[] { + return logs.map((log: TrafficLog) => { + return { + ...log, + formattedDate: formatDate(log.timestamp) + }; + }); +} + +// --- Postman Collection Export Route --- +app.get("/mock-api/:id/postman-collection", async (c) => { + const repo = c.get("mockApiRepository"); + const api = await repo.getApiById(c.req.param("id")); + if (!api) return c.text("API not found", 404); + + // Generate Postman Collection JSON + const collection = generatePostmanCollection(api, c); + + // Serve as downloadable file + const filename = `postman-${api.method}-${api.path.replace(/\//g, "_")}.json`; + c.header("Content-Disposition", `attachment; filename=\"${filename}\"`); + c.header("Content-Type", "application/json"); + return c.body(JSON.stringify(collection, null, 2)); +}); + +function generatePostmanCollection(api: MockApi, c: Context<{ Variables: Variables }>) { + // Determine base URL (protocol + host + /api) + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}/api`; + // Compose full endpoint path + const endpoint = api.path.startsWith("/") ? api.path : `/${api.path}`; + + // Auth mapping + let auth: Record | undefined = undefined; + const headers: Array<{ key: string; value: string; description?: string }> = []; + const query: Array<{ key: string; value: string; description?: string }> = []; + if (api.auth && api.auth.type !== "none") { + switch (api.auth.type) { + case "bearer": + case "jwt": + auth = { + type: "bearer", + bearer: [ + { key: "token", value: api.auth.token || "", type: "string" } + ] + }; + break; + case "basic": + auth = { + type: "basic", + basic: [ + { key: "username", value: api.auth.username || "", type: "string" }, + { key: "password", value: api.auth.password || "", type: "string" } + ] + }; + break; + case "api_key": + if (api.auth.apiKeyInQuery) { + query.push({ key: api.auth.headerName || "apikey", value: api.auth.apiKey || "", description: "API Key" }); + } else { + headers.push({ key: api.auth.headerName || "X-API-Key", value: api.auth.apiKey || "", description: "API Key" }); + } + break; + case "custom_header": + headers.push({ key: api.auth.headerName || "", value: api.auth.headerValue || "", description: "Custom Header" }); + break; + } + } + + // Add CORS headers if needed (optional, for demo) + if (api.cors && api.cors.enabled) { + headers.push({ key: "Origin", value: api.cors.origins?.[0] || "*", description: "CORS Origin" }); + } + + // Compose request body if needed + let body: unknown = undefined; + if (api.method !== "GET" && api.response && api.response.data) { + if (api.response.type === "json") { + body = { + mode: "raw", + raw: typeof api.response.data === "string" ? api.response.data : JSON.stringify(api.response.data, null, 2), + options: { raw: { language: "json" } } + }; + } else if (api.response.type === "text") { + body = { + mode: "raw", + raw: String(api.response.data) + }; + } + // Add more types as needed + } + + // Compose the Postman Collection object + return { + info: { + name: `MockAPI: ${api.method} ${endpoint}`, + schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", + description: api.description || "Exported from MockAPI Studio" + }, + item: [ + { + name: `${api.method} ${endpoint}`, + request: { + method: api.method, + header: headers, + url: { + raw: `${baseUrl}${endpoint}` + (query.length ? `?${query.map(q => `${q.key}=${q.value}`).join("&")}` : ""), + protocol: url.protocol.replace(":", ""), + host: url.host.split("."), + port: url.port || undefined, + path: ["api", ...endpoint.replace(/^\//, "").split("/")], + query: query.length ? query : undefined + }, + ...(body ? { body } : {}), + ...(auth ? { auth } : {}) + }, + response: [] + } + ] + }; +} \ No newline at end of file diff --git a/src/middleware/auth.ts b/src/middleware/auth.ts new file mode 100644 index 0000000..b767005 --- /dev/null +++ b/src/middleware/auth.ts @@ -0,0 +1,84 @@ +import type { Context, Next } from "hono/mod.ts"; +import { config } from "../config.ts"; +import type { MockApi, AuthConfig } from "../types/MockApi.ts"; +import { ApiAuthService, type ApiAuthResult } from "../services/apiAuthService.ts"; + +const CENTRAL_AUTH_URL = config.authGateway.url; + +/** + * Middleware for central auth introspection (for UI screens) + */ +export async function authIntrospectionMiddleware(c: Context, next: Next) { + console.log(`[Introspect] Request URL=${c.req.url}, Authorization=${c.req.header('Authorization')}, Cookie=${c.req.header('Cookie')}`); + let token: string | null = null; + const authHeader = c.req.header('Authorization'); + if (authHeader && authHeader.startsWith('Bearer ')) { + token = authHeader.replace('Bearer ', ''); + } else { + const cookieHeader = c.req.header('Cookie'); + if (cookieHeader) { + const cookies = Object.fromEntries(cookieHeader.split(';').map(pair => { + const [k, v] = pair.trim().split('='); + return [k, v]; + })); + token = cookies['session'] || cookies['access_token'] || null; + } + } + console.log(`[Introspect] Extracted token=${token ? token.slice(0,8)+"..." : 'none'}`); + if (token) { + try { + const introspectRes = await fetch(`${CENTRAL_AUTH_URL}/api/introspect`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'Authorization': `Bearer ${token}` + } + }); + console.log(`[Introspect] /api/introspect HTTP status=${introspectRes.status}`); + if (introspectRes.ok) { + const data = await introspectRes.json(); + console.log('[Introspect] Response data:', data); + if (data.active) { + console.log('[Introspect] Token active, user=', data.user); + c.set('user', data.user); + c.set('isAuthenticated', true); + } else { + console.log('[Introspect] Token inactive'); + c.set('isAuthenticated', false); + } + } else { + console.log('[Introspect] /api/introspect returned non-OK'); + c.set('isAuthenticated', false); + } + } catch (e) { + console.error('[Introspect] Error calling /api/introspect:', e); + c.set('isAuthenticated', false); + } + } else { + console.log('[Introspect] No token found, marking unauthenticated'); + c.set('isAuthenticated', false); + } + await next(); +} + +/** + * Authentication middleware for dynamic APIs + * Uses the individual API's authentication configuration instead of central auth + * Returns HTTP errors instead of redirecting to login screens + */ +export async function dynamicApiAuthMiddleware(c: Context, api: MockApi): Promise { + const authService = new ApiAuthService(); + const result = await authService.authenticate(c, api); + + // Set context variables for compatibility + c.set('apiAuthenticated', result.success); + c.set('authTime', result.authTime); + + if (!result.success) { + c.set('authError', result.error); + } + + return result; +} + + \ No newline at end of file diff --git a/src/middleware/layout.tsx b/src/middleware/layout.tsx new file mode 100644 index 0000000..99442cd --- /dev/null +++ b/src/middleware/layout.tsx @@ -0,0 +1,21 @@ +import { jsxRenderer, useRequestContext } from "hono/jsx-renderer"; +import { NewLayout } from "../components/NewLayout.tsx"; +import type { Context } from "hono/mod.ts"; +import type { JSXNode } from "hono/jsx"; + +// Layout middleware for non-API, non-HTMX requests +export const layoutMiddleware = jsxRenderer( + (props: Record, _c: Context) => { + const ctx = useRequestContext(); + return NewLayout({ + title: props.title || ctx.get("title") || "MockAPI Studio", + breadcrumbs: props.breadcrumbs || ctx.get("breadcrumbs"), + activePath: new URL(ctx.req.url).pathname, + children: props.children as JSXNode | JSXNode[] | undefined ?? [], + extraHead: props.extraHead as JSXNode | undefined, + user: ctx.get('user'), + isAuthenticated: ctx.get('isAuthenticated'), + }); + }, + { docType: "" } +); \ No newline at end of file diff --git a/src/middleware/logger.ts b/src/middleware/logger.ts new file mode 100644 index 0000000..327e477 --- /dev/null +++ b/src/middleware/logger.ts @@ -0,0 +1,4 @@ +import { logger } from "hono/middleware.ts"; + +// Logger middleware for all requests +export const loggerMiddleware = logger(); \ No newline at end of file diff --git a/src/middleware/routing.ts b/src/middleware/routing.ts new file mode 100644 index 0000000..e8ef201 --- /dev/null +++ b/src/middleware/routing.ts @@ -0,0 +1,123 @@ +import type { Context, Next } from "hono/mod.ts"; +import { authIntrospectionMiddleware } from "./auth.ts"; +import { shouldBypassCentralAuth, requiresCentralAuth, getAuthStrategy } from "../config/auth.ts"; + +/** + * Routing middleware that applies central authentication only to UI routes + * API routes (/api/*) bypass central auth and use their own authentication + * This middleware ensures strict separation of concerns: + * - UI routes: Central authentication with login redirects + * - API routes: Dynamic authentication with HTTP errors + */ +export async function routingAuthMiddleware(c: Context, next: Next) { + const path = c.req.path; + const authStrategy = getAuthStrategy(path); + + console.log(`[Routing] Path: ${path}, Strategy: ${authStrategy}`); + + // Skip central authentication for API routes and public routes + if (shouldBypassCentralAuth(path)) { + console.log(`[Routing] Route bypasses central auth: ${path}`); + // Mark that this is an API route for downstream middleware + c.set('isApiRoute', true); + await next(); + return; + } + + // Apply central authentication for protected routes + if (authStrategy === 'central') { + console.log(`[Routing] Applying central auth for: ${path}`); + // Mark that this is a UI route for downstream middleware + c.set('isApiRoute', false); + await authIntrospectionMiddleware(c, next); + return; + } + + // Public routes don't need authentication + console.log(`[Routing] Public route, no auth required: ${path}`); + c.set('isApiRoute', false); + await next(); +} + +/** + * Middleware to check if user is authenticated for protected UI routes + * This middleware ensures that: + * - API routes are never redirected to login screens + * - UI routes get proper authentication handling + */ +export async function requireAuthMiddleware(c: Context, next: Next) { + const path = c.req.path; + const authStrategy = getAuthStrategy(path); + const isApiRoute = c.get('isApiRoute') || false; + + // API routes handle their own authentication and should never be redirected + if (authStrategy === 'api' || isApiRoute) { + console.log(`[Auth] API route detected, skipping central auth check: ${path}`); + await next(); + return; + } + + // Skip auth check for public routes + if (authStrategy === 'public') { + await next(); + return; + } + + // For central auth routes, check if user is authenticated + if (authStrategy === 'central') { + const isAuthenticated = c.get('isAuthenticated'); + + if (!isAuthenticated) { + console.log(`[Auth] Unauthenticated access to protected UI route: ${path}`); + + const returnTo = encodeURIComponent(path); + const redirectUrl = `/login?return_to=${returnTo}`; + + // For HTMX requests, return redirect header + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', redirectUrl); + return c.text('Unauthorized', { status: 401 }); + } + + // For regular requests, redirect to login + return c.redirect(redirectUrl); + } + } + + await next(); +} + +/** + * Middleware to ensure API routes never get login redirects + * This is a safety net to prevent any accidental redirects on API endpoints + */ +export async function apiRouteProtectionMiddleware(c: Context, next: Next) { + const path = c.req.path; + + // Check if this is an API route pattern + const isApiEndpoint = path.startsWith('/api/') || path.startsWith('/rest/api/'); + + if (isApiEndpoint) { + console.log(`[API Protection] Protecting API route from redirects: ${path}`); + + // Override any redirect behavior by intercepting the response + const originalRedirect = c.redirect; + c.redirect = (url: string, status?: number) => { + console.log(`[API Protection] Blocked redirect attempt on API route ${path} to ${url}`); + return c.json( + { + error: 'Unauthorized', + message: 'API endpoints do not support redirects. Please provide proper authentication.', + timestamp: new Date().toISOString(), + path: path + }, + { status: 401 } + ); + }; + + // Also mark this as an API route + c.set('isApiRoute', true); + } + + await next(); +} \ No newline at end of file diff --git a/src/middleware/static.ts b/src/middleware/static.ts new file mode 100644 index 0000000..4a2ded2 --- /dev/null +++ b/src/middleware/static.ts @@ -0,0 +1,11 @@ +import { serveStatic } from "hono/middleware.ts"; +import type { Context, Next } from "hono/mod.ts"; + +// Static file serving middleware +export const staticFileMiddleware = serveStatic({ root: "./" }); + +// Logger for static file requests +export async function staticLoggerMiddleware(c: Context, next: Next) { + console.log(`[Static] ${c.req.method} ${new URL(c.req.url).pathname}`); + await next(); +} \ No newline at end of file diff --git a/src/routes/mockApi.tsx b/src/routes/mockApi.tsx new file mode 100644 index 0000000..433bce0 --- /dev/null +++ b/src/routes/mockApi.tsx @@ -0,0 +1,1420 @@ +/** @jsxImportSource hono/jsx */ +import { Hono } from 'hono/mod.ts'; +import { MockApiPage } from "../components/MockApiPage.tsx"; +import { MockApiForm } from "../components/MockApiForm.tsx"; +import type { MockApi, AuthConfig, ResponseType } from "../types/MockApi.ts"; +import { ApiResults } from "../components/MockApiList.tsx"; +import type { Variables } from "../main.tsx"; + +// Initialize the routes +const mockApi = new Hono<{ Variables: Variables }>(); + +// Main page - list of APIs +mockApi.get('/', async (c) => { + const mockApiRepo = c.get('mockApiRepository'); + const apis = await mockApiRepo.getAllApis(); + const logs = (await mockApiRepo.getTrafficLogs()).logs; + + // Get notification parameters from URL + const success = c.req.query('success'); + const error = c.req.query('error'); + const imported = c.req.query('imported'); + const skipped = c.req.query('skipped'); + const failed = c.req.query('failed'); + const message = c.req.query('message'); + + // Determine if we should show a notification + let notification = null; + + if (success === 'import-complete') { + notification = { + type: 'success', + title: 'Importação concluída', + message: `${imported} APIs importadas, ${skipped} ignoradas (já existentes) e ${failed} falhas.` + }; + } else if (error === 'import-failed') { + notification = { + type: 'error', + title: 'Falha na importação', + message: message || 'Ocorreu um erro ao importar as APIs.' + }; + } else if (error === 'no-file') { + notification = { + type: 'error', + title: 'Arquivo não selecionado', + message: 'Selecione um arquivo JSON para importar.' + }; + } else if (error === 'invalid-json') { + notification = { + type: 'error', + title: 'Arquivo inválido', + message: 'O arquivo não contém JSON válido.' + }; + } else if (error === 'export-failed') { + notification = { + type: 'error', + title: 'Falha na exportação', + message: 'Ocorreu um erro ao exportar as APIs.' + }; + } + + c.set('title', 'APIs'); + return c.render( + <> + {notification && ( +
+
+
+ + {notification.type === 'success' ? 'check_circle' : 'error'} + +
+
+

{notification.title}

+
+

{notification.message}

+
+
+
+
+ +
+
+
+
+ )} + + + ); +}); + +// HTMX search/filter handler - Moved BEFORE '/:id' to ensure correct matching +mockApi.get('/search', async (c) => { + console.log("--- /mock-api/search handler accessed ---"); + const mockApiRepo = c.get('mockApiRepository'); + let apis = await mockApiRepo.getAllApis(); + + const searchQuery = c.req.query('q') || ''; + const methodFilter = c.req.query('method-filter') || ''; + const categoryFilter = c.req.query('category-filter') || ''; + const tagFilter = c.req.query('tag') || ''; + + if (searchQuery) { + const query = searchQuery.toLowerCase(); + apis = apis.filter(api => + api.path.toLowerCase().includes(query) || + (api.description || '').toLowerCase().includes(query) + ); + } + if (methodFilter) { + apis = apis.filter(api => api.method === methodFilter); + } + if (categoryFilter) { + apis = apis.filter(api => (api.category || 'Sem Categoria') === categoryFilter); + } + if (tagFilter) { + apis = apis.filter(api => api.tags?.includes(tagFilter)); + } + + return c.html(); +}); + +// HTMX handler for auth fields +mockApi.get('/auth-fields', (c) => { + const authType = c.req.query('type') || c.req.query('authType') || 'none'; + const token = c.req.query('token') || ''; + const apiKey = c.req.query('apiKey') || ''; + const headerName = c.req.query('headerName') || ''; + const headerValue = c.req.query('headerValue') || ''; + const username = c.req.query('username') || ''; + const password = c.req.query('password') || ''; + const clientId = c.req.query('clientId') || ''; + const clientSecret = c.req.query('clientSecret') || ''; + const allowedScopes = c.req.query('allowedScopes') || ''; + const requiredScopes = c.req.query('requiredScopes') || ''; + const apiKeyInQuery = c.req.query('apiKeyInQuery') === 'true'; + console.log('Auth fields request:', { + authType, + token, + apiKey, + headerName, + headerValue, + username, + password, + clientId, + clientSecret, + allowedScopes, + requiredScopes, + apiKeyInQuery + }); + + switch (authType) { + case 'bearer': + return c.html( +
+ + + +
+ ); + case 'api_key': + return c.html( + <> +
+
+ + + +
+
+ + + +
+
+
+ +
+ + ); + case 'custom_header': + return c.html( +
+
+ + + +
+
+ + + +
+
+ ); + case 'basic': + return c.html( +
+
+ + + +
+
+ + + +
+
+ ); + case 'oauth': + case 'client_credentials': + return c.html( +
+
+
+ + +
+
+ + +
+
+
+ + +
+
+ ); + case 'jwt': + return c.html( +
+
+ + +
+
+ + +
+
+ ); + default: + return c.html( +
Nenhuma configuração necessária para autenticação.
+ ); + } +}); + +// Add a new HTMX endpoint to check for duplicate path+method combinations +mockApi.get('/check-duplicate', async (c) => { + const path = c.req.query('path') || ''; + const method = c.req.query('method') || 'GET'; + const currentId = c.req.query('id') || ''; + + // Don't check if path is empty + if (!path) { + return c.html(''); + } + + console.log('Checking duplicate:', { path, method, currentId }); + + const repo = c.get('mockApiRepository'); + const existingApi = await repo.findApiByPathAndMethod(path, method); + + if (existingApi && existingApi.id !== currentId) { + return c.html(` +
+ warning +
+

+ Esta API já existe: ${method} ${path} +

+ + Ver ou editar API existente + +
+
+ `); + } + + return c.html(''); +}); + +// HTMX handler for CORS fields +mockApi.get('/cors-fields', (c) => { + const enabled = (c.req.query('value') || c.req.query('corsEnabled')) === 'true'; + console.log('CORS fields request:', { enabled }); + + if (!enabled) { + return c.html(
CORS desabilitado para esta API.
); + } + + const origins = c.req.query('corsOrigins') || '*'; + const headersVal = c.req.query('corsHeaders') || ''; // Renamed to avoid conflict with Headers class + const methods = c.req.query('corsMethods') || ''; + const allowCredentials = c.req.query('corsCredentials') === 'true'; + + return c.html( +
+
+ + +

Use * para permitir qualquer origem

+
+
+
+ + +
+
+ + +
+
+
+ + +
+
+ ); +}); + +// HTMX handler for response fields +mockApi.get('/response-fields', (c) => { + const type = c.req.query('type') || 'json'; + const body = c.req.query('body') || ''; + + // Build HTML string directly to avoid TSX parsing issues + const html = ` + +
+ +
+ ${type === 'json' ? `` : ''} + +
+
+

+ Suporte para variáveis: {{req.path}}, {{req.method}}, {{date}}, etc. +

+ `; + return c.html(html); +}); + +// HTMX handler for testing endpoints +mockApi.post('/test-endpoint', async (c) => { + try { + const apiPath = c.req.query('path') || '/'; + const method = c.req.query('method') || 'GET'; + const body = await c.req.text(); + const startTime = performance.now(); + + // Create tabs structure for response + let responseHTML = ` +
+
`; + + // Request details + let requestDetails = ` +
+
+
+ north_east + Request +
+ ${new Date().toLocaleTimeString()} +
+
+ ${method} + /api${apiPath} +
`; + + if (body) { + try { + const jsonBody = JSON.parse(body); + requestDetails += ` +
+ ${JSON.stringify(jsonBody, null, 2)} +
`; + } catch (_e) { + requestDetails += ` +
+ ${body} +
`; + } + } + requestDetails += `
`; + + responseHTML += requestDetails; + + const mockApiRepo = c.get('mockApiRepository'); + const apis = await mockApiRepo.getAllApis(); + const api = apis.find(a => (a.method === method || a.method === "*") && a.path === apiPath); + + if (!api) { + return c.html(` +
+
+ ${requestDetails} +
+
+ south_east + Response +
+ 404 Not Found +
+
+ error_outline +
+

API não encontrada

+

Endpoint não encontrado. Crie primeiro o endpoint antes de testá-lo.

+ Criar nova API +
+
+
+
+ + + + + `); + } + + // Apply simulation delay + let _appliedDelay = 0; + if (api.simulation?.delay) { + const delayStart = performance.now(); + await new Promise(r => setTimeout(r, api.simulation?.delay || 0)); + _appliedDelay = performance.now() - delayStart; + } + + // Simulate network errors if enabled + if (api.simulation?.networkErrors && Math.random() * 100 < (api.simulation.errorChance || 10)) { + const endTime = performance.now(); + const processingTime = endTime - startTime; + + return c.html(` +
+
+ ${requestDetails} +
+
+ south_east + Response +
+ Simulated Error +
+
+ error_outline +
+

Erro de rede simulado

+

A solicitação falhou devido à simulação de erro configurada nesta API.

+

Chance de erro configurada: ${api.simulation.errorChance || 10}%

+

Tempo total de processamento: ${processingTime.toFixed(2)}ms

+
+
+
+
+ + + + + `); + } + + // Process response + let responseContent; + let responseData; + + if (api.response.type === 'json') { + try { + responseData = typeof api.response.data === 'string' + ? JSON.parse(api.response.data) + : api.response.data; + + responseContent = ` +
+ ${JSON.stringify(responseData, null, 2)} +
`; + } catch (_e) { + responseContent = ` +
+ ${JSON.stringify({error: "Erro ao analisar JSON"}, null, 2)} +
`; + } + } else { + responseContent = ` +
+ ${api.response.data} +
`; + } + + const endTime = performance.now(); + const processingTime = endTime - startTime; + + // Generate headers tab content + const headersContent = ` + `; + + // Generate configuration tab content + const configContent = ` + `; + + // Complete the response HTML + responseHTML += ` +
+
+ south_east + Response +
+
+ ${api.statusCode} ${getStatusText(api.statusCode)} + ${processingTime.toFixed(2)}ms +
+
+ ${responseContent} +
+
+ + ${headersContent} + ${configContent}`; + + return c.html(responseHTML); + } catch (error) { + return c.html(` +
+ error_outline +
+

Erro ao testar endpoint

+

${(error as Error).message || "Erro desconhecido"}

+
+
+ `); + } +}); + +// Helper function to get status text +function getStatusText(code: number): string { + const statusTexts: Record = { + 200: 'OK', + 201: 'Created', + 202: 'Accepted', + 204: 'No Content', + 301: 'Moved Permanently', + 302: 'Found', + 304: 'Not Modified', + 400: 'Bad Request', + 401: 'Unauthorized', + 403: 'Forbidden', + 404: 'Not Found', + 409: 'Conflict', + 422: 'Unprocessable Entity', + 429: 'Too Many Requests', + 500: 'Internal Server Error', + 502: 'Bad Gateway', + 503: 'Service Unavailable', + 504: 'Gateway Timeout' + }; + return statusTexts[code] || ''; +} + +// Create new API handler +mockApi.post('/new', async (c) => { + const repo = c.get('mockApiRepository'); + const form = await c.req.formData(); + console.log('Creating API with form data:', Object.fromEntries(form.entries())); + + try { + const method = String(form.get('method') || 'GET'); + // Normalize path to ensure it starts with a slash + const rawPath = String(form.get('path') || '/'); + const path = rawPath.startsWith('/') ? rawPath : `/${rawPath}`; + const description = String(form.get('description') || ''); + const statusCode = Number(form.get('statusCode') || 200); + // Extract simulation delay from number input or range input + const simDelay = Number(form.get('simDelay') ?? form.get('simDelayRange') ?? 0); + const responseType = String(form.get('responseType') || 'json'); + const contentType = form.get('contentType') ? String(form.get('contentType')) : undefined; + const bodyText = String(form.get('body') || ''); + + const authType = String(form.get('authType') || 'none'); + const auth: AuthConfig = { type: authType as AuthConfig["type"] }; + + if (authType === 'bearer') { + auth.token = String(form.get('token') || ''); + } else if (authType === 'api_key') { + auth.headerName = String(form.get('headerName') || 'X-API-Key'); + auth.apiKey = String(form.get('apiKey') || ''); + auth.apiKeyInQuery = form.get('apiKeyInQuery') === 'true'; + } else if (authType === 'custom_header') { + auth.headerName = String(form.get('headerName') || ''); + auth.headerValue = String(form.get('headerValue') || ''); + } else if (authType === 'basic') { + auth.username = String(form.get('username') || ''); + auth.password = String(form.get('password') || ''); + } else if (authType === 'oauth' || authType === 'client_credentials') { + auth.clientId = String(form.get('clientId') || ''); + auth.clientSecret = String(form.get('clientSecret') || ''); + const scopesValue = String(form.get('allowedScopes') || ''); + if (scopesValue) { + const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g; + const scopes: string[] = []; + let match; + while ((match = regex.exec(scopesValue)) !== null) { + if (match[1]) scopes.push(match[1]); + else if (match[2]) scopes.push(match[2]); + else scopes.push(match[0]); + } + auth.allowedScopes = scopes.length > 0 ? scopes : scopesValue.split(/\s+/).filter(Boolean); + } else { + auth.allowedScopes = []; + } + } else if (authType === 'jwt') { + auth.token = String(form.get('token') || ''); + const requiredScopes = String(form.get('requiredScopes') || ''); + if (requiredScopes) { + try { + auth.requiredScopes = JSON.parse(requiredScopes); + } catch (_e) { + auth.requiredScopes = {}; + } + } + } + + const corsEnabled = form.get('corsEnabled') === 'true'; + let cors; + if (corsEnabled) { + cors = { + enabled: true, + origins: String(form.get('corsOrigins') || '*').split(',').map(s => s.trim()), + allowCredentials: form.get('corsCredentials') === 'true', + allowedHeaders: String(form.get('corsHeaders') || '').split(',').map(s => s.trim()).filter(Boolean), + allowedMethods: String(form.get('corsMethods') || '').split(',').map(s => s.trim()).filter(Boolean) + }; + } + + // Checkbox presence indicates simulation of network errors + const simulateNetworkErrors = form.has('simulateNetworkErrors'); + const errorChance = Number(form.get('errorChance') || 0); + + let responseData; + if (responseType === 'json') { + try { + responseData = JSON.parse(bodyText); + } catch { + responseData = bodyText; + } + } else { + responseData = bodyText; + } + + const category = String(form.get('category') || ''); + const tagsString = String(form.get('tags') || ''); + const tags = tagsString.split(',').map(s => s.trim()).filter(Boolean); + const active = form.get('active') === 'true'; + + // Prevent duplicate path+method + const existingApi = await repo.findApiByPathAndMethod(path, method); + if (existingApi) { + // Set title and breadcrumbs for the error page + c.set('title', 'Criar Nova API'); + c.set('breadcrumbs', [ + { href: '/mock-api', label: 'APIs' }, + { label: 'Criar Nova API' } + ]); + + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}`; + + // Return to form with error message + return c.render( + <> +
+
+
+ error_outline +
+
+

Erro ao criar API

+

+ A API {method} {path} já existe. Escolha um caminho diferente ou outro método HTTP. +

+
+ + Editar API existente + +
+
+
+
+ + + ); + } + + await repo.createApi({ + method, path, description, statusCode, auth, cors, + simulation: { delay: simDelay, networkErrors: simulateNetworkErrors, errorChance }, + response: { + data: responseData, + chunks: 0, + type: responseType as ResponseType, + contentType, + dynamic: form.get('dynamicResponse') === 'true' + }, + category: category || undefined, tags, + active, + }); + + // HTMX redirect support + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', '/mock-api'); + return c.text(''); + } + return c.redirect('/mock-api'); + } catch (error) { + console.error('Error creating API:', error); + + c.set('title', 'Criar Nova API - Erro'); + c.set('breadcrumbs', [ + { href: '/mock-api', label: 'APIs' }, + { label: 'Criar Nova API' } + ]); + + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}`; + + return c.render( + <> +
+
+
+ error_outline +
+
+

Erro ao criar API

+

+ {(error as Error).message || "Erro desconhecido"} +

+
+
+
+ + + ); + } +}); + +// Render create form +mockApi.get('/new', async (c) => { + c.set('title', 'Criar Nova API'); + c.set('breadcrumbs', [ + { href: '/mock-api', label: 'APIs' }, + { label: 'Criar Nova API' } + ]); + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}`; + return c.render(); +}); + +// Edit API form (allow any string as ID, but /export and /import must be registered before this) +mockApi.get('/:id', async (c) => { + const id = c.req.param('id')!; + console.log('Edit API route hit for id:', id); + const repo = c.get('mockApiRepository'); + const api = await repo.getApiById(id); + if (!api) return c.redirect('/mock-api'); + c.set('title', `Editar API - ${api.path}`); + c.set('breadcrumbs', [ + { href: '/mock-api', label: 'APIs' }, + { label: `Editar API: ${api.path}` } + ]); + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}`; + return c.render(); +}); + +// Update API handler (allow any string as ID, but /export and /import must be registered before this) +mockApi.post('/:id', async (c) => { + const repo = c.get('mockApiRepository'); + const id = c.req.param('id')!; + const form = await c.req.formData(); + console.log('Updating API', id, 'with form data:', Object.fromEntries(form.entries())); + + try { + const method = String(form.get('method') || 'GET'); + // Normalize path to ensure it starts with a slash + const rawPath = String(form.get('path') || '/'); + const path = rawPath.startsWith('/') ? rawPath : `/${rawPath}`; + const description = String(form.get('description') || ''); + const statusCode = Number(form.get('statusCode') || 200); + // Extract simulation delay from number or range input + const simDelay = Number(form.get('simDelay') ?? form.get('simDelayRange') ?? 0); + const responseType = String(form.get('responseType') || 'json'); + const contentType = form.get('contentType') ? String(form.get('contentType')) : undefined; + const bodyText = String(form.get('body') || ''); + + const authType = String(form.get('authType') || 'none'); + const auth: AuthConfig = { type: authType as AuthConfig["type"] }; + + if (authType === 'bearer') { + auth.token = String(form.get('token') || ''); + } else if (authType === 'api_key') { + auth.headerName = String(form.get('headerName') || 'X-API-Key'); + auth.apiKey = String(form.get('apiKey') || ''); + auth.apiKeyInQuery = form.get('apiKeyInQuery') === 'true'; + } else if (authType === 'custom_header') { + auth.headerName = String(form.get('headerName') || ''); + auth.headerValue = String(form.get('headerValue') || ''); + } else if (authType === 'basic') { + auth.username = String(form.get('username') || ''); + auth.password = String(form.get('password') || ''); + } else if (authType === 'oauth' || authType === 'client_credentials') { + auth.clientId = String(form.get('clientId') || ''); + auth.clientSecret = String(form.get('clientSecret') || ''); + const scopesValue = String(form.get('allowedScopes') || ''); + if (scopesValue) { + const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g; + const scopes: string[] = []; + let match; + while ((match = regex.exec(scopesValue)) !== null) { + if (match[1]) scopes.push(match[1]); + else if (match[2]) scopes.push(match[2]); + else scopes.push(match[0]); + } + auth.allowedScopes = scopes.length > 0 ? scopes : scopesValue.split(/\s+/).filter(Boolean); + } else { + auth.allowedScopes = []; + } + } else if (authType === 'jwt') { + auth.token = String(form.get('token') || ''); + const requiredScopes = String(form.get('requiredScopes') || ''); + if (requiredScopes) { + try { + auth.requiredScopes = JSON.parse(requiredScopes); + } catch (_e) { + auth.requiredScopes = {}; + } + } + } + + const corsEnabled = form.get('corsEnabled') === 'true'; + let cors; + if (corsEnabled) { + cors = { + enabled: true, + origins: String(form.get('corsOrigins') || '*').split(',').map(s => s.trim()), + allowCredentials: form.get('corsCredentials') === 'true', + allowedHeaders: String(form.get('corsHeaders') || '').split(',').map(s => s.trim()).filter(Boolean), + allowedMethods: String(form.get('corsMethods') || '').split(',').map(s => s.trim()).filter(Boolean) + }; + } + + // Checkbox presence indicates simulation of network errors + const simulateNetworkErrors = form.has('simulateNetworkErrors'); + const errorChance = Number(form.get('errorChance') || 0); + + let responseData; + if (responseType === 'json') { + try { + responseData = JSON.parse(bodyText); + } catch { + responseData = bodyText; + } + } else { + responseData = bodyText; + } + + const category = String(form.get('category') || ''); + const tagsString = String(form.get('tags') || ''); + const tags = tagsString.split(',').map(s => s.trim()).filter(Boolean); + const active = form.get('active') === 'true'; + + // Prevent duplicate path+method on update + const existingApi2 = await repo.findApiByPathAndMethod(path, method); + if (existingApi2 && existingApi2.id !== id) { + const api = await repo.getApiById(id); + if (!api) return c.redirect('/mock-api'); + + c.set('title', `Editar API - ${api.path}`); + c.set('breadcrumbs', [ + { href: '/mock-api', label: 'APIs' }, + { label: `Editar API: ${api.path}` } + ]); + + const url = new URL(c.req.url); + const baseUrl = `${url.protocol}//${url.host}`; + + return c.render( + <> +
+
+
+ error_outline +
+
+

Erro ao atualizar API

+

+ A API {method} {path} já existe. Escolha um caminho diferente ou outro método HTTP. +

+
+ + Editar API existente + +
+
+
+
+ + + ); + } + + await repo.updateApi(id, { + id, path, method, description, statusCode, auth, cors, + simulation: { delay: simDelay, networkErrors: simulateNetworkErrors, errorChance }, + response: { + data: responseData, + chunks: 0, + type: responseType as ResponseType, + contentType, + dynamic: form.get('dynamicResponse') === 'true' + }, + category: category || undefined, tags, + active, + }); + + // HTMX redirect support + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', '/mock-api'); + return c.text(''); + } + return c.redirect('/mock-api'); + } catch (error) { + console.error('Error updating API:', error); + return c.text(`Error updating API: ${(error as Error).message || "Unknown error"}`, { status: 500 }); + } +}); + +// Delete API handler +mockApi.post('/:id/delete', async (c) => { + const repo = c.get('mockApiRepository'); + const id = c.req.param('id')!; + try { + console.log('Deleting API', id); + await repo.deleteApi(id); + // HTMX redirect support + if (c.req.header('HX-Request') === 'true') { + c.header('HX-Redirect', '/mock-api'); + return c.text(''); + } + return c.redirect('/mock-api'); + } catch (error) { + console.error('Error deleting API:', error); + // Return structured error response + if (c.req.header('HX-Request') === 'true') { + return c.html(`
Erro ao deletar API: ${(error as Error).message}
`); + } + return c.text(`Error deleting API: ${(error as Error).message || "Unknown error"}`, { status: 500 }); + } +}); + +// Duplicate API handler +mockApi.post('/:id/duplicate', async (c) => { + const repo = c.get('mockApiRepository'); + const id = c.req.param('id')!; + + try { + const originalApi = await repo.getApiById(id); + if (!originalApi) { + return c.html( + `
+ API não encontrada. +
` + ); + } + + const duplicatedApi = await repo.createApi({ + path: `${originalApi.path}_copy`, + method: originalApi.method, + description: `${originalApi.description || originalApi.path} (Cópia)`, + statusCode: originalApi.statusCode, + auth: originalApi.auth, + cors: originalApi.cors, + simulation: originalApi.simulation, + response: originalApi.response, + tags: originalApi.tags ? [...originalApi.tags, 'duplicated'] : ['duplicated'], + category: originalApi.category + }); + + const allApis = await repo.getAllApis(); + const categories = new Map(); + allApis.forEach(api => { + const category = api.category || 'Sem Categoria'; + if (!categories.has(category)) { + categories.set(category, []); + } + categories.get(category)!.push(api); + }); + + return c.html( +
+ API duplicada com sucesso! + Editar a cópia + +
+ ); + + } catch (error) { + console.error('Error duplicating API:', error); + return c.html( + `
+ Erro ao duplicar API: ${(error as Error).message} +
` + ); + } +}); + +// Export APIs +mockApi.route('/export') + .get(async (c) => { + const repo = c.get('mockApiRepository'); + try { + const exportData = await repo.exportApis(); + + // Use a more unique filename that includes the word "json" to help browsers identify it + const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); + const filename = `mockapi-export-${timestamp}.json`; + + // Force the appropriate JSON content type regardless of Accept headers + const headers = new Headers({ + 'Content-Type': 'application/json', + 'Content-Disposition': `attachment; filename="${filename}"`, + // Prevent caching + 'Cache-Control': 'no-store, max-age=0', + // Force file download in all browsers + 'X-Content-Type-Options': 'nosniff' + }); + + // Create raw response to bypass Hono's content negotiation + const jsonStr = JSON.stringify(exportData, null, 2); + console.log(`Exporting JSON (GET): ${jsonStr.substring(0, 100)}...`); + return new Response(jsonStr, { + status: 200, + headers + }); + } catch (error) { + console.error('Error exporting APIs:', error); + c.header('HX-Redirect', '/mock-api?error=export-failed'); + return c.text(''); + } + }) + .post(async (c) => { + const repo = c.get('mockApiRepository'); + try { + const formData = await c.req.formData(); + const selectedIdsRaw = formData.get('selectedIds'); + let selectedIds: string[] = []; + if (selectedIdsRaw) { + try { + selectedIds = JSON.parse(selectedIdsRaw as string); + } catch (e) { + selectedIds = []; + } + } + let apis; + if (selectedIds.length > 0) { + const all = await repo.getAllApis(); + apis = all.filter(api => selectedIds.includes(api.id)); + } else { + apis = await repo.getAllApis(); + } + const exportData = { + apis, + timestamp: new Date().toISOString(), + version: "1.0" + }; + + // Use a more unique filename that includes the word "json" to help browsers identify it + const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); + const filename = `mockapi-export-${timestamp}.json`; + + // Force the appropriate JSON content type regardless of Accept headers + const headers = new Headers({ + 'Content-Type': 'application/json', + 'Content-Disposition': `attachment; filename="${filename}"`, + // Prevent caching + 'Cache-Control': 'no-store, max-age=0', + // Force file download in all browsers + 'X-Content-Type-Options': 'nosniff' + }); + + // Create raw response to bypass Hono's content negotiation + const jsonStr = JSON.stringify(exportData, null, 2); + console.log(`Exporting JSON: ${jsonStr.substring(0, 100)}...`); + return new Response(jsonStr, { + status: 200, + headers + }); + } catch (error) { + console.error('Error exporting APIs:', error); + c.header('HX-Redirect', '/mock-api?error=export-failed'); + return c.text(''); + } + }); + +// Import APIs via HTMX OOB updates +mockApi.post('/import', async (c) => { + const repo = c.get('mockApiRepository'); + try { + const formData = await c.req.formData(); + const file = formData.get('apiFile') as File; + if (!file) { + return c.html( +
+ Selecione um arquivo JSON para importar. +
+ ); + } + const fileContent = await file.text(); + let importData; + try { + importData = JSON.parse(fileContent); + } catch (_e) { + return c.html( +
+ Arquivo inválido: não contém JSON válido. +
+ ); + } + const result = await repo.importApis(importData); + const all = await repo.getAllApis(); + return c.html( + <> +
+ {result.imported} APIs importadas, {result.skipped} ignoradas, {result.failed} falharam. +
+
+ +
+ + ); + } catch (e) { + return c.html( +
+ Erro ao importar: {(e as Error).message} +
+ ); + } +}); + +export default mockApi; \ No newline at end of file diff --git a/src/routes/trafficLogs.tsx b/src/routes/trafficLogs.tsx new file mode 100644 index 0000000..176acf5 --- /dev/null +++ b/src/routes/trafficLogs.tsx @@ -0,0 +1,668 @@ +/** @jsxImportSource hono/jsx */ +import { Hono } from 'hono/mod.ts'; +import type { Variables } from "../main.tsx"; + +// Initialize the routes +const trafficLogs = new Hono<{ Variables: Variables }>(); + +// Traffic logs main page +trafficLogs.get('/', async (c) => { + const mockApiRepo = c.get('mockApiRepository'); + const logs = await mockApiRepo.getTrafficLogs(10, 1); + + c.set('title', 'Logs de Tráfego'); + + // Compute metrics for display + const allLogsRes = await mockApiRepo.getTrafficLogs(logs.total, 1); + const allLogs = allLogsRes.logs; + const totalRequests = logs.total; + const startOfToday = new Date(new Date().setHours(0, 0, 0, 0)).getTime(); + const requestsToday = allLogs.filter(log => log.timestamp >= startOfToday).length; + const successCount = allLogs.filter(log => log.response.status >= 200 && log.response.status < 300).length; + const successRate = totalRequests > 0 ? Math.round((successCount / totalRequests) * 100) : 0; + const averageTime = totalRequests > 0 ? Math.round(allLogs.reduce((acc, log) => acc + log.performance.total, 0) / totalRequests) : 0; + + // Parse query parameters for filters + const url = new URL(c.req.url); + const pathFilter = url.searchParams.get('path') || ''; + const methodFilter = url.searchParams.get('method') || ''; + const statusFilter = url.searchParams.get('status') || ''; + + // Apply filters if any are set + let filteredLogs = logs.logs; + if (pathFilter || methodFilter || statusFilter) { + filteredLogs = logs.logs.filter(log => { + // Filter by path + if (pathFilter && !log.request.path.toLowerCase().includes(pathFilter.toLowerCase())) { + return false; + } + + // Filter by method + if (methodFilter && log.request.method !== methodFilter) { + return false; + } + + // Filter by status code + if (statusFilter) { + const statusCode = String(log.response.status); + if (!statusCode.includes(statusFilter)) { + return false; + } + } + + return true; + }); + } + + return c.render( +
+ {/* Metrics Cards */} +
+
+
Total de Requisições
+
{logs.total}
+
+ analytics +
+
+ +
+
Requisições Hoje
+
{requestsToday}
+
+ today +
+
+ +
+
Taxa de Sucesso
+
{`${successRate}%`}
+
+ trending_up +
+
+ +
+
Tempo Médio
+
{`${averageTime}ms`}
+
+ speed +
+
+
+ + {/* Filter bar */} +
+
+
+ search +
+ +
+ +
+ +
+ expand_more +
+
+ +
+ +
+ + + + {(pathFilter || methodFilter || statusFilter) && ( + + clear + Limpar Filtros + + )} + + +
+