kybernus 1.0.0

package/templates/nodejs-express/pro/clean/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/clean/src/application/services/AuthService.ts.hbs

@@ -0,0 +1,66 @@
+import { IUserRepository } from '../../domain/repositories/IUserRepository';
+import { RegisterUserUseCase } from '../../domain/usecases/RegisterUserUseCase';
+import { LoginUserUseCase } from '../../domain/usecases/LoginUserUseCase';
+
+export interface RegisterDTO {
+    email: string;
+    name: string;
+    password: string;
+}
+
+export interface LoginDTO {
+    email: string;
+    password: string;
+}
+
+export interface AuthResponseDTO {
+    token: string;
+    user: {
+        id: string;
+        email: string;
+        name: string;
+    };
+}
+
+/**
+* Auth Service - Application Layer
+* Orchestrates use cases and handles DTOs
+*/
+export class AuthService {
+    private registerUseCase: RegisterUserUseCase;
+    private loginUseCase: LoginUserUseCase;
+
+    constructor(
+        userRepository: IUserRepository,
+        passwordHasher: { hash: (password: string) => Promise<string>; compare: (password: string, hash: string) => Promise
+        <boolean> },
+        tokenGenerator: { generate: (userId: string, email: string) => string }
+    ) {
+        this.registerUseCase = new RegisterUserUseCase(userRepository, passwordHasher, tokenGenerator);
+        this.loginUseCase = new LoginUserUseCase(userRepository, passwordHasher, tokenGenerator);
+    }
+
+    async register(dto: RegisterDTO): Promise<AuthResponseDTO> {
+        const result = await this.registerUseCase.execute(dto);
+        return {
+            token: result.token,
+            user: {
+                id: result.user.id!,
+                email: result.user.email,
+                name: result.user.name,
+            },
+        };
+    }
+
+    async login(dto: LoginDTO): Promise<AuthResponseDTO> {
+        const result = await this.loginUseCase.execute(dto);
+        return {
+            token: result.token,
+            user: {
+                id: result.user.id!,
+                email: result.user.email,
+                name: result.user.name,
+            },
+        };
+    }
+}

package/templates/nodejs-express/pro/clean/src/domain/entities/User.ts.hbs

@@ -0,0 +1,38 @@
+/**
+* User Entity - Domain Layer
+* Pure business logic, no framework dependencies
+*/
+export interface UserProps {
+    id?: string;
+    email: string;
+    name: string;
+    password: string;
+    stripeCustomerId?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+export class User {
+    private props: UserProps;
+
+    private constructor(props: UserProps) {
+        this.props = {
+            ...props,
+            createdAt: props.createdAt || new Date(),
+            updatedAt: props.updatedAt || new Date(),
+        };
+    }
+
+    static create(props: UserProps): User {
+        // Domain validation
+        if (!props.email || !props.email.includes('@')) {
+            throw new Error('Invalid email format');
+        }
+        if (!props.password || props.password.length < 8) { throw new Error('Password must be at least 8 characters'); } return
+        new User(props); } static restore(props: UserProps): User { return new User(props); } get id(): string | undefined {
+            return this.props.id; } get email(): string { return this.props.email; } get name(): string { return
+            this.props.name; } get password(): string { return this.props.password; } get stripeCustomerId(): string | undefined
+            { return this.props.stripeCustomerId; } setStripeCustomerId(customerId: string): void {
+                this.props.stripeCustomerId=customerId; this.props.updatedAt=new Date(); } toJSON() { return { id: this.props.id,
+                email: this.props.email, name: this.props.name, stripeCustomerId: this.props.stripeCustomerId, createdAt:
+                this.props.createdAt, updatedAt: this.props.updatedAt, }; } }

package/templates/nodejs-express/pro/clean/src/domain/repositories/IUserRepository.ts.hbs

@@ -0,0 +1,13 @@
+import { User } from '../entities/User';
+
+/**
+* User Repository Interface - Domain Layer
+* Defines the contract for user persistence
+*/
+export interface IUserRepository {
+    findById(id: string): Promise<User | null>;
+    findByEmail(email: string): Promise<User | null>;
+    save(user: User): Promise<User>;
+    update(user: User): Promise<User>;
+    delete(id: string): Promise<void>;
+}

package/templates/nodejs-express/pro/clean/src/domain/usecases/LoginUserUseCase.ts.hbs

@@ -0,0 +1,39 @@
+import { User } from '../entities/User';
+import { IUserRepository } from '../repositories/IUserRepository';
+
+export interface LoginUserInput {
+    email: string;
+    password: string;
+}
+
+export interface LoginUserOutput {
+    user: User;
+    token: string;
+}
+
+/**
+* Login User Use Case - Domain Layer
+*/
+export class LoginUserUseCase {
+    constructor(
+        private userRepository: IUserRepository,
+        private passwordHasher: { compare: (password: string, hash: string) => Promise<boolean> },
+        private tokenGenerator: { generate: (userId: string, email: string) => string }
+    ) {}
+
+    async execute(input: LoginUserInput): Promise<LoginUserOutput> {
+        const user = await this.userRepository.findByEmail(input.email);
+        if (!user) {
+            throw new Error('Invalid credentials');
+        }
+
+        const isValidPassword = await this.passwordHasher.compare(input.password, user.password);
+        if (!isValidPassword) {
+            throw new Error('Invalid credentials');
+        }
+
+        const token = this.tokenGenerator.generate(user.id!, user.email);
+
+        return { user, token };
+    }
+}

package/templates/nodejs-express/pro/clean/src/domain/usecases/RegisterUserUseCase.ts.hbs

@@ -0,0 +1,51 @@
+import { User } from '../entities/User';
+import { IUserRepository } from '../repositories/IUserRepository';
+
+export interface RegisterUserInput {
+    email: string;
+    name: string;
+    password: string;
+}
+
+export interface RegisterUserOutput {
+    user: User;
+    token: string;
+}
+
+/**
+* Register User Use Case - Domain Layer
+* Pure business logic for user registration
+*/
+export class RegisterUserUseCase {
+    constructor(
+        private userRepository: IUserRepository,
+        private passwordHasher: { hash: (password: string) => Promise<string> },
+        private tokenGenerator: { generate: (userId: string, email: string) => string }
+    ) {}
+
+    async execute(input: RegisterUserInput): Promise<RegisterUserOutput> {
+        // Check if user already exists
+        const existingUser = await this.userRepository.findByEmail(input.email);
+        if (existingUser) {
+            throw new Error('User already exists');
+        }
+
+        // Hash password
+        const hashedPassword = await this.passwordHasher.hash(input.password);
+
+        // Create user entity
+        const user = User.create({
+            email: input.email,
+            name: input.name,
+            password: hashedPassword,
+        });
+
+        // Persist user
+        const savedUser = await this.userRepository.save(user);
+
+        // Generate token
+        const token = this.tokenGenerator.generate(savedUser.id!, savedUser.email);
+
+        return { user: savedUser, token };
+    }
+}

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

@@ -0,0 +1,40 @@
+import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import morgan from 'morgan';
+import dotenv from 'dotenv';
+
+import authRoutes from './infrastructure/http/controllers/AuthController';
+
+dotenv.config();
+
+const app = express();
+
+// Security
+app.use(helmet());
+app.use(cors());
+app.use(morgan('dev'));
+
+// Body parsing
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Health check
+app.get('/health', (_, res) => res.json({ status: 'ok' }));
+
+// Routes
+app.use('/api/auth', authRoutes);
+
+// Error handling
+app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
+    console.error(err.stack);
+    res.status(500).json({ error: 'Internal server error' });
+});
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+    console.log(`🚀 {{pascalCase projectName}} running on port ${PORT}`);
+    console.log(`📐 Architecture: Clean Architecture`);
+    console.log(`🔗 Health check: http://localhost:${PORT}/health`);
+});

package/templates/nodejs-express/pro/clean/src/infrastructure/database/InMemoryUserRepository.ts.hbs

@@ -0,0 +1,46 @@
+import { User } from '../../domain/entities/User';
+import { IUserRepository } from '../../domain/repositories/IUserRepository';
+
+/**
+* In-Memory User Repository - Infrastructure Layer
+* Replace with actual database implementation (Prisma, TypeORM, etc.)
+*/
+export class InMemoryUserRepository implements IUserRepository {
+    private users: Map<string, User> = new Map();
+
+    async findById(id: string): Promise<User | null> {
+        return this.users.get(id) || null;
+    }
+
+    async findByEmail(email: string): Promise<User | null> {
+        for (const user of this.users.values()) {
+            if (user.email === email) {
+                return user;
+            }
+        }
+        return null;
+    }
+
+    async save(user: User): Promise<User> {
+        const id = Date.now().toString();
+        const savedUser = User.restore({
+            id,
+            email: user.email,
+            name: user.name,
+            password: user.password,
+            stripeCustomerId: user.stripeCustomerId,
+        });
+        this.users.set(id, savedUser);
+        return savedUser;
+    }
+
+    async update(user: User): Promise<User> {
+        if (!user.id) throw new Error('User must have an ID to update');
+        this.users.set(user.id, user);
+        return user;
+    }
+
+    async delete(id: string): Promise<void> {
+        this.users.delete(id);
+    }
+}

package/templates/nodejs-express/pro/clean/src/infrastructure/http/controllers/AuthController.ts.hbs

@@ -0,0 +1,45 @@
+import { Router, Request, Response } from 'express';
+import { AuthService } from '../../../application/services/AuthService';
+import { InMemoryUserRepository } from '../../database/InMemoryUserRepository';
+import { bcryptPasswordHasher } from '../../providers/PasswordHasher';
+import { jwtTokenGenerator } from '../../providers/TokenGenerator';
+import { authMiddleware, AuthRequest } from '../middlewares/AuthMiddleware';
+
+const router = Router();
+
+// Dependency Injection
+const userRepository = new InMemoryUserRepository();
+const authService = new AuthService(userRepository, bcryptPasswordHasher, jwtTokenGenerator);
+
+/**
+* @route POST /api/auth/register
+*/
+router.post('/register', async (req: Request, res: Response) => {
+    try {
+        const result = await authService.register(req.body);
+        res.status(201).json(result);
+    } catch (error: any) {
+        res.status(400).json({ error: error.message });
+    }
+});
+
+/**
+* @route POST /api/auth/login
+*/
+router.post('/login', async (req: Request, res: Response) => {
+    try {
+        const result = await authService.login(req.body);
+        res.json(result);
+    } catch (error: any) {
+        res.status(401).json({ error: error.message });
+    }
+});
+
+/**
+* @route GET /api/auth/me
+*/
+router.get('/me', authMiddleware, (req: AuthRequest, res: Response) => {
+    res.json({ user: req.user });
+});
+
+export default router;

package/templates/nodejs-express/pro/clean/src/infrastructure/http/middlewares/AuthMiddleware.ts.hbs

@@ -0,0 +1,27 @@
+import { Request, Response, NextFunction } from 'express';
+import { jwtTokenGenerator } from '../../providers/TokenGenerator';
+
+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];
+    const decoded = jwtTokenGenerator.verify(token);
+
+    if (!decoded) {
+        return res.status(401).json({ error: 'Invalid token' });
+    }
+
+    req.user = decoded;
+    next();
+}

package/templates/nodejs-express/pro/clean/src/infrastructure/providers/PasswordHasher.ts.hbs

@@ -0,0 +1,14 @@
+import bcrypt from 'bcryptjs';
+
+/**
+* Bcrypt Password Hasher - Infrastructure Provider
+*/
+export const bcryptPasswordHasher = {
+    async hash(password: string): Promise<string> {
+        return bcrypt.hash(password, 10);
+    },
+
+    async compare(password: string, hash: string): Promise<boolean> {
+        return bcrypt.compare(password, hash);
+    },
+};

package/templates/nodejs-express/pro/clean/src/infrastructure/providers/TokenGenerator.ts.hbs

@@ -0,0 +1,25 @@
+import jwt from 'jsonwebtoken';
+
+/**
+* JWT Token Generator - Infrastructure Provider
+*/
+export const jwtTokenGenerator = {
+    generate(userId: string, email: string): string {
+        return jwt.sign(
+            { id: userId, email },
+            process.env.JWT_SECRET || 'your-secret-key',
+            { expiresIn: '7d' }
+        );
+    },
+
+    verify(token: string): { id: string; email: string } | null {
+        try {
+            return jwt.verify(token, process.env.JWT_SECRET || 'your-secret-key') as {
+                id: string;
+                email: string;
+            };
+        } catch {
+            return null;
+        }
+    },
+};

package/templates/nodejs-express/pro/clean/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/nodejs-express/pro/hexagonal/.env.example.hbs

@@ -0,0 +1,19 @@
+# {{projectName}} Environment Variables
+
+# Server
+NODE_ENV=development
+PORT=3000
+
+# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/{{projectNameSnakeCase}}
+
+# Authentication
+JWT_SECRET=your-super-secret-jwt-key-change-in-production
+
+# Stripe
+STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
+STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret
+STRIPE_PRICE_ID=price_your_price_id
+
+# Frontend URL (for redirects)
+FRONTEND_URL=http://localhost:3001

package/templates/nodejs-express/pro/hexagonal/.github/workflows/ci-cd.yml.hbs

@@ -0,0 +1,88 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+    pull_request:
+      branches: [main]
+
+      env:
+        NODE_VERSION: '20'
+        AWS_REGION: 'us-east-1'
+
+        jobs:
+          test:
+            runs-on: ubuntu-latest
+
+            steps:
+              - uses: actions/checkout@v4
+
+              - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                node-version: $\{{ env.NODE_VERSION }}
+                cache: 'npm'
+
+                - name: Install dependencies
+                run: npm ci
+
+                - name: Run linter
+                run: npm run lint --if-present
+
+                - name: Run tests
+                run: npm test --if-present
+
+                - name: Build
+                run: npm run build
+
+                build-and-push:
+                  needs: test
+                  runs-on: ubuntu-latest
+                  if: github.ref == 'refs/heads/main'
+
+                  steps:
+                    - uses: actions/checkout@v4
+
+                    - name: Configure AWS credentials
+                    uses: aws-actions/configure-aws-credentials@v4
+                    with:
+                      aws-access-key-id: $\{{ secrets.AWS_ACCESS_KEY_ID }}
+                      aws-secret-access-key: $\{{ secrets.AWS_SECRET_ACCESS_KEY }}
+                      aws-region: $\{{ env.AWS_REGION }}
+
+                      - name: Login to Amazon ECR
+                      id: login-ecr
+                      uses: aws-actions/amazon-ecr-login@v2
+
+                      - name: Build, tag, and push image to Amazon ECR
+                      env:
+                        ECR_REGISTRY: $\{{ steps.login-ecr.outputs.registry }}
+                        ECR_REPOSITORY: {{projectNameKebabCase}}
+                        IMAGE_TAG: $\{{ github.sha }}
+                        run: |
+                        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+                        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:latest .
+                        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+                        docker push $ECR_REGISTRY/$ECR_REPOSITORY:latest
+
+                        deploy:
+                          needs: build-and-push
+                          runs-on: ubuntu-latest
+                          if: github.ref == 'refs/heads/main'
+
+                          steps:
+                            - uses: actions/checkout@v4
+
+                            - name: Configure AWS credentials
+                            uses: aws-actions/configure-aws-credentials@v4
+                            with:
+                              aws-access-key-id: $\{{ secrets.AWS_ACCESS_KEY_ID }}
+                              aws-secret-access-key: $\{{ secrets.AWS_SECRET_ACCESS_KEY }}
+                              aws-region: $\{{ env.AWS_REGION }}
+
+                              - name: Deploy to ECS
+                              run: |
+                              aws ecs update-service \
+                              --cluster {{projectNameKebabCase}}-prod \
+                              --service {{projectNameKebabCase}}-api \
+                              --force-new-deployment

package/templates/nodejs-express/pro/hexagonal/Dockerfile.hbs

@@ -0,0 +1,45 @@
+# Production Dockerfile for {{projectName}}
+
+# Build stage
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source code
+COPY . .
+
+# Build TypeScript
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine AS production
+
+WORKDIR /app
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# Copy built application
+COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
+COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
+
+# Switch to non-root user
+USER nodejs
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+# Start application
+CMD ["node", "dist/index.js"]