kybernus 2.3.0 → 3.0.0

package/add-features/deploy/render/INSTRUCTIONS.md

@@ -0,0 +1,35 @@
+# 🚀 Deploy to Render
+
+Your deployment configuration has been generated for **Render**.
+
+## 📁 Files generated
+
+- `render.yaml` — Render Blueprint (Infrastructure as Code)
+
+## 🔑 1. Set Environment Variables
+
+The `render.yaml` marks sensitive variables as `sync: false`, meaning you need to set them manually:
+
+1. Go to [dashboard.render.com](https://dashboard.render.com) → Your Service → **Environment**
+2. Add each variable:
+
+| Variable | Description |
+|---|---|
+| `DATABASE_URL` | Your database connection string |
+| `JWT_SECRET` | A strong, random secret (auto-generated if `generateValue: true`) |
+
+> 💡 Render can also **provision a Postgres database** — create a new **PostgreSQL** service and connect it.
+
+## ⚡ 2. Deploy
+
+**Option A — Blueprint (recommended — uses `render.yaml`):**
+1. Go to [dashboard.render.com](https://dashboard.render.com) → **New → Blueprint**
+2. Connect your GitHub repo — Render reads `render.yaml` and sets everything up automatically
+
+**Option B — Manual Service:**
+1. Go to **New → Web Service**
+2. Connect your GitHub repo and fill in build/start commands from `render.yaml`
+
+## 📖 More Info
+- [Render Docs](https://render.com/docs)
+- [render.yaml Reference](https://render.com/docs/blueprint-spec)

package/add-features/deploy/render/java-spring.yaml

@@ -0,0 +1,14 @@
+services:
+  - type: web
+    name: my-spring-app
+    runtime: docker
+    plan: free
+    dockerfilePath: ./Dockerfile
+    branch: main
+    envVars:
+      - key: DATABASE_URL
+        sync: false
+      - key: JWT_SECRET
+        generateValue: true
+      - key: SPRING_PROFILES_ACTIVE
+        value: prod

package/add-features/deploy/render/nextjs.yaml

@@ -0,0 +1,17 @@
+services:
+  - type: web
+    name: my-nextjs-app
+    runtime: node
+    plan: free
+    buildCommand: npm install && npm run build
+    startCommand: npm start
+    branch: main
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: DATABASE_URL
+        sync: false
+      - key: JWT_SECRET
+        generateValue: true
+      - key: NEXTAUTH_URL
+        sync: false

package/add-features/deploy/render/nodejs.yaml

@@ -0,0 +1,15 @@
+services:
+  - type: web
+    name: my-node-app
+    runtime: node
+    plan: free
+    buildCommand: npm install && npm run build
+    startCommand: npm start
+    branch: main
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: DATABASE_URL
+        sync: false
+      - key: JWT_SECRET
+        generateValue: true

package/add-features/deploy/render/python-fastapi.yaml

@@ -0,0 +1,13 @@
+services:
+  - type: web
+    name: my-fastapi-app
+    runtime: python
+    plan: free
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT
+    branch: main
+    envVars:
+      - key: DATABASE_URL
+        sync: false
+      - key: JWT_SECRET
+        generateValue: true

package/add-features/deploy/vercel/INSTRUCTIONS.md

@@ -0,0 +1,40 @@
+# 🚀 Deploy to Vercel
+
+Your deployment configuration has been generated for **Vercel**.
+
+## 📁 Files generated
+
+- `vercel.json` — Vercel project configuration
+
+## 🔑 1. Set Environment Variables
+
+Before deploying, configure your environment variables in the **Vercel Dashboard**:
+
+1. Go to [vercel.com](https://vercel.com) → Your Project → **Settings → Environment Variables**
+2. Add each variable from your `.env` file:
+
+| Variable | Description |
+|---|---|
+| `DATABASE_URL` | Your database connection string |
+| `JWT_SECRET` | A strong, random secret for JWT signing |
+| `NODE_ENV` | Set to `production` |
+
+> 💡 Generate a strong JWT secret: `node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"`
+
+## ⚡ 2. Deploy
+
+**Option A — GitHub Auto-Deploy (recommended):**
+1. Push your code to GitHub
+2. Go to [vercel.com](https://vercel.com) → **New Project** → Import your repo
+3. Vercel auto-detects the framework and deploys on every push to `main`
+
+**Option B — Vercel CLI:**
+```bash
+npm install -g vercel
+vercel login
+vercel --prod
+```
+
+## 📖 More Info
+- [Vercel Docs](https://vercel.com/docs)
+- [Environment Variables on Vercel](https://vercel.com/docs/environment-variables)

package/add-features/deploy/vercel/nextjs.json

@@ -0,0 +1,16 @@
+{
+    "version": 2,
+    "name": "my-nextjs-app",
+    "builds": [
+        {
+            "src": "next.config.*",
+            "use": "@vercel/next"
+        }
+    ],
+    "env": {
+        "DATABASE_URL": "@database_url",
+        "JWT_SECRET": "@jwt_secret",
+        "NEXTAUTH_SECRET": "@nextauth_secret",
+        "NEXTAUTH_URL": "@nextauth_url"
+    }
+}

package/add-features/deploy/vercel/nodejs-express.json

@@ -0,0 +1,21 @@
+{
+    "version": 2,
+    "name": "my-express-api",
+    "builds": [
+        {
+            "src": "src/index.ts",
+            "use": "@vercel/node"
+        }
+    ],
+    "routes": [
+        {
+            "src": "/(.*)",
+            "dest": "src/index.ts"
+        }
+    ],
+    "env": {
+        "DATABASE_URL": "@database_url",
+        "JWT_SECRET": "@jwt_secret",
+        "NODE_ENV": "production"
+    }
+}

package/add-features/deploy/vercel/python-fastapi.json

@@ -0,0 +1,21 @@
+{
+    "version": 2,
+    "name": "my-fastapi-app",
+    "builds": [
+        {
+            "src": "app/main.py",
+            "use": "@vercel/python"
+        }
+    ],
+    "routes": [
+        {
+            "src": "/(.*)",
+            "dest": "app/main.py"
+        }
+    ],
+    "env": {
+        "DATABASE_URL": "@database_url",
+        "JWT_SECRET": "@jwt_secret",
+        "PYTHON_VERSION": "3.11"
+    }
+}

package/add-features/husky/INSTRUCTIONS.md

@@ -0,0 +1,52 @@
+# Husky + Commitlint
+
+## Files generated
+
+- `.husky/pre-commit` — runs `lint-staged` before each commit
+- `.husky/commit-msg` — validates commit message format
+- `commitlint.config.js` — enforces [Conventional Commits](https://www.conventionalcommits.org/)
+
+## Install dependencies
+
+```bash
+npm install -D husky lint-staged @commitlint/cli @commitlint/config-conventional
+```
+
+## Setup
+
+```bash
+npx husky init
+```
+
+Then copy the generated hook files to `.husky/`:
+```bash
+cp .husky/pre-commit .husky/commit-msg ./
+```
+
+Or, Kybernus already set this up — just run the init command above.
+
+---
+
+## Add lint-staged config to `package.json`
+
+```json
+{
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx}": ["eslint --fix", "prettier --write"],
+    "*.{json,md,yml}": ["prettier --write"]
+  }
+}
+```
+
+---
+
+## Commit message format
+
+```
+feat: add new endpoint
+fix: correct validation error
+chore: update dependencies
+docs: update README
+```
+
+Valid types: `feat`, `fix`, `chore`, `docs`, `style`, `refactor`, `test`, `perf`, `ci`, `build`, `revert`

package/add-features/husky/commit-msg

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit "$1"

package/add-features/husky/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    extends: ['@commitlint/config-conventional'],
+};

package/add-features/husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged

package/add-features/redis/.env.snippet

@@ -0,0 +1 @@
+REDIS_URL=redis://localhost:6379

package/add-features/redis/INSTRUCTIONS.md

@@ -0,0 +1,64 @@
+# Redis Cache
+
+## Files generated
+
+- `redis.ts` or `redis.py` in the root of `src/`
+- `docker-compose.snippet.yml` — add the `redis` service to your existing `docker-compose.yml`
+- `.env.snippet` — add `REDIS_URL` to your `.env`
+
+## Install dependencies
+
+### Node.js (Express or NestJS)
+```bash
+npm install redis
+npm install -D @types/redis
+```
+
+### Python FastAPI
+```bash
+pip install redis[asyncio]
+```
+
+---
+
+## Integration
+
+### Node.js Express — add to `app.ts` / `index.ts`:
+```typescript
+import { connectRedis } from './redis';
+
+// Before starting the server:
+await connectRedis();
+```
+
+### NestJS — add to `app.module.ts`:
+```typescript
+// Option 1: Use the redis.ts file as a custom provider
+// Option 2: Use @nestjs-modules/ioredis or nestjs-redis packages
+
+import { connectRedis } from './redis';
+
+// In bootstrap():
+await connectRedis();
+```
+
+### Python FastAPI — add to `main.py`:
+```python
+from redis import connect_redis, disconnect_redis
+
+@app.on_event("startup")
+async def startup():
+    await connect_redis()
+
+@app.on_event("shutdown")
+async def shutdown():
+    await disconnect_redis()
+```
+
+---
+
+## docker-compose
+
+Add the redis service block from `docker-compose.snippet.yml` to your existing `docker-compose.yml` under `services:`.
+
+Also make sure to merge the `redis_data` volume under the top-level `volumes:` key.

package/add-features/redis/docker-compose.snippet.yml

@@ -0,0 +1,18 @@
+services:
+  # Faltou essa linha principal
+  redis:
+    image: redis:7-alpine
+    container_name: ${PROJECT_NAME:-app}-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+    healthcheck:
+      test: [ "CMD", "redis-cli", "ping" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  redis_data:

package/add-features/redis/java-spring.java

@@ -0,0 +1,27 @@
+package com.example.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * Redis configuration using Spring Data Redis.
+ * Generated by: kybernus add redis
+ */
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+        template.setKeySerializer(new StringRedisSerializer());
+        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
+        return template;
+    }
+}

package/add-features/redis/nextjs.ts

@@ -0,0 +1,23 @@
+// Redis client for Next.js (server-side only)
+// Use in Server Components, API routes, or Server Actions
+// File generated by: kybernus add redis
+
+import { createClient } from 'redis';
+
+const globalForRedis = globalThis as unknown as {
+    redis: ReturnType<typeof createClient> | undefined;
+};
+
+export const redis =
+    globalForRedis.redis ??
+    createClient({
+        url: process.env.REDIS_URL || 'redis://localhost:6379',
+    });
+
+if (process.env.NODE_ENV !== 'production') globalForRedis.redis = redis;
+
+if (!redis.isOpen) {
+    redis.connect().catch(console.error);
+}
+
+export default redis;

package/add-features/redis/nodejs.ts

@@ -0,0 +1,14 @@
+import { createClient } from 'redis';
+
+const client = createClient({
+    url: process.env.REDIS_URL || 'redis://localhost:6379',
+});
+
+client.on('error', (err) => console.error('Redis error:', err));
+client.on('connect', () => console.log('✅ Redis connected'));
+
+export async function connectRedis(): Promise<void> {
+    await client.connect();
+}
+
+export { client as redis };

package/add-features/redis/python.py

@@ -0,0 +1,22 @@
+import redis.asyncio as aioredis
+from typing import Optional
+
+redis: Optional[aioredis.Redis] = None
+
+
+async def connect_redis() -> None:
+    global redis
+    redis_url = os.getenv("REDIS_URL", "redis://localhost:6379")
+    redis = await aioredis.from_url(redis_url, decode_responses=True)
+    print("✅ Redis connected")
+
+
+async def disconnect_redis() -> None:
+    if redis:
+        await redis.close()
+
+
+def get_redis() -> aioredis.Redis:
+    if redis is None:
+        raise RuntimeError("Redis is not connected. Call connect_redis() first.")
+    return redis

package/add-features/swagger/INSTRUCTIONS.md

@@ -0,0 +1,53 @@
+# Swagger / OpenAPI
+
+## Files generated
+
+- `swagger.ts` or `swagger.py` in the root of `src/`
+
+## Install dependencies
+
+### Node.js Express
+```bash
+npm install swagger-jsdoc swagger-ui-express
+npm install -D @types/swagger-jsdoc @types/swagger-ui-express
+```
+
+### NestJS
+```bash
+npm install @nestjs/swagger
+```
+
+### Python FastAPI
+> FastAPI has OpenAPI/Swagger built-in — no extra packages needed!
+
+---
+
+## Integration
+
+### Node.js Express — add to `app.ts`:
+```typescript
+import { setupSwagger } from './swagger';
+// after app is created:
+setupSwagger(app);
+```
+
+### NestJS — add to `main.ts`:
+```typescript
+import { setupSwagger } from './swagger';
+// after app is created, before app.listen():
+setupSwagger(app);
+```
+
+### Python FastAPI — add to `main.py`:
+```python
+from swagger import configure_swagger
+configure_swagger(app)
+```
+
+---
+
+## Docs URL
+
+After starting the server, open:
+- **Express / NestJS:** `http://localhost:3000/api/docs`
+- **FastAPI:** `http://localhost:8000/api/docs`

package/add-features/swagger/java-spring.java

@@ -0,0 +1,34 @@
+package com.example.config;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import org.springdoc.core.models.GroupedOpenApi;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Swagger / OpenAPI configuration using SpringDoc.
+ * Generated by: kybernus add swagger
+ *
+ * Docs available at: http://localhost:8080/swagger-ui.html
+ */
+@Configuration
+public class SwaggerConfig {
+
+    @Bean
+    public OpenAPI customOpenAPI() {
+        return new OpenAPI()
+                .info(new Info()
+                        .title("API Documentation")
+                        .version("1.0.0")
+                        .description("Auto-generated API docs by Kybernus"));
+    }
+
+    @Bean
+    public GroupedOpenApi publicApi() {
+        return GroupedOpenApi.builder()
+                .group("public")
+                .pathsToMatch("/api/**")
+                .build();
+    }
+}

package/add-features/swagger/nestjs.ts

@@ -0,0 +1,16 @@
+import { INestApplication } from '@nestjs/common';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+
+export function setupSwagger(app: INestApplication): void {
+    const config = new DocumentBuilder()
+        .setTitle('API Documentation')
+        .setDescription('Auto-generated API docs by Kybernus')
+        .setVersion('1.0')
+        .addBearerAuth()
+        .build();
+
+    const document = SwaggerModule.createDocument(app, config);
+    SwaggerModule.setup('api/docs', app, document);
+
+    console.log(`📄 Swagger docs available at /api/docs`);
+}

package/add-features/swagger/nextjs-route.ts

@@ -0,0 +1,11 @@
+// Next.js API route to serve Swagger UI
+// Place this file at: src/app/api/docs/route.ts
+// File generated by: kybernus add swagger
+
+import { getSwaggerSpec } from '../../../swagger';
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+    const spec = getSwaggerSpec();
+    return NextResponse.json(spec);
+}

package/add-features/swagger/nextjs-swagger.ts

@@ -0,0 +1,17 @@
+// Next.js Swagger setup using next-swagger-doc
+// File generated by: kybernus add swagger
+
+import { createSwaggerSpec } from 'next-swagger-doc';
+
+export const getSwaggerSpec = () =>
+    createSwaggerSpec({
+        apiFolder: 'src/app/api',
+        definition: {
+            openapi: '3.0.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+                description: 'Auto-generated API docs by Kybernus',
+            },
+        },
+    });

package/add-features/swagger/nodejs-express.ts

@@ -0,0 +1,30 @@
+import swaggerJsdoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { Express } from 'express';
+
+const options: swaggerJsdoc.Options = {
+    definition: {
+        openapi: '3.0.0',
+        info: {
+            title: 'API Documentation',
+            version: '1.0.0',
+            description: 'Auto-generated API docs by Kybernus',
+        },
+        servers: [
+            {
+                url: process.env.API_URL || 'http://localhost:3000',
+                description: 'Development server',
+            },
+        ],
+    },
+    apis: ['./src/**/*.ts'],
+};
+
+const swaggerSpec = swaggerJsdoc(options);
+
+export function setupSwagger(app: Express): void {
+    app.use('/api/docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
+    app.get('/api/docs.json', (_, res) => res.json(swaggerSpec));
+
+    console.log(`📄 Swagger docs available at /api/docs`);
+}

package/add-features/swagger/python-fastapi.py

@@ -0,0 +1,21 @@
+"""
+FastAPI has OpenAPI/Swagger built-in at /docs and /redoc.
+This file provides a custom configuration to enhance those pages.
+
+Apply by importing and calling configure_swagger(app) in your main.py.
+"""
+
+from fastapi import FastAPI
+
+
+def configure_swagger(app: FastAPI) -> None:
+    """Enhance the built-in FastAPI Swagger/OpenAPI docs."""
+    app.title = "API Documentation"
+    app.description = "Auto-generated API docs by Kybernus"
+    app.version = "1.0.0"
+    app.docs_url = "/api/docs"
+    app.redoc_url = "/api/redoc"
+    app.openapi_url = "/api/openapi.json"
+
+    print("📄 Swagger docs available at /api/docs")
+    print("📄 ReDoc available at /api/redoc")