@venizia/ignis-docs 0.0.1-1

package/wiki/get-started/philosophy.md

@@ -0,0 +1,123 @@
+# Philosophy: The Best of Two Worlds
+
+Ignis combines the structured, enterprise-grade development experience of **LoopBack 4** with the speed and simplicity of **Hono**.
+
+## The Problem
+
+When building REST APIs with Node.js/Bun, developers face a choice:
+
+| Aspect | Minimal Frameworks | Enterprise Frameworks | **Ignis** |
+|--------|-------------------|----------------------|-----------|
+| **Examples** | Express, Hono, Fastify | NestJS, LoopBack | **Ignis** |
+| **Performance** | ⚡ Very fast | 🐌 Slower | ⚡ Very fast (Hono) |
+| **Architecture** | ❌ No structure | ✅ Structured | ✅ Structured |
+| **Learning Curve** | ✅ Easy | ❌ Steep | ✅ Gradual |
+| **Dependency Injection** | ❌ Manual | ✅ Built-in | ✅ Built-in |
+| **Boilerplate** | ✅ Minimal | ❌ Heavy | ✅ Moderate |
+| **Best For** | Prototypes, tiny APIs | Large enterprise apps | Growing APIs, teams |
+
+### Ignis: The Middle Ground
+
+Ignis provides the architectural benefits of enterprise frameworks while maintaining Hono's speed:
+
+- ✅ **Enterprise patterns** (DI, layered architecture) without the bloat
+- ✅ **Hono's performance** - one of the fastest frameworks
+- ✅ **Gradual complexity** - start simple, add structure as you grow
+- ✅ **TypeScript-first** with excellent type safety
+
+## Inspired By The Best
+
+### From LoopBack 4
+
+[LoopBack 4](https://loopback.io/doc/en/lb4/index.html) proved that enterprise patterns work:
+
+| Pattern | Benefit |
+|---------|---------|
+| **Dependency Injection** | Loosely coupled, testable code |
+| **Layered Architecture** | Clear separation (Controllers → Services → Repositories) |
+| **Component-Based** | Modular, reusable features |
+| **Decorators** | Declarative metadata for routes and DI |
+
+### From Hono
+
+[Hono](https://hono.dev/) provides the performance foundation:
+
+| Feature | Why It Matters |
+|---------|----------------|
+| **Ultrafast** | One of the fastest web frameworks |
+| **Lightweight** | Minimal core, fast startup |
+| **Modern API** | Clean, intuitive developer experience |
+| **Multi-Runtime** | Works on Node.js, Bun, Deno, Cloudflare Workers |
+
+### The Ignis Synthesis
+
+Ignis = LoopBack patterns + Hono performance:
+
+```
+┌─────────────────┐      ┌──────────────┐      ┌──────────────┐
+│  LoopBack 4     │  +   │    Hono      │  =   │    Ignis     │
+│                 │      │              │      │              │
+│ • DI Container  │      │ • Speed      │      │ • DI + Speed │
+│ • Layered Arch  │      │ • Minimal    │      │ • Structure  │
+│ • Components    │      │ • Modern API │      │ • Components │
+└─────────────────┘      └──────────────┘      └──────────────┘
+```
+
+**What you get:**
+- Familiar structure for LoopBack/NestJS developers
+- Hono's performance and flexibility
+- Pre-built components (auth, logging, database, etc.)
+
+## When Should You Use Ignis?
+
+### Decision Matrix
+
+| Your Situation | Use Ignis? | Why |
+|----------------|------------|-----|
+| Building 10+ endpoint API | ✅ Yes | Structure prevents spaghetti code |
+| Team of 2+ developers | ✅ Yes | Patterns improve collaboration |
+| Need database + auth + docs | ✅ Yes | Built-in components save time |
+| Coming from NestJS/LoopBack | ✅ Yes | Familiar patterns, better performance |
+| Prototyping quickly | ❌ No | Use plain Hono for speed |
+| Simple proxy/webhook | ❌ No | Too much structure |
+| 3-5 endpoints, solo dev | 🤔 Maybe | Start with Hono, migrate later if needed |
+
+### ✅ Perfect For
+
+**E-commerce Backends:**
+- Controllers for products, orders, users, payments
+- Services for business logic (tax, inventory)
+- Repository pattern for data access
+- JWT authentication + OpenAPI docs
+
+**SaaS Platform APIs:**
+- Multi-tenant architecture
+- Complex business rules
+- Modular components
+- Easy testing with DI
+
+**Enterprise Tools:**
+- CRUD operations via `ControllerFactory`
+- Team collaboration with clear patterns
+- Type-safe database operations
+- Automatic validation
+
+## The Trade-off
+
+| You Gain | You Give Up |
+|----------|-------------|
+| Clear architecture | ~100 lines setup boilerplate |
+| Built-in DI, validation, docs | Learning curve for patterns |
+| Faster for medium/large projects | Slightly more abstraction than Hono |
+| Easier testing | Initial time investment |
+| Team scalability | Convention over total freedom |
+
+**Bottom line:** If you're building more than a simple API, the structure pays off in maintainability and productivity.
+
+## Next Steps
+
+Ready to get started?
+
+1. [Check Prerequisites](./prerequisites.md) - Install required tools
+2. [Quickstart Guide](./quickstart.md) - Build your first endpoint
+3. [CRUD Tutorial](./building-a-crud-api.md) - Build a complete API

package/wiki/get-started/prerequisites.md

@@ -0,0 +1,113 @@
+# Prerequisites
+
+Before starting with Ignis, ensure you have the following installed and configured.
+
+> **New to Ignis?** This is a TypeScript REST API framework that combines enterprise patterns with high performance. [Learn more about the philosophy](./philosophy.md).
+
+## Required Software
+
+| Tool | Version | Purpose | Installation |
+|------|---------|---------|--------------|
+| **Bun** | ≥ 1.3 | JavaScript runtime & package manager | [bun.sh](https://bun.sh) |
+| **PostgreSQL** | ≥ 14.x | Database server for storing your data | [postgresql.org/download](https://www.postgresql.org/download/) |
+
+### Installation Quick Links
+
+**Bun:**
+```bash
+# macOS/Linux
+curl -fsSL https://bun.sh/install | bash
+
+# Windows (requires WSL)
+# First install WSL, then run the command above
+```
+
+**PostgreSQL:**
+- **macOS:** `brew install postgresql@14` (requires [Homebrew](https://brew.sh))
+- **Ubuntu/Debian:** `sudo apt-get install postgresql-14`
+- **Windows:** Download installer from [postgresql.org](https://www.postgresql.org/download/windows/)
+
+### Verify Installation
+
+After installing, verify everything works:
+
+```bash
+# Check Bun
+bun --version
+# Expected: 1.3.0 or higher
+
+# Check PostgreSQL
+psql --version
+# Expected: psql (PostgreSQL) 14.x or higher
+```
+
+## Required Knowledge
+
+You should be comfortable with:
+
+- **TypeScript basics** - Variables, functions, classes, interfaces
+- **REST APIs** - What GET, POST, PUT, DELETE mean
+- **Async/await** - Handling asynchronous code in JavaScript
+- **SQL basics** - What a database table is, basic SELECT/INSERT/UPDATE/DELETE
+
+**Don't have these?** You can still follow along, but consider bookmarking these resources:
+- [TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/intro.html)
+- [REST API Tutorial](https://restfulapi.net/)
+
+## Database Setup
+
+Create a database for your application:
+
+```bash
+# Start PostgreSQL service (if not already running)
+# macOS with Homebrew:
+brew services start postgresql@14
+
+# Ubuntu/Debian:
+sudo service postgresql start
+
+# Connect to PostgreSQL
+psql -U postgres
+
+# Inside psql, create your database:
+CREATE DATABASE my_app_db;
+
+# Verify it was created:
+\l
+
+# Exit psql:
+\q
+```
+
+**What just happened?**
+- `psql -U postgres` - Connect as the default "postgres" superuser
+- `CREATE DATABASE my_app_db;` - Creates an empty database to store your app's data
+- `\l` - Lists all databases (you should see `my_app_db` in the list)
+
+**Troubleshooting:**
+- **"postgres" user doesn't exist?** Try `psql -U your_username` (your system username)
+- **Password prompt?** Default PostgreSQL installations often have no password. If prompted, check your installation docs.
+- **Connection refused?** PostgreSQL service isn't running. Check the `brew services start` or `sudo service postgresql start` command.
+
+## Text Editor Setup (Optional but Recommended)
+
+Any editor works, but **VS Code** has the best TypeScript support:
+
+1. Install [VS Code](https://code.visualstudio.com/)
+2. Install these extensions:
+   - **ESLint** - Catches code errors
+   - **Prettier** - Auto-formats code
+   - **TypeScript + JavaScript** - Built-in, enables autocomplete
+
+## Ready to Start?
+
+✅ Bun installed and working
+✅ PostgreSQL installed and running
+✅ Database created
+✅ Basic TypeScript knowledge
+
+Continue to the [Quickstart Guide](./quickstart.md) to build your first API!
+
+**Alternative paths:**
+- Want to understand "why Ignis"? Read [Philosophy](./philosophy.md) first
+- Want to see the full picture? Check [Getting Started Overview](./index.md)

package/wiki/get-started/quickstart.md

@@ -0,0 +1,382 @@
+# Quickstart Guide
+
+This guide walks you through creating a new web application with Ignis and setting up a professional development environment.
+
+> **Prerequisites:** Ensure you have [Bun installed and basic TypeScript knowledge](./prerequisites.md) before starting.
+
+## 1. Initialize Your Project
+
+```bash
+mkdir my-app
+cd my-app
+bun init -y
+```
+
+## 2. Install Dependencies
+
+### Production Dependencies
+
+```bash
+bun add hono @hono/zod-openapi @scalar/hono-api-reference @venizia/ignis dotenv-flow
+```
+
+**What each package does:**
+- `hono` - High-performance web framework
+- `@hono/zod-openapi` - OpenAPI schema generation with Zod validation
+- `@scalar/hono-api-reference` - Interactive API documentation UI
+- `@venizia/ignis` - Core Ignis framework
+- `dotenv-flow` - Environment variable management
+
+### Development Dependencies
+
+```bash
+bun add -d typescript @types/bun @venizia/dev-configs tsc-alias tsconfig-paths
+```
+
+**What `@venizia/dev-configs` provides:**
+- Centralized ESLint configuration
+- Centralized Prettier configuration
+- Shared TypeScript base configs
+- Consistent code style across all Ignis projects
+
+> **Note:** Database dependencies (drizzle-orm, pg, etc.) will be added later in the [CRUD Tutorial](./building-a-crud-api.md).
+
+## 3. Configure Development Tools
+
+All development configurations are centralized in the `@venizia/dev-configs` package for consistency and ease of maintenance.
+
+### TypeScript
+
+Create `tsconfig.json` in your project root:
+
+```json
+{
+  "$schema": "http://json.schemastore.org/tsconfig",
+  "extends": "@venizia/dev-configs/tsconfig.common.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": "src",
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["src", "./*.config.*", ".prettierrc.*"],
+  "exclude": ["node_modules", "dist"]
+}
+```
+
+> **Note:** The `extends` field pulls in all TypeScript configuration from `@venizia/dev-configs/tsconfig.common.json`, which includes decorator support, strict mode, and ES2022 target settings.
+
+### Prettier
+
+Create `.prettierrc.mjs` for code formatting:
+
+```javascript
+import { prettierConfigs } from '@venizia/dev-configs';
+
+export default prettierConfigs;
+```
+
+Create `.prettierignore`:
+```
+dist
+node_modules
+*.log
+.*-audit.json
+```
+
+> **Customization:** To override Prettier settings, merge with the base config:
+> ```javascript
+> import { prettierConfigs } from '@venizia/dev-configs';
+> export default { ...prettierConfigs, printWidth: 120 };
+> ```
+
+### ESLint
+
+Create `eslint.config.mjs` for code linting:
+
+```javascript
+import { eslintConfigs } from '@venizia/dev-configs';
+
+export default eslintConfigs;
+```
+
+> **Customization:** To add project-specific rules:
+> ```javascript
+> import { eslintConfigs } from '@venizia/dev-configs';
+> export default [...eslintConfigs, { rules: { 'no-console': 'warn' } }];
+> ```
+
+> **Deep Dive:** See [Code Style Standards](./best-practices/code-style-standards.md) for detailed configuration options.
+
+:::tip A Note on Setup for Express/Hono/Fastify Developers
+If you're coming from a minimal framework like Express, Hono, or Fastify, you might be thinking: "This is a lot of setup just to get started!"
+
+You're right—and it's intentional. Here's why:
+
+**In Express/Hono/Fastify, you might start with:**
+```javascript
+const app = require('express')();
+app.get('/', (req, res) => res.json({ hello: 'world' }));
+app.listen(3000);
+```
+
+That's 3 lines. Beautiful and fast.
+
+**The problem comes later:**
+- Where do you put database logic?
+- How do you organize routes when you have 50+ endpoints?
+- How do you share code between routes?
+- How do you validate requests?
+- How do you generate API docs?
+- How do you test business logic in isolation?
+
+`Ignis` answers these questions upfront with:
+- **Type Safety (`tsconfig.json`):** Catches errors before they reach production
+- **Consistent Formatting (`.prettierrc.mjs`):** No more debates about code style in PRs
+- **Code Quality (`eslint.config.mjs`):** Prevents common bugs and enforces best practices
+
+**The trade-off:** You write 50-100 lines of config once. In return, you get a scalable architecture that handles projects with 10, 100, or 1000+ endpoints without becoming spaghetti code.
+
+If you're building a quick prototype or tiny API (< 5 endpoints), stick with plain Hono. But if your API will grow or be maintained by a team, this setup pays for itself within a week.
+:::
+
+## 4. Build Your First Application
+
+### Create Project Structure
+
+```bash
+mkdir -p src/controllers
+```
+
+Your structure will look like:
+```
+src/
+├── application.ts
+├── index.ts
+└── controllers/
+    └── hello.controller.ts
+```
+
+### Create Application Class
+
+Create `src/application.ts` - this is where you configure and register all your application resources:
+
+```typescript
+import { BaseApplication, IApplicationConfigs, IApplicationInfo, ValueOrPromise } from '@venizia/ignis';
+import { HelloController } from './controllers/hello.controller';
+import packageJson from '../package.json';
+
+// Define application configurations
+export const appConfigs: IApplicationConfigs = {
+  host: process.env.HOST ?? '0.0.0.0',        // Where your server listens
+  port: +(process.env.PORT ?? 3000),          // Port number
+  path: { base: '/api', isStrict: true },      // All routes will be under /api
+};
+
+export class Application extends BaseApplication {
+  // Required: Tell the framework about your app (used for API docs)
+  override getAppInfo(): ValueOrPromise<IApplicationInfo> {
+    return packageJson;
+  }
+
+  // Hook 1: Configure static file serving (e.g., serve images from /public)
+  staticConfigure(): void {
+    // Example: this.static({ folderPath: './public' })
+  }
+
+  // Hook 2: Add global middlewares (CORS, compression, etc.)
+  setupMiddlewares(): ValueOrPromise<void> {
+    // Example: this.server.use(cors())
+  }
+
+  // Hook 3: Register your resources (THIS IS THE MOST IMPORTANT ONE)
+  preConfigure(): ValueOrPromise<void> {
+    // As your app grows, you'll add:
+    // this.dataSource(PostgresDataSource);    // Database connection
+    // this.repository(UserRepository);        // Data access layer
+    // this.service(UserService);              // Business logic
+    // this.component(AuthComponent);          // Auth setup
+
+    // For now, just register our controller
+    this.controller(HelloController);
+  }
+
+  // Hook 4: Do cleanup or extra work after everything is set up
+  postConfigure(): ValueOrPromise<void> {
+    // Example: Seed database, start background jobs, etc.
+  }
+}
+```
+
+**Key takeaway:** You'll mostly work in `preConfigure()` when building your app. The other hooks are there when you need them.
+
+**Application Lifecycle Hooks:**
+| Hook | Purpose | Usage |
+|------|---------|-------|
+| `getAppInfo()` | Application metadata | Required - used for API docs |
+| `staticConfigure()` | Static file serving | Optional |
+| `setupMiddlewares()` | Global middlewares | Optional |
+| `preConfigure()` | **Register resources** | **Main hook** - register controllers, services, etc. |
+| `postConfigure()` | Post-initialization | Optional - seed data, background jobs |
+
+> **Deep Dive:** See [Application Class Reference](./core-concepts/application.md) for detailed lifecycle documentation.
+
+### Create Controller
+
+Create `src/controllers/hello.controller.ts` - controllers handle HTTP requests and return responses:
+
+```typescript
+import {
+  BaseController,
+  controller,
+  get, // Import the 'get' decorator
+  HTTP,
+  jsonContent,
+} from '@venizia/ignis';
+import { z } from '@hono/zod-openapi';
+import { Context } from 'hono';
+
+const BASE_PATH = '/hello';
+
+// The @controller decorator registers this class as a controller
+// All routes in this controller will be under /api/hello (remember path.base: '/api')
+@controller({ path: BASE_PATH })
+export class HelloController extends BaseController {
+  constructor() {
+    super({ scope: HelloController.name, path: BASE_PATH });
+  }
+
+  // The @get decorator defines a GET route at /api/hello/
+  @get({
+    configs: {
+      path: '/',
+      // This 'responses' config does two things:
+      // 1. Generates OpenAPI/Swagger documentation automatically
+      // 2. Validates that your handler returns the correct shape
+      responses: {
+        [HTTP.ResultCodes.RS_2.Ok]: jsonContent({
+          description: 'A simple hello message',
+          schema: z.object({ message: z.string() }), // Zod schema for validation
+        }),
+      },
+    },
+  })
+  sayHello(c: Context) {
+    // This looks just like Hono! Because it IS Hono under the hood.
+    return c.json({ message: 'Hello, World!' });
+  }
+
+  // You can add more routes here:
+  // @post({ configs: { ... } })
+  // createSomething(c: Context) { ... }
+
+  // For authenticated endpoints, add 'authStrategies' to the configs:
+  // @get({ configs: { path: '/secure', authStrategies: [Authentication.STRATEGY_JWT] } })
+  // secureMethod(c: Context) { /* ... */ }
+
+  // For database CRUD operations, use ControllerFactory (covered in the CRUD tutorial)
+}
+```
+
+**Controller Decorators:**
+- `@controller` - Registers the class as a controller with a base path
+- `@get`, `@post`, `@put`, `@patch`, `@del` - Define HTTP endpoints
+- Zod schemas provide automatic validation and OpenAPI docs
+
+> **Deep Dive:** See [Controllers Reference](./core-concepts/controllers.md) for advanced routing patterns and validation.
+
+### Create Entry Point
+
+Create `src/index.ts` - this starts your application:
+
+```typescript
+import { Application, appConfigs } from './application';
+import { LoggerFactory } from '@venizia/ignis';
+
+const logger = LoggerFactory.getLogger(['main']);
+
+const main = async () => {
+  const application = new Application({
+    scope: 'MyApp',
+    config: appConfigs,
+  });
+
+  const applicationName = process.env.APP_ENV_APPLICATION_NAME?.toUpperCase() ?? 'My-App';
+  logger.info('[main] Getting ready to start up %s Application...', applicationName);
+  await application.start();
+  return application;
+};
+
+export default main();
+```
+
+## 5. Run Your Application
+
+Add common application scripts to your `package.json`:
+
+```json
+"scripts": {
+    "lint": "bun run eslint && bun run prettier:cli",
+    "lint:fix": "bun run eslint --fix && bun run prettier:fix",
+    "prettier:cli": "prettier \"**/*.{js,ts}\" -l",
+    "prettier:fix": "bun run prettier:cli --write",
+    "eslint": "eslint --report-unused-disable-directives .",
+    "build": "tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
+    "compile:linux": "bun build --compile --minify --sourcemap --target=bun-linux-x64 ./src/index.ts --outfile ./dist/my_app",
+    "clean": "sh ./scripts/clean.sh",
+    "rebuild": "bun run clean && bun run build",
+    "migrate:dev": "NODE_ENV=development drizzle-kit push --config=src/migration.ts",
+    "generate-migration:dev": "NODE_ENV=development drizzle-kit generate --config=src/migration.ts",
+    "preserver:dev": "bun run rebuild",
+    "server:dev": "NODE_ENV=development bun .",
+    "server:prod": "NODE_ENV=production bun ."
+}
+```
+
+Create a cleanup script at `scripts/clean.sh`:
+
+```bash
+#!/bin/bash
+
+echo "START | Clean up..."
+
+rm -rf dist *.tsbuildinfo .eslintcache
+rm -rf artifact.zip
+
+echo "DONE | Clean up..."
+
+```
+
+Now, start your application:
+
+```bash
+bun run server:dev
+```
+
+Your server will be running on `http://localhost:3000`. You can access your new endpoint at `http://localhost:3000/api/hello`.
+
+Test with curl:
+```bash
+curl http://localhost:3000/api/hello
+```
+
+Response:
+```json
+{"message":"Hello, World!"}
+```
+
+Congratulations! You have successfully created and configured your first application with the `Ignis` framework.
+
+## Continue Your Journey
+
+✅ You now have a working Ignis application!
+
+**Next steps:**
+
+1. **[Building a CRUD API](./building-a-crud-api.md)** - Add database, create full REST API with CRUD operations
+2. **[Core Concepts](./core-concepts/application.md)** - Deep dive into application architecture
+3. **[Best Practices](./best-practices/architectural-patterns.md)** - Learn recommended patterns and practices
+
+> **Deep Dive:** See [API Usage Examples](./best-practices/api-usage-examples.md) for more routing patterns and controller techniques.

package/wiki/index.md

@@ -0,0 +1,48 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: "🔥 IGNIS"
+  text: "A TypeScript Server Infrastructure with Hono"
+  tagline: Enterprise-grade architecture meets Hono's ultrafast performance. Build scalable REST APIs with TypeScript.
+  actions:
+    - theme: brand
+      text: Get Started
+      link: /get-started/
+    - theme: alt
+      text: Quickstart
+      link: /get-started/quickstart
+    - theme: alt
+      text: Philosophy
+      link: /get-started/philosophy
+
+features:
+  - icon: <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-zap"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></svg>
+    title: Ultrafast Hono Performance
+    details: Leverage Hono's speed for high-performance APIs and serverless environments, ensuring your applications are always responsive.
+
+  - icon: <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-git-branch"><line x1="6" y1="3" x2="6" y2="15"></line><path d="M18 6l-6 6-6-6"></path><path d="M12 18V6"></path><path d="M18 12l-6 6-6-6"></path><circle cx="6" cy="18" r="3"></circle><circle cx="18" cy="6" r="3"></circle></svg>
+    title: Modular Package Architecture
+    details: Built as a monorepo with independent packages (@venizia/ignis, @venizia/ignis-helpers, @venizia/ignis-inversion, @venizia/dev-configs) for flexible, granular consumption.
+
+  - icon: <svg width="24" height="24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-share-2"><circle cx="18" cy="6" r="3"></circle><circle cx="6" cy="12" r="3"></circle><circle cx="18" cy="18" r="3"></circle><line x1="8.59" y1="13.51" x2="15.42" y2="16.49"></line><line x1="15.41" y1="7.51" x2="8.59" y2="10.49"></line></svg>
+    title: Powerful Dependency Injection
+    details: Utilize a custom, lightweight DI container to promote loose coupling, enhanced testability, and flexible code organization.
+
+  - icon: <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-layers"><polygon points="12 2 2 7 12 12 22 7 12 2"></polygon><polyline points="2 17 12 22 22 17"></polyline><polyline points="2 12 12 17 22 12"></polyline></svg>
+    title: Clear Layered Architecture
+    details: Organize your code with a strict separation of concerns (Controllers, Services, Repositories) for maintainability and clarity.
+
+  - icon: <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-book-open"><path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"></path><path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"></path></svg>
+    title: Automated OpenAPI Documentation
+    details: Generate interactive Swagger UI documentation effortlessly from your Zod schemas, simplifying API consumption and understanding.
+
+  - icon: <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-tool"><path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-2.06 2.06A7.5 7.5 0 0 1 1.07 11.24a7.5 7.5 0 0 1 10.6-10.6z"></path></svg>
+    title: Rich & Extensible Ecosystem
+    details: Benefit from comprehensive built-in helpers for Authentication, Logging, Database interactions, Queues, Worker Threads, and more.
+
+footer:
+  message: Released under the MIT License.
+  copyright: Copyright © 2024-present VENIZIA-AI
+---