exisjs 0.5.10 → 0.5.12

package/dist/docs/content/testing.mdx

@@ -0,0 +1,139 @@
+---
+nextUrl: "/docs/adapters"
+nextTitle: "Adapters"
+---
+
+# Testing
+
+ExisJS was built with testing as a first-class citizen. Instead of forcing you to configure bulky external test runners like Jest or Vitest, ExisJS natively wraps the ultra-fast, built-in **Node.js Test Runner** (`node:test`).
+
+This means you get blistering fast, zero-dependency testing out-of-the-box.
+
+---
+
+## The Testing Module
+
+ExisJS exports everything you need for testing directly from `exisjs/testing`. This includes the test runner functions (`test`, `describe`, `it`, `before`), assertions (`assert`), and the powerful ExisJS `createTestContext`!
+
+### Creating a Test Context
+
+When testing an API, you want to boot the app, run HTTP requests against it, and then gracefully shut it down (closing database connections so the test runner doesn't hang). `createTestContext` does exactly this for you automatically! It seamlessly handles both functional `exis({ ... })` applications and Object-Oriented `@Server` decorated classes.
+
+```typescript filename="tests/users.test.ts"
+import { describe, it, expect, createTestContext } from 'exisjs/testing'
+import app from '../src/http/server' // Import your Exis instance or @Server class
+
+describe('Users API', () => {
+  // Automatically boots the app, runs `onStart`, and gracefully shuts down databases after tests!
+  const api = createTestContext(app)
+
+  it('should create a new user', async () => {
+    // `api` exposes a fast, fluid HTTP client
+    const res = await api
+      .post('/users')
+      .send({ name: 'Alice', email: 'alice@example.com' })
+      .execute()
+
+    // Integrated Jest-like expectations
+    expect(res.status).toBe(201)
+    expect(res.body.success).toBe(true)
+    expect(res.body.data.name).toBe('Alice')
+  })
+
+  it('should return 400 on invalid input', async () => {
+    const res = await api
+      .post('/users')
+      .send({ name: 'Bob' }) // Missing email
+      .execute()
+
+    expect(res.status).toBe(400)
+    expect(res.body.success).toBe(false)
+  })
+})
+```
+
+### Running Tests
+
+Because ExisJS wraps the native Node.js test runner in its powerful CLI, you can run all your tests simply using the standard Exis command!
+
+```bash
+npx exisjs test
+```
+
+Or configure it in your `package.json`:
+
+```json
+{
+  "scripts": {
+    "test": "exisjs test"
+  }
+}
+```
+
+The `exisjs test` command automatically bootstraps your environment, loads your environment variables (`.env`), registers TypeScript (`tsx`), and recursively finds and executes all test files matching standard testing conventions (`*.test.ts`, `*.spec.ts`, etc.) regardless of where they are placed.
+
+### Test Configuration
+
+ExisJS allows you to configure your testing environment directly. By default, it will use your project's TypeScript configuration, but you can override this by creating a specific `tsconfig.test.json` file in your project root. The test runner will automatically detect and prioritize it when running tests!
+
+---
+
+## Mocking (Dependency Injection)
+
+If you are using ExisJS's built-in **Dependency Injection (DI)** or **Gateways**, mocking is incredibly easy. You don't need magic `jest.mock()` intercepts. You can simply override the providers in your test!
+
+```typescript filename="tests/billing.test.ts"
+import { describe, it, expect, createTestContext } from 'exisjs/testing'
+import app from '../src/http/server'
+import { BillingGateway } from '../src/http/billing/gateway'
+
+describe('Billing API', () => {
+  
+  // Override the StripeService strictly for testing!
+  BillingGateway.overrideProvider('StripeService', {
+    charge: async (amount: number) => ({ success: true, transactionId: 'test_123' })
+  })
+
+  const api = createTestContext(app)
+
+  it('should process payment', async () => {
+    const res = await api
+      .post('/billing/charge')
+      .send({ amount: 500 })
+      .execute()
+
+    expect(res.status).toBe(200)
+    expect(res.body.transactionId).toBe('test_123')
+  })
+})
+```
+
+---
+
+## Test Isolation
+
+One of the most common pitfalls when testing backend frameworks is **test bleed**—where the state from one test unexpectedly affects the next. ExisJS provides the tools to prevent this, but you must be intentional about state isolation.
+
+### 1. Dependency Injection Cleanup
+If you rely heavily on singletons in the ExisJS Dependency Injection container, you may want to reset the container's state between tests. 
+
+```typescript filename="tests/setup.ts"
+import { beforeEach } from 'exisjs/testing'
+import { getActiveApp } from 'exisjs/app'
+
+beforeEach(() => {
+  const app = getActiveApp()
+  if (app) {
+    app.container.clearCache() // Purges all instantiated singletons
+  }
+})
+```
+
+### 2. Zero-Config Singletons (Redis, Prisma, etc.)
+ExisJS provides zero-config integrations (`redis.ts`, `prisma.ts`, etc.) which act as **process-wide singletons**. 
+Because they use proxy-based caching at the module level, running multiple test suites concurrently in the same Node.js process means they will all share the **exact same database connections and state**. 
+
+If your tests write to the database or queue, ensure you either:
+1. Run your test runner in a mode that isolates processes per file.
+2. Manually clear database tables or flush Redis in a `beforeEach` block.
+3. Use database transactions that rollback after each test.

package/dist/docs/content/validation.mdx

@@ -0,0 +1,249 @@
+---
+nextUrl: "/docs/errors"
+nextTitle: "Error Handling"
+---
+
+# Validation & Schemas
+
+If you are coming from frameworks like Fastify, you are likely used to writing validation schemas using JSON Schema strings and relying on external dependencies like AJV.
+
+ExisJS takes a strictly-typed approach. It includes a native validation engine out of the box, powered by Rust for maximum performance. You don't need any external dependencies, and you avoid string-based references.
+
+## The Native Validator (`tex`)
+
+ExisJS exports a global validator object `tex` that allows you to fluently build complex validation schemas using pure, typesafe JavaScript.
+
+```typescript filename="example.ts"
+import { tex } from 'exisjs/validator'
+
+// Build a strict schema intuitively
+const userSchema = tex.object({
+  name: tex.string({ min: 3 }),
+  age: tex.number({ optional: true }),
+  role: tex.enum(['admin', 'user']),
+  email: tex.email()
+})
+
+// You can natively parse data directly!
+const safeData = userSchema.parse(rawInput)
+```
+
+### Validation Primitives
+
+ExisJS supports a comprehensive set of strict validation primitives:
+
+- `tex.string()` - String validation (supports options like `{ min: 5, max: 10 }`).
+- `tex.email()` - Validates standard email formatting.
+- `tex.number()` - Strict number validation (fails if passed a string).
+- `tex.boolean()` - Strict boolean validation.
+- `tex.number({ coerce: true })` - Automatically coerces incoming string representations into native JavaScript numbers.
+- `tex.boolean({ coerce: true })` - Coerces `"true"`/`"1"` and `"false"`/`"0"` into native booleans.
+- `tex.array(schema)` - Validates an array of items.
+- `tex.object({ ... })` - Validates structured JSON objects.
+- `tex.enum(['A', 'B'])` - Ensures the value matches one of the provided exact strings.
+
+All primitives accept an options object where you can pass `{ optional: true }` to allow `undefined`.
+
+### Data Sanitization (Trimming & Formatting)
+
+ExisJS allows you to mutate and sanitize incoming data in real-time before it reaches your controller. It includes a native Rust-powered sanitization engine for Strings and Arrays.
+
+```typescript filename="example.ts"
+import { tex } from 'exisjs/validator'
+import { sanitize } from 'exisjs/sanitize'
+
+const loginSchema = tex.object({
+  // Automatically trim whitespace, convert to lowercase, and prevent HTML injections
+  email: tex.email().sanitize(sanitize.trim, sanitize.toLowerCase, sanitize.escapeHtml),
+  password: tex.string({ min: 8 })
+})
+
+const articleSchema = tex.object({
+  title: tex.string().sanitize(sanitize.collapseWhitespace, sanitize.truncate(100)),
+  // Auto-generate slugs from the title using sanitize.slugify!
+  slug: tex.string().sanitize(sanitize.slugify),
+  tags: tex.array(tex.string()).sanitize(sanitize.dedupe, sanitize.compact)
+})
+```
+
+### Standalone Sanitization Usage
+
+Because the sanitization engine is designed as a collection of pure, independent functions, **you don't have to use it with the Validator**. If you ever need to manually sanitize data deep inside your services, background jobs, or generic Node.js scripts, you can import the engine directly:
+
+```typescript filename="src/services/formatter.ts"
+import { sanitize } from 'exisjs/sanitize'
+
+export function formatArticleTitle(rawInput: string) {
+  let clean = sanitize.stripHtml(rawInput)
+  clean = sanitize.collapseWhitespace(clean)
+  return sanitize.trim(clean)
+}
+```
+
+## Schema Composition & Features
+
+ExisJS validation provides robust features to handle real-world use cases efficiently and seamlessly.
+
+### Schema Composition
+
+You can construct powerful shared schemas easily using composition methods (`.partial()`, `.omit()`, `.pick()`). This prevents schema duplication.
+
+```typescript filename="example.ts"
+const UserSchema = tex.object({
+  id: tex.string(),
+  name: tex.string(),
+  email: tex.email(),
+  password: tex.string({ min: 8 })
+})
+
+// Create an update schema (all fields optional)
+const UpdateUserSchema = UserSchema.partial()
+
+// Create a safe response schema (omit password)
+const PublicUserSchema = UserSchema.omit(['password'])
+
+// Create a specialized schema
+const LoginSchema = UserSchema.pick(['email', 'password'])
+
+// Chain multiple schemas using tex.union()
+const FlexibleIdSchema = tex.union([tex.string(), tex.number()])
+```
+
+### Asynchronous Validation
+
+Need to check a database during validation? No problem! Use `.refineAsync()` to run complex async logic seamlessly within your validation schemas. The ExisJS router will automatically wait for the async checks to resolve before executing your route handler.
+
+```typescript filename="example.ts"
+const registerSchema = tex.object({
+  email: tex.email()
+    .refineAsync(async (val) => {
+      const exists = await db.users.find({ email: val })
+      return !exists // Return false if email is taken
+    }, 'Email is already taken'),
+  password: tex.string({ min: 8 })
+})
+```
+
+### Response Stripping & Serialization
+
+Because `TexEngine` validates by strictly iterating over its defined schema keys, it naturally **strips** any extra or unknown properties from the resulting object. 
+
+This provides immense security out of the box when used as a `response` schema, ensuring you never accidentally leak sensitive data (like passwords or internal IDs) to the client. The ExisJS router handles this stripping serialization natively behind the scenes.
+
+### Separating Schemas
+
+To keep your route files clean and maintainable, we highly recommend defining your schemas in a dedicated `schema.ts` file alongside your routes.
+
+```typescript filename="src/http/users/schema.ts"
+import { tex } from 'exisjs/validator'
+import type { ResolveSchema } from 'exisjs/validator'
+
+export const UserParamsSchema = tex.object({
+  id: tex.number({ coerce: true })
+})
+
+export type UserParams = ResolveSchema<typeof UserParamsSchema>
+```
+
+To validate incoming HTTP requests, ExisJS provides built-in validation configurations. Whether you use the Functional paradigm or the Class-based (OOP) paradigm, ExisJS validates incoming payloads and types your handlers.
+
+#### Functional Paradigm
+
+```typescript filename="src/http/users/route.ts"
+import { controller, route } from 'exisjs/router'
+import { tex } from 'exisjs/validator'
+
+export default controller({
+  create: route.post('/', {
+    // 1. The validation schema is passed directly in the config
+    body: tex.object({
+      username: tex.string({ min: 4 }),
+      password: tex.string({ min: 8 })
+    }),
+    query: tex.object({
+      source: tex.string({ optional: true })
+    }),
+      
+    // 2. Your handler only runs if validation succeeds
+    async handle({ body, query, req, res }) {
+      // body and query are strongly-typed here
+      await db.users.create(body)
+      res.status(201).json({ success: true })
+    }
+  })
+})
+```
+
+#### Class-Based (OOP) Paradigm
+
+```typescript filename="src/http/api/books/route.ts"
+import { Controller, Use, Post, Body, Req } from 'exisjs/decorators'
+import { tex } from 'exisjs/validator'
+import type { ResolveSchema } from 'exisjs/validator'
+
+// 1. Define your schema
+const CreateBookSchema = tex.object({
+  title: tex.string(),
+  caption: tex.string(),
+  rating: tex.number(),
+  image: tex.string(),
+})
+
+// 2. Infer the TypeScript type!
+type CreateBookDto = ResolveSchema<typeof CreateBookSchema>
+
+@Use(protectRoute)
+@Controller()
+export default class BooksController {
+  
+  // 3. Inject the schema directly into the @Body() decorator!
+  @Post('/')
+  async create(@Body(CreateBookSchema) body: CreateBookDto, @Req() req: any) {
+    // If validation fails, this block is never reached!
+    // body is strictly typed as CreateBookDto
+    
+    const newBook = new Book({
+      title: body.title,
+      caption: body.caption,
+      rating: body.rating,
+      image: body.image,
+      user: req.user._id,
+    })
+
+    await newBook.save()
+    return newBook
+  }
+}
+```
+
+### Database Integration (Mongoose)
+
+Because the ExisJS Validator is native to the framework, it is tightly coupled with our database and documentation adapters. You can generate Mongoose schemas directly from your validation schemas using `.toMongoSchema()`!
+
+```typescript filename="src/models/User.ts"
+import mongoose from 'mongoose'
+import { tex } from 'exisjs/validator'
+
+export const UserValidator = tex.object({
+  email: tex.email(),
+  password: tex.string({ min: 8 }),
+  role: tex.enum(['admin', 'user'], { default: 'user' })
+})
+
+// Pass the ExisJS Validator directly into Mongoose!
+export const User = mongoose.model('User', new mongoose.Schema(UserValidator.toMongoSchema()))
+```
+
+## Error Handling
+
+If a request fails validation (e.g., missing a required body field), the validation engine will instantly catch it and return a standardized `400 Bad Request` JSON response to the client.
+
+```json filename="Response"
+{
+  "statusCode": 400,
+  "error": "Bad Request",
+  "message": "Validation Error: body.username is required"
+}
+```
+
+Because this is built right into the framework, you don't have to manually catch errors or construct complex schema error formatters. It just works exactly as you expect!

package/dist/docs/content/websockets.mdx

@@ -0,0 +1,289 @@
+---
+nextUrl: "/docs/queues"
+nextTitle: "Job Queues"
+---
+
+# WebSockets
+
+ExisJS provides a built-in WebSocket engine. It includes an integrated Pub/Sub system (rooms), automatic JSON serialization, Socket.io-style event emitters, and built-in presence tracking.
+
+You can handle WebSockets using either the **Functional API** or the **Class-Based (OOP) API**.
+
+---
+
+## 1. Functional API
+
+For smaller applications or functional paradigms, you can define WebSocket routes directly on a router using `route.ws()`.
+
+```typescript filename="src/http/route.ts"
+import { controller, route } from 'exisjs/router'
+
+export default controller({
+  chatSocket: route.ws('/ws', {
+    handle({ socket }) {
+      console.log(`New connection: ${socket.id}`)
+
+      // Listen for incoming messages
+      socket.on('message', (rawData) => {
+        const data = JSON.parse(rawData.toString())
+
+        if (data.action === 'join') {
+          // Join a room (Pub/Sub)
+          socket.join(data.room)
+
+          // Emit a named event back to the socket
+          socket.emit('chat', {
+            type: 'system',
+            message: `You joined #${data.room}`,
+          })
+        } else if (data.action === 'message') {
+          // Publish a message to everyone in the room (excluding sender by default)
+          socket.publish(data.room, {
+            event: 'chat',
+            data: { message: data.message },
+          })
+        }
+      })
+
+      socket.on('close', () => {
+        console.log(`Disconnected: ${socket.id}`)
+        socket.leaveAll()
+      })
+    },
+  }),
+})
+```
+
+---
+
+## 2. Class-Based (OOP) API
+
+For larger applications, ExisJS provides the `@Ws()` decorator to map WebSocket endpoints inside your Controllers.
+
+```typescript filename="src/http/chat/route.ts"
+import { Controller, Ws, Socket } from 'exisjs/decorators'
+import { ExisWebSocket } from 'exisjs/router'
+
+@Controller()
+export default class ChatController {
+  @Ws('/ws')
+  handleSocket(@Socket() socket: ExisWebSocket) {
+    // Enable auto-presence for this server
+    socket.server.enablePresence()
+
+    // Listen for custom JSON events
+    socket.onEvent('join', (data) => {
+      // Attach custom state to the socket
+      socket.data.userId = data.userId
+
+      // Unsubscribe from previous rooms
+      socket.leaveAll()
+      socket.join(data.room)
+
+      // Fetch the roster of active users in the room
+      const roster = socket.server.getRoomRoster(data.room)
+      socket.emit('roster', { roster })
+    })
+
+    socket.onEvent('message', (data) => {
+      // Socket.io style broadcasting!
+      socket.to(data.room).emit('chat', {
+        userId: socket.data.userId,
+        message: data.message,
+      })
+    })
+  }
+}
+```
+
+---
+
+## The `ExisWebSocket` API
+
+ExisJS wraps the native WebSocket with an `ExisWebSocket` instance that provides Socket.io-like ergonomics without the heavy client-side dependencies.
+
+### Emitting & Sending
+
+- **`socket.send(data)`**: Sends raw data. Objects are automatically stringified.
+- **`socket.emit(event, data)`**: Emits a named JSON event (`{ event: "name", data: ... }`).
+- **`socket.emitWithAck(event, data, timeoutMs?)`**: Emits an event and returns a Promise that resolves when the client sends back an acknowledgment with the matching `ackId`.
+- **`socket.volatile.emit(event, data)`**: Emits an event that will be safely dropped if the connection is experiencing backpressure (network saturation).
+
+#### Example: Emitting Events
+
+**Functional API:**
+
+```typescript
+route.ws('/ws', {
+  handle({ socket }) {
+    // Send a standard named event
+    socket.emit('ping', { timestamp: Date.now() })
+
+    // Send a volatile event that drops if network is busy
+    socket.volatile.emit('stock-tick', { price: 100 })
+  },
+})
+```
+
+**Class-Based (OOP) API:**
+
+```typescript
+@Ws('/ws')
+handleSocket(@Socket() socket: ExisWebSocket) {
+  // Await an acknowledgment from the client
+  socket.onEvent('request-data', async () => {
+    try {
+      const response = await socket.emitWithAck('data-ready', { id: 1 }, 5000)
+      console.log('Client acknowledged:', response)
+    } catch (err) {
+      console.error('Client failed to ack in 5s')
+    }
+  })
+}
+```
+
+### Rooms (Pub/Sub)
+
+ExisJS has a built-in Pub/Sub engine that allows sockets to subscribe to topics (rooms).
+
+- **`socket.join(room)`** / **`socket.subscribe(room)`**: Subscribes the socket to a room.
+- **`socket.leave(room)`** / **`socket.unsubscribe(room)`**: Unsubscribes from a room.
+- **`socket.leaveAll()`** / **`socket.unsubscribeAll()`**: Unsubscribes from all joined rooms.
+- **`socket.publish(room, data, excludeSelf?)`**: Publishes data to all sockets in a room. By default, it excludes the sender.
+
+#### Example: Managing Rooms
+
+**Functional API:**
+
+```typescript
+route.ws('/chat', {
+  handle({ socket }) {
+    socket.onEvent('join-room', (data) => {
+      // Leave old rooms before joining a new one
+      socket.leaveAll()
+      socket.join(data.roomId)
+
+      socket.publish(data.roomId, {
+        event: 'system',
+        data: 'A new user joined',
+      })
+    })
+  },
+})
+```
+
+**Class-Based (OOP) API:**
+
+```typescript
+@Ws('/chat')
+handleSocket(@Socket() socket: ExisWebSocket) {
+  socket.onEvent('leave-room', (data) => {
+    socket.leave(data.roomId)
+  })
+}
+```
+
+### Broadcasting (Socket.io Style)
+
+If you prefer Socket.io's chainable broadcasting syntax, ExisJS fully supports it:
+
+- **`socket.to(room).emit(event, data)`**: Emits an event to everyone in the specified room _except_ the sender.
+- **`socket.broadcast.emit(event, data)`**: Emits to every connected socket on the server _except_ the sender.
+- **`socket.broadcast.to(room).emit(event, data)`**: Same as `socket.to()`.
+
+#### Example: Broadcasting
+
+**Functional API:**
+
+```typescript
+route.ws('/game', {
+  handle({ socket }) {
+    socket.onEvent('player-move', (position) => {
+      // Tell everyone ELSE in 'game-1' that this player moved
+      socket.to('game-1').emit('player-moved', { id: socket.id, position })
+    })
+  },
+})
+```
+
+**Class-Based (OOP) API:**
+
+```typescript
+@Ws('/global')
+handleSocket(@Socket() socket: ExisWebSocket) {
+  socket.onEvent('global-alert', (alert) => {
+    // Broadcast to EVERYONE on the server except the sender
+    socket.broadcast.emit('alert', alert)
+  })
+}
+```
+
+### Listening for Events
+
+- **`socket.on('message', cb)`**: Listens for raw WebSocket messages.
+- **`socket.onEvent(eventName, cb)`**: Automatically parses incoming JSON and triggers the callback _only_ if the JSON payload matches `{ event: "eventName" }`.
+
+#### Example: Event Listeners
+
+**Functional API:**
+
+```typescript
+route.ws('/data', {
+  handle({ socket }) {
+    // Handle raw buffer/string messages manually
+    socket.on('message', (raw) => {
+      console.log('Raw data received:', raw.toString())
+    })
+  },
+})
+```
+
+**Class-Based (OOP) API:**
+
+```typescript
+@Ws('/api')
+handleSocket(@Socket() socket: ExisWebSocket) {
+  // Handle specific JSON events
+  socket.onEvent('auth', (credentials) => {
+    console.log('Auth attempt:', credentials.username)
+  })
+}
+```
+
+### State & Presence
+
+- **`socket.data`**: An empty object `Record<string, any>` where you can safely attach custom user data (like user IDs, roles, etc.) for the duration of the connection.
+- **`socket.server.enablePresence()`**: Turns on automatic presence tracking. When a socket joins or leaves a room, ExisJS will automatically broadcast `room:join` and `room:leave` events to the room.
+- **`socket.server.getRoomRoster(room)`**: Returns an array of all connected sockets currently in a specific room.
+
+#### Example: State & Roster Tracking
+
+**Functional API:**
+
+```typescript
+route.ws('/collaboration', {
+  handle({ socket }) {
+    socket.server.enablePresence()
+
+    socket.onEvent('identify', (user) => {
+      // Safely store state on the socket instance
+      socket.data.userId = user.id
+      socket.data.role = 'editor'
+    })
+  },
+})
+```
+
+**Class-Based (OOP) API:**
+
+```typescript
+@Ws('/collaboration')
+handleSocket(@Socket() socket: ExisWebSocket) {
+  socket.onEvent('get-users', (room) => {
+    // Fetch everyone currently in the room
+    const roster = socket.server.getRoomRoster(room)
+
+    socket.emit('users-list', roster.map(s => s.data.userId))
+  })
+}
+```

package/dist/docs/integrations/README.md

@@ -0,0 +1,23 @@
+# ExisJS Integrations Blueprint
+
+This directory contains the documentation for integrating third-party services and tools with ExisJS. This `README.md` acts as a **blueprint** to help you understand what each integration guide covers.
+
+## 🗄️ Databases & Storage
+*   **`mongo.mdx`**: Connecting to MongoDB using Mongoose, leveraging the DI container, and data modeling.
+*   **`postgres.mdx`**: Connecting to PostgreSQL databases (e.g., via Prisma or Drizzle ORM) in a type-safe manner.
+*   **`redis.mdx`**: Using Redis for high-speed caching, rate limiting, and powering ExisJS queues.
+*   **`s3.mdx`**: Integrating with AWS S3 (or compatible services like Cloudflare R2) for file uploads and object storage.
+
+## 🔐 Auth & Security
+*   **`jwt.mdx`**: Implementing JSON Web Token (JWT) authentication, signing, and protecting routes via middleware.
+
+## 🤖 Artificial Intelligence
+*   **`openai.mdx`**: Integrating the OpenAI SDK, streaming LLM responses using ExisJS SSE (Server-Sent Events), and managing API keys securely.
+
+## 📧 Communications
+*   **`resend.mdx`**: Sending transactional emails (like password resets or welcome emails) using the Resend API, ideally triggered via background Queues.
+
+## 📊 Analytics & Observability
+*   **`posthog.mdx`**: Capturing user events, feature flags, and product analytics using PostHog inside your ExisJS controllers.
+*   **`observability.mdx`**: Setting up advanced monitoring, tracing (OpenTelemetry), and logging infrastructure.
+*   **`swagger.mdx`**: Automatic OpenAPI/Swagger generation for your endpoints based on your validation schemas and route definitions.