kybernus 2.1.1 → 2.2.1

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

@@ -10,81 +10,213 @@ variable "environment" {
 
 # VPC
 resource "aws_vpc" "main" {
-  cidr_block = "10.0.0.0/16"
+  cidr_block           = "10.0.0.0/16"
   enable_dns_hostnames = true
-  enable_dns_support = true
+  enable_dns_support   = true
 
   tags = {
-    Name = "${var.app_name}-${var.environment}-vpc"
+    Name        = "${var.app_name}-${var.environment}-vpc"
     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"
+}
+
 # Public Subnets
 resource "aws_subnet" "public" {
-  count = 2
+  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
+  }
+}
+
+# Route Table for Public Subnets
+resource "aws_route_table" "public" {
   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
+  route {
+    cidr_block = "0.0.0.0/0"
+    gateway_id = aws_internet_gateway.main.id
+  }
+
+  tags = {
+    Name        = "${var.app_name}-${var.environment}-public-rt"
+    Environment = var.environment
+  }
+}
+
+# Association for Public Subnets
+resource "aws_route_table_association" "public" {
+  count          = 2
+  subnet_id      = aws_subnet.public[count.index].id
+  route_table_id = aws_route_table.public.id
+}
+
+# Elastic IP for NAT Gateway
+resource "aws_eip" "nat" {
+  count  = 1
+  domain = "vpc"
 
   tags = {
-    Name = "${var.app_name}-${var.environment}-public-${count.index + 1}"
+    Name        = "${var.app_name}-${var.environment}-nat-eip"
+    Environment = var.environment
+  }
+}
+
+# NAT Gateway (single NAT for cost savings, can change to 1 per AZ for production if needed)
+resource "aws_nat_gateway" "main" {
+  count         = 1
+  allocation_id = aws_eip.nat[0].id
+  subnet_id     = aws_subnet.public[0].id
+
+  depends_on = [aws_internet_gateway.main]
+
+  tags = {
+    Name        = "${var.app_name}-${var.environment}-nat"
     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"
+  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}"
+    Name        = "${var.app_name}-${var.environment}-private-${count.index + 1}"
     Environment = var.environment
   }
 }
 
-# Internet Gateway
-resource "aws_internet_gateway" "main" {
+# Route Table for Private Subnets
+resource "aws_route_table" "private" {
   vpc_id = aws_vpc.main.id
 
+  route {
+    cidr_block     = "0.0.0.0/0"
+    nat_gateway_id = aws_nat_gateway.main[0].id
+  }
+
   tags = {
-    Name = "${var.app_name}-${var.environment}-igw"
+    Name        = "${var.app_name}-${var.environment}-private-rt"
     Environment = var.environment
   }
 }
 
-# Data source for AZs
-data "aws_availability_zones" "available" {
-  state = "available"
+# Association for Private Subnets
+resource "aws_route_table_association" "private" {
+  count          = 2
+  subnet_id      = aws_subnet.private[count.index].id
+  route_table_id = aws_route_table.private.id
+}
+
+# Security Group for Load Balancer (ALB)
+resource "aws_security_group" "alb" {
+  name        = "${var.app_name}-${var.environment}-alb-sg"
+  description = "Security group for ALB"
+  vpc_id      = aws_vpc.main.id
+
+  ingress {
+    from_port   = 80
+    to_port     = 80
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+    description = "Allow HTTP from anywhere"
+  }
+
+  ingress {
+    from_port   = 443
+    to_port     = 443
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+    description = "Allow HTTPS from anywhere"
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+
+  tags = {
+    Name        = "${var.app_name}-${var.environment}-alb-sg"
+    Environment = var.environment
+  }
 }
 
-# Security Group for DB
+# Security Group for ECS Tasks
+resource "aws_security_group" "ecs_tasks" {
+  name        = "${var.app_name}-${var.environment}-ecs-tasks-sg"
+  description = "Security group for ECS tasks"
+  vpc_id      = aws_vpc.main.id
+
+  ingress {
+    from_port       = 0
+    to_port         = 0
+    protocol        = "-1"
+    security_groups = [aws_security_group.alb.id]
+    description     = "Allow all traffic from ALB"
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+    description = "Allow all outbound traffic"
+  }
+
+  tags = {
+    Name        = "${var.app_name}-${var.environment}-ecs-tasks-sg"
+    Environment = var.environment
+  }
+}
+
+# Security Group for Database (RDS)
 resource "aws_security_group" "db" {
-  name = "${var.app_name}-${var.environment}-db-sg"
+  name        = "${var.app_name}-${var.environment}-db-sg"
   description = "Security group for database"
-  vpc_id = aws_vpc.main.id
+  vpc_id      = aws_vpc.main.id
 
   ingress {
-    from_port = 5432
-    to_port = 5432
-    protocol = "tcp"
-    cidr_blocks = ["10.0.0.0/16"]
+    from_port       = 5432
+    to_port         = 5432
+    protocol        = "tcp"
+    security_groups = [aws_security_group.ecs_tasks.id]
+    description     = "Allow PostgreSQL access from ECS tasks"
   }
 
   egress {
-    from_port = 0
-    to_port = 0
-    protocol = "-1"
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
     cidr_blocks = ["0.0.0.0/0"]
   }
 
   tags = {
-    Name = "${var.app_name}-${var.environment}-db-sg"
+    Name        = "${var.app_name}-${var.environment}-db-sg"
     Environment = var.environment
   }
 }
@@ -104,4 +236,12 @@ output "private_subnet_ids" {
 
 output "db_security_group_id" {
   value = aws_security_group.db.id
-}
+}
+
+output "alb_security_group_id" {
+  value = aws_security_group.alb.id
+}
+
+output "ecs_tasks_security_group_id" {
+  value = aws_security_group.ecs_tasks.id
+}

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

@@ -9,7 +9,9 @@
     "start": "node dist/index.js",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
-    "test": "jest"
+    "test": "jest",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push"
   },
   "keywords": [
     "express",
@@ -30,7 +32,8 @@
     "morgan": "^1.10.0",
     "jsonwebtoken": "^9.0.2",
     "bcryptjs": "^2.4.3",
-    "stripe": "^14.14.0"
+    "stripe": "^14.14.0",
+    "@prisma/client": "^5.10.2"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -47,9 +50,10 @@
     "@typescript-eslint/parser": "^6.21.0",
     "prettier": "^3.2.5",
     "jest": "^29.7.0",
-    "@types/jest": "^29.5.12"
+    "@types/jest": "^29.5.12",
+    "prisma": "^5.10.2"
   },
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/templates/nodejs-express/mvc/prisma/schema.prisma.hbs

@@ -0,0 +1,31 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id               String   @id @default(uuid())
+  email            String   @unique
+  name             String?
+  password         String
+  stripeCustomerId String?  @map("stripe_customer_id")
+  createdAt        DateTime @default(now()) @map("created_at")
+  updatedAt        DateTime @updatedAt @map("updated_at")
+
+  @@map("users")
+}
+
+model Item {
+  id          String   @id @default(uuid())
+  name        String
+  description String?
+  price       Float?
+  createdAt   DateTime @default(now()) @map("created_at")
+  updatedAt   DateTime @updatedAt @map("updated_at")
+
+  @@map("items")
+}

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

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

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

@@ -1,55 +1,36 @@
 import { Router, Request, Response } from 'express';
-import jwt from 'jsonwebtoken';
-import bcrypt from 'bcryptjs';
+import { authService } from '../services/auth.service';
 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
-*/
+ * @route POST /api/auth/register
+ * @desc Register a new user
+ */
 router.post('/register', async (req: Request, res: Response) => {
     try {
-        const { email, password } = req.body;
+        const { email, name, 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 result = await authService.register(email, name, password);
+        res.status(201).json(result);
+    } catch (error: any) {
+        console.error('Registration error:', error);
+        if (error.message === 'User already exists') {
+            return res.status(400).json({ error: error.message });
         }
-
-        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
-*/
+ * @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;
@@ -58,34 +39,35 @@ router.post('/login', async (req: Request, res: Response) => {
             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' });
+        const result = await authService.login(email, password);
+        res.json(result);
+    } catch (error: any) {
+         console.error('Login error:', error);
+         if (error.message === 'Invalid credentials') {
+            return res.status(401).json({ error: error.message });
+         }
+         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 });
+ * @route GET /api/auth/me
+ * @desc Get current user info
+ */
+router.get('/me', authMiddleware, async (req: AuthRequest, res: Response) => {
+    try {
+         if (!req.user?.id) {
+             return res.status(401).json({ error: 'Unauthorized' });
+         }
+
+         const user = await authService.getMe(req.user.id);
+         res.json({ user });
+    } catch (error: any) {
+         if (error.message === 'User not found') {
+             return res.status(404).json({ error: error.message });
+         }
+         res.status(500).json({ error: 'Internal server error' });
+    }
 });
 
-export default router;
+export default router;

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

@@ -0,0 +1,29 @@
+import { Router, Request, Response } from 'express';
+import { prisma } from '../prisma/client';
+
+const router = Router();
+
+// Basic CRUD for Items using the new structure
+
+router.get('/', async (req: Request, res: Response) => {
+    try {
+        const items = await prisma.item.findMany();
+        res.json(items);
+    } catch (error) {
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+router.post('/', async (req: Request, res: Response) => {
+    try {
+        const { name, description, price } = req.body;
+        const item = await prisma.item.create({
+            data: { name, description, price }
+        });
+        res.status(201).json(item);
+    } catch (error) {
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+export default router;

package/templates/nodejs-express/mvc/src/models/README.md.hbs

@@ -0,0 +1,10 @@
+# Models Directory
+
+In an MVC application using Prisma, the true database models are defined centrally in `prisma/schema.prisma`. 
+
+This `models/` directory is typically used for:
+1. **Interfaces and Types**: TypeScript interfaces for data structures that don't directly map to the database (e.g., API response structures, complex DTOs).
+2. **Business Logic Models**: domain-driven models if your application requires a thicker model layer than what Prisma Client provides by default.
+3. **Mongoose/Sequelize**: If you were to swap Prisma out for an ODM like Mongoose or another ORM like Sequelize, those definitions would live here.
+
+Since we are using Prisma, you can simply import types directly generated by Prisma Client (e.g., `import { User, Item } from '@prisma/client'`) where needed.

package/templates/nodejs-express/mvc/src/prisma/client.ts.hbs

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();

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

@@ -0,0 +1,71 @@
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import { prisma } from '../prisma/client';
+
+export class AuthService {
+    async register(email: string, name: string, password: string) {
+        const existingUser = await prisma.user.findUnique({
+             where: { email }
+        });
+
+        if (existingUser) {
+            throw new Error('User already exists');
+        }
+
+        const hashedPassword = await bcrypt.hash(password, 10);
+        
+        const user = await prisma.user.create({
+            data: {
+                 email,
+                 name,
+                 password: hashedPassword
+            }
+        });
+
+        const token = jwt.sign(
+            { id: user.id, email: user.email },
+            process.env.JWT_SECRET || 'your-secret-key',
+            { expiresIn: '7d' }
+        );
+
+        return { token, user: { id: user.id, email: user.email, name: user.name } };
+    }
+
+    async login(email: string, password: string) {
+         const user = await prisma.user.findUnique({
+            where: { email }
+        });
+
+        if (!user) {
+            throw new Error('Invalid credentials');
+        }
+
+        const isValidPassword = await bcrypt.compare(password, user.password);
+        if (!isValidPassword) {
+            throw new Error('Invalid credentials');
+        }
+
+        const token = jwt.sign(
+            { id: user.id, email: user.email },
+            process.env.JWT_SECRET || 'your-secret-key',
+            { expiresIn: '7d' }
+        );
+
+        return { token, user: { id: user.id, email: user.email, name: user.name } };
+    }
+
+    async getMe(userId: string) {
+        const user = await prisma.user.findUnique({
+             where: { id: userId },
+             select: { id: true, email: true, name: true }
+         });
+         
+         if (!user) {
+             throw new Error('User not found');
+         }
+         
+         return user;
+    }
+}
+
+export const authService = new AuthService();