kybernus 1.0.0

package/templates/nodejs-express/pro/mvc/package.json.hbs

@@ -0,0 +1,55 @@
+{
+  "name": "{{kebabCase projectName}}",
+  "version": "1.0.0",
+  "description": "Generated by Kybernus CLI (Pro)",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "rimraf dist && tsc",
+    "start": "node dist/index.js",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test": "jest"
+  },
+  "keywords": [
+    "express",
+    "api",
+    "typescript",
+    "mvc",
+    "saas",
+    "stripe",
+    "auth"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2",
+    "dotenv": "^16.4.5",
+    "cors": "^2.8.5",
+    "helmet": "^7.1.0",
+    "morgan": "^1.10.0",
+    "jsonwebtoken": "^9.0.2",
+    "bcryptjs": "^2.4.3",
+    "stripe": "^14.14.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.19",
+    "@types/cors": "^2.8.17",
+    "@types/morgan": "^1.9.9",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/bcryptjs": "^2.4.6",
+    "typescript": "^5.3.3",
+    "tsx": "^4.7.1",
+    "rimraf": "^5.0.5",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "prettier": "^3.2.5",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.12"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/nodejs-express/pro/mvc/src/app.ts.hbs

@@ -0,0 +1,34 @@
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import morgan from 'morgan';
+import routes from './routes';
+import authRoutes from './controllers/auth.controller';
+import paymentsRoutes from './controllers/payments.controller';
+import { errorHandler } from './middleware/errorHandler';
+
+const app = express();
+
+// Security middleware
+app.use(helmet());
+
+// CORS
+app.use(cors());
+
+// Logging
+app.use(morgan('dev'));
+
+// Body parsing (raw for Stripe webhooks)
+app.use('/api/payments/webhook', express.raw({ type: 'application/json' }));
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Routes
+app.use('/api', routes);
+app.use('/api/auth', authRoutes);
+app.use('/api/payments', paymentsRoutes);
+
+// Error handling (must be last)
+app.use(errorHandler);
+
+export default app;

package/templates/nodejs-express/pro/mvc/src/config/database.ts.hbs

@@ -0,0 +1,10 @@
+/**
+* Database configuration
+*
+* Add your database connection logic here
+* Example with PostgreSQL / Prisma / TypeORM
+*/
+
+export const databaseConfig = {
+    url: process.env.DATABASE_URL || 'postgresql://localhost:5432/{{snakeCase projectName}}',
+};

package/templates/nodejs-express/pro/mvc/src/controllers/auth.controller.ts.hbs

@@ -0,0 +1,91 @@
+import { Router, Request, Response } from 'express';
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import { authMiddleware, AuthRequest } from '../middlewares/auth.middleware';
+
+const router = Router();
+
+// In-memory users store (replace with database in production)
+const users: { id: string; email: string; password: string }[] = [];
+
+/**
+* @route POST /api/auth/register
+* @desc Register a new user
+*/
+router.post('/register', async (req: Request, res: Response) => {
+    try {
+        const { email, password } = req.body;
+
+        if (!email || !password) {
+            return res.status(400).json({ error: 'Email and password are required' });
+        }
+
+        const existingUser = users.find(u => u.email === email);
+        if (existingUser) {
+            return res.status(400).json({ error: 'User already exists' });
+        }
+
+        const hashedPassword = await bcrypt.hash(password, 10);
+        const user = {
+            id: Date.now().toString(),
+            email,
+            password: hashedPassword,
+        };
+
+        users.push(user);
+
+        const token = jwt.sign(
+            { id: user.id, email: user.email },
+            process.env.JWT_SECRET || 'your-secret-key',
+            { expiresIn: '7d' }
+        );
+
+        res.status(201).json({ token, user: { id: user.id, email: user.email } });
+    } catch (error) {
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+* @route POST /api/auth/login
+* @desc Authenticate user and return token
+*/
+router.post('/login', async (req: Request, res: Response) => {
+    try {
+        const { email, password } = req.body;
+
+        if (!email || !password) {
+            return res.status(400).json({ error: 'Email and password are required' });
+        }
+
+        const user = users.find(u => u.email === email);
+        if (!user) {
+            return res.status(401).json({ error: 'Invalid credentials' });
+        }
+
+        const isValidPassword = await bcrypt.compare(password, user.password);
+        if (!isValidPassword) {
+            return res.status(401).json({ error: 'Invalid credentials' });
+        }
+
+        const token = jwt.sign(
+            { id: user.id, email: user.email },
+            process.env.JWT_SECRET || 'your-secret-key',
+            { expiresIn: '7d' }
+        );
+
+        res.json({ token, user: { id: user.id, email: user.email } });
+    } catch (error) {
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+* @route GET /api/auth/me
+* @desc Get current user info
+*/
+router.get('/me', authMiddleware, (req: AuthRequest, res: Response) => {
+    res.json({ user: req.user });
+});
+
+export default router;

package/templates/nodejs-express/pro/mvc/src/controllers/healthController.ts.hbs

@@ -0,0 +1,20 @@
+import { Request, Response } from 'express';
+
+/**
+* Health check controller
+*/
+class HealthController {
+    /**
+    * Check server health
+    */
+    check(req: Request, res: Response) {
+        res.status(200).json({
+            status: 'ok',
+            message: '{{pascalCase projectName}} API is running',
+            timestamp: new Date().toISOString(),
+            uptime: process.uptime(),
+        });
+    }
+}
+
+export default new HealthController();

package/templates/nodejs-express/pro/mvc/src/controllers/payments.controller.ts.hbs

@@ -0,0 +1,72 @@
+import { Router, Request, Response } from 'express';
+import { stripeService } from '../services/stripe.service';
+import { authMiddleware, AuthRequest } from '../middlewares/auth.middleware';
+
+const router = Router();
+
+/**
+* @route POST /api/payments/checkout
+* @desc Create a Stripe checkout session
+*/
+router.post('/checkout', authMiddleware, async (req: AuthRequest, res: Response) => {
+    try {
+        const { priceId } = req.body;
+
+        if (!priceId) {
+            return res.status(400).json({ error: 'Price ID is required' });
+        }
+
+        const session = await stripeService.createCheckoutSession({
+            priceId,
+            successUrl: `${process.env.FRONTEND_URL}/success?session_id={CHECKOUT_SESSION_ID}`,
+            cancelUrl: `${process.env.FRONTEND_URL}/cancel`,
+        });
+
+        res.json({ url: session.url });
+    } catch (error) {
+        console.error('Checkout error:', error);
+        res.status(500).json({ error: 'Failed to create checkout session' });
+    }
+});
+
+/**
+* @route POST /api/payments/portal
+* @desc Create a Stripe customer portal session
+*/
+router.post('/portal', authMiddleware, async (req: AuthRequest, res: Response) => {
+    try {
+        const { customerId } = req.body;
+
+        if (!customerId) {
+            return res.status(400).json({ error: 'Customer ID is required' });
+        }
+
+        const session = await stripeService.createPortalSession(
+            customerId,
+            `${process.env.FRONTEND_URL}/dashboard`
+        );
+
+        res.json({ url: session.url });
+    } catch (error) {
+        console.error('Portal error:', error);
+        res.status(500).json({ error: 'Failed to create portal session' });
+    }
+});
+
+/**
+* @route POST /api/payments/webhook
+* @desc Handle Stripe webhook events
+*/
+router.post('/webhook', async (req: Request, res: Response) => {
+    const signature = req.headers['stripe-signature'] as string;
+
+    try {
+        const result = await stripeService.handleWebhook(req.body, signature);
+        res.json(result);
+    } catch (error) {
+        console.error('Webhook error:', error);
+        res.status(400).json({ error: 'Webhook handling failed' });
+    }
+});
+
+export default router;

package/templates/nodejs-express/pro/mvc/src/index.ts.hbs

@@ -0,0 +1,12 @@
+import app from './app';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+    console.log(`🚀 {{pascalCase projectName}} server running on port ${PORT}`);
+    console.log(`📝 Environment: ${process.env.NODE_ENV || 'development'}`);
+    console.log(`🔗 Health check: http://localhost:${PORT}/api/health`);
+});

package/templates/nodejs-express/pro/mvc/src/middleware/errorHandler.ts.hbs

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from 'express';
+
+/**
+* Global error handling middleware
+*/
+export function errorHandler(
+    err: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction
+) {
+    console.error('❌ Error:', err);
+
+    const statusCode = res.statusCode !== 200 ? res.statusCode : 500;
+
+    res.status(statusCode).json({
+        error: {
+            message: err.message,
+            ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+        },
+    });
+}

package/templates/nodejs-express/pro/mvc/src/middlewares/auth.middleware.ts.hbs

@@ -0,0 +1,31 @@
+import jwt from 'jsonwebtoken';
+import { Request, Response, NextFunction } from 'express';
+
+export interface AuthRequest extends Request {
+    user?: {
+        id: string;
+        email: string;
+    };
+}
+
+export function authMiddleware(req: AuthRequest, res: Response, next: NextFunction) {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({ error: 'Token not provided' });
+    }
+
+    const token = authHeader.split(' ')[1];
+
+    try {
+        const decoded = jwt.verify(token, process.env.JWT_SECRET || 'your-secret-key') as {
+            id: string;
+            email: string;
+        };
+
+        req.user = decoded;
+        next();
+    } catch (error) {
+        return res.status(401).json({ error: 'Invalid token' });
+    }
+}

package/templates/nodejs-express/pro/mvc/src/routes/index.ts.hbs

@@ -0,0 +1,14 @@
+import { Router } from 'express';
+import healthController from '../controllers/healthController';
+
+const router = Router();
+
+// Health check endpoint
+router.get('/health', healthController.check);
+
+// Add your routes here
+// Example:
+// import userRoutes from './userRoutes';
+// router.use('/users', userRoutes);
+
+export default router;

package/templates/nodejs-express/pro/mvc/src/services/stripe.service.ts.hbs

@@ -0,0 +1,102 @@
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || '', {
+    apiVersion: '2024-12-18.acacia',
+});
+
+export interface CreateCheckoutSessionParams {
+    priceId: string;
+    customerId?: string;
+    successUrl: string;
+    cancelUrl: string;
+}
+
+export class StripeService {
+    /**
+    * Create a checkout session for subscription
+    */
+    async createCheckoutSession(params: CreateCheckoutSessionParams) {
+        const session = await stripe.checkout.sessions.create({
+            mode: 'subscription',
+            payment_method_types: ['card'],
+            line_items: [
+                {
+                    price: params.priceId,
+                    quantity: 1,
+                },
+            ],
+            customer: params.customerId,
+            success_url: params.successUrl,
+            cancel_url: params.cancelUrl,
+        });
+
+        return session;
+    }
+
+    /**
+    * Create a customer portal session
+    */
+    async createPortalSession(customerId: string, returnUrl: string) {
+        const session = await stripe.billingPortal.sessions.create({
+            customer: customerId,
+            return_url: returnUrl,
+        });
+
+        return session;
+    }
+
+    /**
+    * Handle webhook event
+    */
+    async handleWebhook(rawBody: Buffer, signature: string) {
+        const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET || '';
+
+        const event = stripe.webhooks.constructEvent(
+            rawBody,
+            signature,
+            webhookSecret
+        );
+
+        switch (event.type) {
+            case 'checkout.session.completed':
+            const session = event.data.object;
+            // Handle successful subscription
+            console.log('Checkout completed:', session.id);
+            break;
+
+            case 'customer.subscription.updated':
+            const subscription = event.data.object;
+            // Handle subscription update
+            console.log('Subscription updated:', subscription.id);
+            break;
+
+            case 'customer.subscription.deleted':
+            const deletedSubscription = event.data.object;
+            // Handle subscription cancellation
+            console.log('Subscription deleted:', deletedSubscription.id);
+            break;
+
+            case 'invoice.payment_failed':
+            const invoice = event.data.object;
+            // Handle failed payment
+            console.log('Payment failed:', invoice.id);
+            break;
+        }
+
+        return { received: true };
+    }
+
+    /**
+    * Create a Stripe customer
+    */
+    async createCustomer(email: string, name?: string) {
+        const customer = await stripe.customers.create({
+            email,
+            name,
+        });
+
+        return customer;
+    }
+}
+
+export const stripeService = new StripeService();

package/templates/nodejs-express/pro/mvc/template.json

@@ -0,0 +1,18 @@
+{
+    "name": "Node.js Express MVC",
+    "tier": "free",
+    "stack": "nodejs-express",
+    "version": "1.0.0",
+    "description": "Express.js REST API with TypeScript and MVC architecture",
+    "targetVersions": {
+        "node": ">=18.0.0",
+        "express": "^4.18.0",
+        "typescript": "^5.0.0"
+    },
+    "requiredConfig": [
+        "projectName"
+    ],
+    "optionalConfig": [
+        "useAI"
+    ]
+}

package/templates/nodejs-express/pro/mvc/tsconfig.json.hbs

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": [
+      "ES2022"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/templates/python-fastapi/free/mvc/README.md.hbs

@@ -0,0 +1,41 @@
+# {{projectName}}
+
+> Generated by [Kybernus CLI](https://kybernus.dev) 🚀 (Free)
+
+## Stack
+
+- **Framework**: FastAPI
+- **Python**: 3.11+
+- **Validation**: Pydantic v2
+
+## Quick Start
+
+```bash
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate # Linux/Mac
+# or: venv\Scripts\activate # Windows
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run development server
+uvicorn app.main:app --reload
+```
+
+## API Endpoints
+
+- `GET /api/health` - Health check
+- `GET /api/items` - List items
+- `POST /api/items` - Create item
+- `GET /api/items/{id}` - Get item
+- `DELETE /api/items/{id}` - Delete item
+
+## Documentation
+
+- Swagger UI: http://localhost:8000/docs
+- ReDoc: http://localhost:8000/redoc
+
+---
+
+Made with ❤️ using [Kybernus](https://kybernus.dev)

package/templates/python-fastapi/free/mvc/app/controllers/health.py.hbs

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/health")
+async def health_check():
+return {"status": "ok"}

package/templates/python-fastapi/free/mvc/app/controllers/items.py.hbs

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, HTTPException
+from typing import List
+from app.schemas.item import ItemCreate, ItemResponse
+from app.services.item_service import ItemService
+
+router = APIRouter()
+item_service = ItemService()
+
+@router.get("/", response_model=List[ItemResponse])
+async def get_items():
+return item_service.get_all()
+
+@router.get("/{item_id}", response_model=ItemResponse)
+async def get_item(item_id: str):
+item = item_service.get_by_id(item_id)
+if not item:
+raise HTTPException(status_code=404, detail="Item not found")
+return item
+
+@router.post("/", response_model=ItemResponse, status_code=201)
+async def create_item(item: ItemCreate):
+return item_service.create(item)
+
+@router.delete("/{item_id}", status_code=204)
+async def delete_item(item_id: str):
+if not item_service.delete(item_id):
+raise HTTPException(status_code=404, detail="Item not found")

package/templates/python-fastapi/free/mvc/app/main.py.hbs

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.controllers import health, items
+
+app = FastAPI(
+title="{{projectNamePascalCase}}",
+description="Generated by Kybernus CLI",
+version="1.0.0"
+)
+
+# CORS
+app.add_middleware(
+CORSMiddleware,
+allow_origins=["*"],
+allow_credentials=True,
+allow_methods=["*"],
+allow_headers=["*"],
+)
+
+# Routes
+app.include_router(health.router, prefix="/api", tags=["Health"])
+app.include_router(items.router, prefix="/api/items", tags=["Items"])
+
+@app.get("/")
+async def root():
+return {"message": "Welcome to {{projectNamePascalCase}} API"}

package/templates/python-fastapi/free/mvc/app/models/item.py.hbs

@@ -0,0 +1,11 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+import uuid
+
+@dataclass
+class Item:
+id: str = field(default_factory=lambda: str(uuid.uuid4()))
+name: str = ""
+description: Optional[str] = None
+created_at: datetime = field(default_factory=datetime.now)

package/templates/python-fastapi/free/mvc/app/schemas/item.py.hbs

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Optional
+
+class ItemBase(BaseModel):
+name: str
+description: Optional[str] = None
+
+class ItemCreate(ItemBase):
+pass
+
+class ItemResponse(ItemBase):
+id: str
+created_at: datetime
+
+class Config:
+from_attributes = True