kybernus 1.0.0

package/templates/nodejs-express/pro/hexagonal/README.md.hbs

@@ -0,0 +1,42 @@
+# {{projectName}}
+
+> Generated by [Kybernus CLI](https://kybernus.dev) 🚀 (Pro - Hexagonal Architecture)
+
+## Architecture
+
+This project follows **Hexagonal Architecture** (Ports & Adapters):
+
+```
+src/
+├── core/ # The Hexagon
+│ ├── domain/ # Business entities
+│ │ └── entities/
+│ ├── ports/ # Interfaces (contracts)
+│ │ ├── inbound/ # What the app CAN DO (use cases)
+│ │ └── outbound/ # What the app NEEDS
+│ └── AuthService.ts # Core business logic
+├── adapters/ # Outside the Hexagon
+│ ├── inbound/ # Driving adapters
+│ │ └── http/ # Express controllers
+│ └── outbound/ # Driven adapters
+│ └── persistence/ # Database implementations
+└── config/ # Application configuration
+```
+
+## Key Principles
+
+1. **Ports**: Interfaces that define boundaries
+2. **Adapters**: Implementations that connect to external systems
+3. **Dependency Inversion**: Core depends on abstractions, not implementations
+
+## Quick Start
+
+```bash
+npm install
+cp .env.example .env
+npm run dev
+```
+
+---
+
+Made with ❤️ using [Kybernus Pro](https://kybernus.dev/pro)

package/templates/nodejs-express/pro/hexagonal/docker-compose.yml.hbs

@@ -0,0 +1,18 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: {{kebabCase projectName}}-db
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: {{snakeCase projectName}}
+      ports:
+        - "5432:5432"
+        volumes:
+          - postgres_data:/var/lib/postgresql/data
+          restart: unless-stopped
+
+          volumes:
+            postgres_data:

package/templates/nodejs-express/pro/hexagonal/infra/main.tf.hbs

@@ -0,0 +1,83 @@
+# Terraform Infrastructure for {{projectName}}
+
+terraform {
+  required_version = ">= 1.0.0"
+
+  required_providers {
+    aws = {
+      source = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+
+# Uncomment for remote state (recommended for production)
+# backend "s3" {
+# bucket = "your-terraform-state-bucket"
+# key = "{{projectNameKebabCase}}/terraform.tfstate"
+# region = "us-east-1"
+# encrypt = true
+# dynamodb_table = "terraform-locks"
+# }
+}
+
+provider "aws" {
+  region = var.aws_region
+}
+
+# Variables
+variable "aws_region" {
+  description = "AWS region"
+  type = string
+  default = "us-east-1"
+}
+
+variable "environment" {
+  description = "Environment name (dev, staging, prod)"
+  type = string
+  default = "dev"
+}
+
+variable "app_name" {
+  description = "Application name"
+  type = string
+  default = "{{projectNameKebabCase}}"
+}
+
+# VPC
+module "vpc" {
+  source = "./modules/vpc"
+
+  app_name = var.app_name
+  environment = var.environment
+}
+
+# ECS Cluster
+module "ecs" {
+  source = "./modules/ecs"
+
+  app_name = var.app_name
+  environment = var.environment
+  vpc_id = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+}
+
+# RDS PostgreSQL
+module "rds" {
+  source = "./modules/rds"
+
+  app_name = var.app_name
+  environment = var.environment
+  vpc_id = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+  security_group_id = module.vpc.db_security_group_id
+}
+
+# Outputs
+output "ecs_cluster_name" {
+  value = module.ecs.cluster_name
+}
+
+output "rds_endpoint" {
+  value = module.rds.endpoint
+  sensitive = true
+}

package/templates/nodejs-express/pro/hexagonal/infra/modules/ecs/main.tf.hbs

@@ -0,0 +1,54 @@
+# ECS Module
+
+variable "app_name" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+variable "vpc_id" {
+  type = string
+}
+
+variable "subnet_ids" {
+  type = list(string)
+}
+
+# ECS Cluster
+resource "aws_ecs_cluster" "main" {
+  name = "${var.app_name}-${var.environment}"
+
+  setting {
+    name = "containerInsights"
+    value = "enabled"
+  }
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# ECS Capacity Provider
+resource "aws_ecs_cluster_capacity_providers" "main" {
+  cluster_name = aws_ecs_cluster.main.name
+
+  capacity_providers = ["FARGATE", "FARGATE_SPOT"]
+
+  default_capacity_provider_strategy {
+    base = 1
+    weight = 100
+    capacity_provider = "FARGATE"
+  }
+}
+
+# Outputs
+output "cluster_name" {
+  value = aws_ecs_cluster.main.name
+}
+
+output "cluster_arn" {
+  value = aws_ecs_cluster.main.arn
+}

package/templates/nodejs-express/pro/hexagonal/infra/modules/rds/main.tf.hbs

@@ -0,0 +1,88 @@
+# RDS Module
+
+variable "app_name" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+variable "vpc_id" {
+  type = string
+}
+
+variable "subnet_ids" {
+  type = list(string)
+}
+
+variable "security_group_id" {
+  type = string
+}
+
+# DB Subnet Group
+resource "aws_db_subnet_group" "main" {
+  name = "${var.app_name}-${var.environment}"
+  subnet_ids = var.subnet_ids
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# RDS PostgreSQL Instance
+resource "aws_db_instance" "main" {
+  identifier = "${var.app_name}-${var.environment}"
+
+  engine = "postgres"
+  engine_version = "16"
+  instance_class = "db.t3.micro"
+
+  allocated_storage = 20
+  max_allocated_storage = 100
+  storage_type = "gp3"
+  storage_encrypted = true
+
+  db_name = replace(var.app_name, "-", "_")
+  username = "postgres"
+  password = random_password.db_password.result
+
+  db_subnet_group_name = aws_db_subnet_group.main.name
+  vpc_security_group_ids = [var.security_group_id]
+
+  backup_retention_period = 7
+  skip_final_snapshot = var.environment != "prod"
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# Random password for DB
+resource "random_password" "db_password" {
+  length = 32
+  special = false
+}
+
+# Store password in SSM
+resource "aws_ssm_parameter" "db_password" {
+  name = "/${var.app_name}/${var.environment}/db-password"
+  description = "Database password for ${var.app_name}"
+  type = "SecureString"
+  value = random_password.db_password.result
+
+  tags = {
+    Environment = var.environment
+  }
+}
+
+# Outputs
+output "endpoint" {
+  value = aws_db_instance.main.endpoint
+}
+
+output "db_name" {
+  value = aws_db_instance.main.db_name
+}

package/templates/nodejs-express/pro/hexagonal/infra/modules/vpc/main.tf.hbs

@@ -0,0 +1,107 @@
+# VPC Module
+
+variable "app_name" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+# VPC
+resource "aws_vpc" "main" {
+  cidr_block = "10.0.0.0/16"
+  enable_dns_hostnames = true
+  enable_dns_support = true
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}-vpc"
+    Environment = var.environment
+  }
+}
+
+# Public Subnets
+resource "aws_subnet" "public" {
+  count = 2
+  vpc_id = aws_vpc.main.id
+  cidr_block = "10.0.${count.index + 1}.0/24"
+  availability_zone = data.aws_availability_zones.available.names[count.index]
+
+  map_public_ip_on_launch = true
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}-public-${count.index + 1}"
+    Environment = var.environment
+  }
+}
+
+# Private Subnets
+resource "aws_subnet" "private" {
+  count = 2
+  vpc_id = aws_vpc.main.id
+  cidr_block = "10.0.${count.index + 10}.0/24"
+  availability_zone = data.aws_availability_zones.available.names[count.index]
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}-private-${count.index + 1}"
+    Environment = var.environment
+  }
+}
+
+# Internet Gateway
+resource "aws_internet_gateway" "main" {
+  vpc_id = aws_vpc.main.id
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}-igw"
+    Environment = var.environment
+  }
+}
+
+# Data source for AZs
+data "aws_availability_zones" "available" {
+  state = "available"
+}
+
+# Security Group for DB
+resource "aws_security_group" "db" {
+  name = "${var.app_name}-${var.environment}-db-sg"
+  description = "Security group for database"
+  vpc_id = aws_vpc.main.id
+
+  ingress {
+    from_port = 5432
+    to_port = 5432
+    protocol = "tcp"
+    cidr_blocks = ["10.0.0.0/16"]
+  }
+
+  egress {
+    from_port = 0
+    to_port = 0
+    protocol = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}-db-sg"
+    Environment = var.environment
+  }
+}
+
+# Outputs
+output "vpc_id" {
+  value = aws_vpc.main.id
+}
+
+output "public_subnet_ids" {
+  value = aws_subnet.public[*].id
+}
+
+output "private_subnet_ids" {
+  value = aws_subnet.private[*].id
+}
+
+output "db_security_group_id" {
+  value = aws_security_group.db.id
+}

package/templates/nodejs-express/pro/hexagonal/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/hexagonal/src/adapters/inbound/http/AuthController.ts.hbs

@@ -0,0 +1,48 @@
+import { Router, Request, Response } from 'express';
+import { IAuthPort } from '../../../core/ports/inbound/IAuthPort';
+
+/**
+* HTTP Auth Controller - Inbound Adapter
+* Adapts HTTP requests to the application port
+*/
+export function createAuthController(authService: IAuthPort): Router {
+    const router = Router();
+
+    router.post('/register', async (req: Request, res: Response) => {
+        try {
+            const { email, name, password } = req.body;
+            const result = await authService.register(email, name, password);
+            res.status(201).json({
+                token: result.token,
+                user: { id: result.user.id, email: result.user.email, name: result.user.name },
+            });
+        } catch (error: any) {
+            res.status(400).json({ error: error.message });
+        }
+    });
+
+    router.post('/login', async (req: Request, res: Response) => {
+        try {
+            const { email, password } = req.body;
+            const result = await authService.login(email, password);
+            res.json({
+                token: result.token,
+                user: { id: result.user.id, email: result.user.email, name: result.user.name },
+            });
+        } catch (error: any) {
+            res.status(401).json({ error: error.message });
+        }
+    });
+
+    router.get('/me', async (req: Request, res: Response) => {
+        const token = req.headers.authorization?.split(' ')[1];
+        if (!token) return res.status(401).json({ error: 'No token' });
+
+        const user = await authService.validateToken(token);
+        if (!user) return res.status(401).json({ error: 'Invalid token' });
+
+        res.json({ user: { id: user.id, email: user.email, name: user.name } });
+    });
+
+    return router;
+}

package/templates/nodejs-express/pro/hexagonal/src/adapters/outbound/SecurityAdapters.ts.hbs

@@ -0,0 +1,31 @@
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import { IPasswordHasherPort, ITokenGeneratorPort } from '../../../core/ports/outbound/ISecurityPorts';
+
+/**
+* Bcrypt Password Hasher Adapter
+*/
+export const bcryptAdapter: IPasswordHasherPort = {
+    async hash(password: string): Promise<string> {
+        return bcrypt.hash(password, 10);
+    },
+    async compare(password: string, hash: string): Promise<boolean> {
+        return bcrypt.compare(password, hash);
+    },
+};
+
+/**
+* JWT Token Generator Adapter
+*/
+export const jwtAdapter: ITokenGeneratorPort = {
+    generate(userId: string, email: string): string {
+        return jwt.sign({ id: userId, email }, process.env.JWT_SECRET || 'secret', { expiresIn: '7d' });
+    },
+    verify(token: string): { id: string; email: string } | null {
+        try {
+            return jwt.verify(token, process.env.JWT_SECRET || 'secret') as { id: string; email: string };
+        } catch {
+            return null;
+        }
+    },
+};

package/templates/nodejs-express/pro/hexagonal/src/adapters/outbound/persistence/InMemoryUserAdapter.ts.hbs

@@ -0,0 +1,38 @@
+import { User } from '../../core/domain/entities/User';
+import { IUserRepositoryPort } from '../../core/ports/outbound/IUserRepositoryPort';
+
+/**
+* In-Memory User Repository Adapter
+* Implements the outbound port
+*/
+export class InMemoryUserAdapter implements IUserRepositoryPort {
+    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.withId(id);
+        this.users.set(id, savedUser);
+        return savedUser;
+    }
+
+    async update(user: User): Promise<User> {
+        if (!user.id) throw new Error('User must have an ID');
+        this.users.set(user.id, user);
+        return user;
+    }
+
+    async delete(id: string): Promise<void> {
+        this.users.delete(id);
+    }
+}

package/templates/nodejs-express/pro/hexagonal/src/core/AuthService.ts.hbs

@@ -0,0 +1,51 @@
+import { User } from '../domain/entities/User';
+import { IAuthPort } from '../ports/inbound/IAuthPort';
+import { IUserRepositoryPort } from '../ports/outbound/IUserRepositoryPort';
+import { IPasswordHasherPort, ITokenGeneratorPort } from '../ports/outbound/ISecurityPorts';
+
+/**
+* Auth Service - Application Core
+* Implements the inbound port using outbound ports
+*/
+export class AuthService implements IAuthPort {
+    constructor(
+        private readonly userRepository: IUserRepositoryPort,
+        private readonly passwordHasher: IPasswordHasherPort,
+        private readonly tokenGenerator: ITokenGeneratorPort
+    ) {}
+
+    async register(email: string, name: string, password: string): Promise<{ user: User; token: string }> {
+        const existingUser = await this.userRepository.findByEmail(email);
+        if (existingUser) {
+            throw new Error('User already exists');
+        }
+
+        const hashedPassword = await this.passwordHasher.hash(password);
+        const user = new User(undefined, email, name, hashedPassword);
+        const savedUser = await this.userRepository.save(user);
+        const token = this.tokenGenerator.generate(savedUser.id!, savedUser.email);
+
+        return { user: savedUser, token };
+    }
+
+    async login(email: string, password: string): Promise<{ user: User; token: string }> {
+        const user = await this.userRepository.findByEmail(email);
+        if (!user) {
+            throw new Error('Invalid credentials');
+        }
+
+        const isValid = await this.passwordHasher.compare(password, user.password);
+        if (!isValid) {
+            throw new Error('Invalid credentials');
+        }
+
+        const token = this.tokenGenerator.generate(user.id!, user.email);
+        return { user, token };
+    }
+
+    async validateToken(token: string): Promise<User | null> {
+        const decoded = this.tokenGenerator.verify(token);
+        if (!decoded) return null;
+        return this.userRepository.findById(decoded.id);
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+* User Entity - Core Domain
+* Hexagonal Architecture: This is the heart of the hexagon
+*/
+export class User {
+    constructor(
+        public readonly id: string | undefined,
+        public readonly email: string,
+        public readonly name: string,
+        public readonly password: string,
+        public readonly stripeCustomerId?: string,
+        public readonly createdAt: Date = new Date()
+    ) {
+        this.validateEmail(email);
+        this.validatePassword(password);
+    }
+
+    private validateEmail(email: string): void {
+        if (!email || !email.includes('@')) {
+            throw new Error('Invalid email format');
+        }
+    }
+
+    private validatePassword(password: string): void {
+        if (!password || password.length < 8) { throw new Error('Password must be at least 8 characters'); } } withId(id:
+        string): User { return new User(id, this.email, this.name, this.password, this.stripeCustomerId, this.createdAt); }
+        withStripeCustomerId(customerId: string): User { return new User(this.id, this.email, this.name, this.password,
+        customerId, this.createdAt); } }

package/templates/nodejs-express/pro/hexagonal/src/core/ports/inbound/IAuthPort.ts.hbs

@@ -0,0 +1,11 @@
+import { User } from '../../domain/entities/User';
+
+/**
+* Auth Port - Inbound (Driving) Port
+* Defines what the application CAN DO (use cases)
+*/
+export interface IAuthPort {
+    register(email: string, name: string, password: string): Promise<{ user: User; token: string }>;
+    login(email: string, password: string): Promise<{ user: User; token: string }>;
+    validateToken(token: string): Promise<User | null>;
+}

package/templates/nodejs-express/pro/hexagonal/src/core/ports/outbound/ISecurityPorts.ts.hbs

@@ -0,0 +1,15 @@
+/**
+* Password Hasher Port - Outbound Port
+*/
+export interface IPasswordHasherPort {
+    hash(password: string): Promise<string>;
+    compare(password: string, hash: string): Promise<boolean>;
+}
+
+/**
+* Token Generator Port - Outbound Port
+*/
+export interface ITokenGeneratorPort {
+    generate(userId: string, email: string): string;
+    verify(token: string): { id: string; email: string } | null;
+}

package/templates/nodejs-express/pro/hexagonal/src/core/ports/outbound/IUserRepositoryPort.ts.hbs

@@ -0,0 +1,13 @@
+import { User } from '../../domain/entities/User';
+
+/**
+* User Repository Port - Outbound (Driven) Port
+* Defines what the application NEEDS from the outside world
+*/
+export interface IUserRepositoryPort {
+    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>;
+}