nodejs-structure-cli 1.0.0

package/templates/common/src/config/auth.js.ejs

@@ -0,0 +1,19 @@
+import { betterAuth } from "better-auth";
+<% if (database === 'MongoDB') { %>import { mongodbAdapter } from "better-auth/adapters/mongodb";
+import mongoose from "mongoose";<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>import { sequelizeAdapter } from "better-auth/adapters/sequelize";
+import sequelize from "./database";<% } %>
+
+export const auth = betterAuth({
+    database: <% if (database === 'MongoDB') { %>mongodbAdapter(mongoose.connection.db)<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>sequelizeAdapter(sequelize)<% } else { %>null // Better-Auth requires a database adapter<% } %>,
+    emailAndPassword: {
+        enabled: true
+    },
+    socialProviders: {
+        <% if (googleLogin === 'Google Login') { %>
+        google: {
+            clientId: process.env.GOOGLE_CLIENT_ID,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        },
+        <% } %>
+    },
+});

package/templates/common/src/config/auth.ts.ejs

@@ -0,0 +1,19 @@
+import { betterAuth } from "better-auth";
+<% if (database === 'MongoDB') { %>import { mongodbAdapter } from "better-auth/adapters/mongodb";
+import mongoose from "mongoose";<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>import { sequelizeAdapter } from "better-auth/adapters/sequelize";
+import sequelize from "./database";<% } %>
+
+export const auth = betterAuth({
+    database: <% if (database === 'MongoDB') { %>mongodbAdapter(mongoose.connection.db)<% } else if (database === 'MySQL' || database === 'PostgreSQL') { %>sequelizeAdapter(sequelize)<% } else { %>null<% } %>,
+    emailAndPassword: {
+        enabled: true
+    },
+    socialProviders: {
+        <% if (googleLogin === 'Google Login') { %>
+        google: {
+            clientId: process.env.GOOGLE_CLIENT_ID,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        },
+        <% } %>
+    },
+});

package/templates/common/src/controllers/authController.js.ejs

@@ -0,0 +1,101 @@
+<% if (auth === 'Better-Auth') { %>
+import { auth } from '../config/auth<% if (language === 'TypeScript') { %>.ts<% } %>';
+
+export const register = async (req, res, next) => {
+  try {
+    const { email, password, name } = req.body;
+    const user = await auth.api.signUpEmail({
+      body: {
+        email,
+        password,
+        name,
+      },
+    });
+    res.status(201).json({ message: 'User registered successfully', user });
+  } catch (error) {
+    next(error);
+  }
+};
+
+export const login = async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+    const session = await auth.api.signInEmail({
+      body: {
+        email,
+        password,
+      },
+    });
+    res.status(200).json({ message: 'Login successful', session });
+  } catch (error) {
+    next(error);
+  }
+};
+<% } else if (auth === 'JWT') { %>
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+
+// Mock User database (In production, use your database models)
+const users = []; 
+
+export const register = async (req, res, next) => {
+  try {
+    const { email, password, name } = req.body;
+    
+    const existingUser = users.find(u => u.email === email);
+    if (existingUser) {
+      throw new ApiError(400, 'User already exists');
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const newUser = { id: Date.now(), email, password: hashedPassword, name };
+    users.push(newUser);
+
+    res.status(201).json({ 
+      message: 'User registered successfully',
+      user: { id: newUser.id, email: newUser.email, name: newUser.name }
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+export const login = async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+    
+    const user = users.find(u => u.email === email);
+    if (!user) {
+      throw new ApiError(401, 'Invalid credentials');
+    }
+
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) {
+      throw new ApiError(401, 'Invalid credentials');
+    }
+
+    const token = jwt.sign(
+      { id: user.id, email: user.email },
+      process.env.JWT_SECRET || 'secret',
+      { expiresIn: process.env.JWT_EXPIRES_IN || '1d' }
+    );
+
+    res.status(200).json({ 
+      message: 'Login successful',
+      token,
+      user: { id: user.id, email: user.email, name: user.name }
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+<% } else if (auth === 'OAuth' || googleLogin === 'Google Login') { %>
+export const googleCallback = (req, res) => {
+  // Passport handles the authentication, we just redirect or respond
+  res.status(200).json({
+    message: 'Google login successful',
+    user: req.user
+  });
+};
+<% } %>

package/templates/common/src/controllers/authController.ts.ejs

@@ -0,0 +1,101 @@
+import { Request, Response, NextFunction } from 'express';
+<% if (auth === 'Better-Auth') { %>
+import { auth } from '../config/auth';
+
+export const register = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password, name } = req.body;
+    const user = await auth.api.signUpEmail({
+      body: {
+        email,
+        password,
+        name,
+      },
+    });
+    res.status(201).json({ message: 'User registered successfully', user });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const login = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password } = req.body;
+    const session = await auth.api.signInEmail({
+      body: {
+        email,
+        password,
+      },
+    });
+    res.status(200).json({ message: 'Login successful', session });
+  } catch (error: any) {
+    next(error);
+  }
+};
+<% } else if (auth === 'JWT') { %>
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import { ApiError } from '../utils/errorMiddleware';
+
+// Mock User database (In production, use your database models)
+const users: any[] = []; 
+
+export const register = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password, name } = req.body;
+    
+    const existingUser = users.find(u => u.email === email);
+    if (existingUser) {
+      throw new ApiError(400, 'User already exists');
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const newUser = { id: Date.now(), email, password: hashedPassword, name };
+    users.push(newUser);
+
+    res.status(201).json({ 
+      message: 'User registered successfully',
+      user: { id: newUser.id, email: newUser.email, name: newUser.name }
+    });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const login = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password } = req.body;
+    
+    const user = users.find(u => u.email === email);
+    if (!user) {
+      throw new ApiError(401, 'Invalid credentials');
+    }
+
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) {
+      throw new ApiError(401, 'Invalid credentials');
+    }
+
+    const token = jwt.sign(
+      { id: user.id, email: user.email },
+      process.env.JWT_SECRET || 'secret',
+      { expiresIn: process.env.JWT_EXPIRES_IN || '1d' }
+    );
+
+    res.status(200).json({ 
+      message: 'Login successful',
+      token,
+      user: { id: user.id, email: user.email, name: user.name }
+    });
+  } catch (error: any) {
+    next(error);
+  }
+};
+<% } else if (auth === 'OAuth' || googleLogin === 'Google Login') { %>
+export const googleCallback = (req: Request, res: Response) => {
+  res.status(200).json({
+    message: 'Google login successful',
+    user: req.user
+  });
+};
+<% } %>

package/templates/common/src/middleware/auth.js.ejs

@@ -0,0 +1,20 @@
+import jwt from 'jsonwebtoken';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+
+export const authMiddleware = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return next(new ApiError(401, 'No token provided'));
+  }
+
+  const token = authHeader.split(' ')[1];
+
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
+    req.user = decoded;
+    next();
+  } catch (error) {
+    return next(new ApiError(401, 'Invalid or expired token'));
+  }
+};

package/templates/common/src/middleware/auth.ts.ejs

@@ -0,0 +1,25 @@
+import jwt from 'jsonwebtoken';
+import { Request, Response, NextFunction } from 'express';
+import { ApiError } from '../utils/errorMiddleware';
+
+export interface AuthRequest extends Request {
+  user?: any;
+}
+
+export const authMiddleware = (req: AuthRequest, res: Response, next: NextFunction) => {
+  const authHeader = req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return next(new ApiError(401, 'No token provided'));
+  }
+
+  const token = authHeader.split(' ')[1];
+
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
+    req.user = decoded;
+    next();
+  } catch (error) {
+    return next(new ApiError(401, 'Invalid or expired token'));
+  }
+};

package/templates/common/src/middleware/upload.js.ejs

@@ -0,0 +1,31 @@
+import multer from 'multer';
+import path from 'path';
+import { ApiError } from '../utils/errorMiddleware<% if (language === 'TypeScript') { %>.ts<% } %>';
+
+// Storage configuration
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, 'uploads/');
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
+    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
+  }
+});
+
+// File filter (optional)
+const fileFilter = (req, file, cb) => {
+  if (file.mimetype.startsWith('image/')) {
+    cb(null, true);
+  } else {
+    cb(new ApiError(400, 'Only images are allowed'), false);
+  }
+};
+
+export const upload = multer({
+  storage: storage,
+  fileFilter: fileFilter,
+  limits: {
+    fileSize: 5 * 1024 * 1024 // 5MB limit
+  }
+});

package/templates/common/src/middleware/upload.ts.ejs

@@ -0,0 +1,32 @@
+import multer from 'multer';
+import path from 'path';
+import { Request } from 'express';
+import { ApiError } from '../utils/errorMiddleware';
+
+// Storage configuration
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, 'uploads/');
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
+    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
+  }
+});
+
+// File filter
+const fileFilter = (req: Request, file: Express.Multer.File, cb: multer.FileFilterCallback) => {
+  if (file.mimetype.startsWith('image/')) {
+    cb(null, true);
+  } else {
+    cb(new ApiError(400, 'Only images are allowed'));
+  }
+};
+
+export const upload = multer({
+  storage: storage,
+  fileFilter: fileFilter,
+  limits: {
+    fileSize: 5 * 1024 * 1024 // 5MB limit
+  }
+});

package/templates/common/src/routes/authRoutes.js.ejs

@@ -0,0 +1,20 @@
+import express from 'express';
+<% if (auth === 'OAuth' || googleLogin === 'Google Login') { %>import passport from 'passport';<% } %>
+import * as authController from '../controllers/authController<% if (language === 'TypeScript') { %>.ts<% } %>';
+
+const router = express.Router();
+
+<% if (auth === 'Better-Auth' || auth === 'JWT') { %>
+router.post('/register', authController.register);
+router.post('/login', authController.login);
+<% } %>
+
+<% if (auth === 'OAuth' || googleLogin === 'Google Login') { %>
+router.get('/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
+router.get('/google/callback', 
+  passport.authenticate('google', { failureRedirect: '/login' }),
+  authController.googleCallback
+);
+<% } %>
+
+export default router;

package/templates/common/src/routes/authRoutes.ts.ejs

@@ -0,0 +1,20 @@
+import express, { Router } from 'express';
+<% if (auth === 'OAuth' || googleLogin === 'Google Login') { %>import passport from 'passport';<% } %>
+import * as authController from '../controllers/authController';
+
+const router: Router = express.Router();
+
+<% if (auth === 'Better-Auth' || auth === 'JWT') { %>
+router.post('/register', authController.register);
+router.post('/login', authController.login);
+<% } %>
+
+<% if (auth === 'OAuth' || googleLogin === 'Google Login') { %>
+router.get('/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
+router.get('/google/callback', 
+  passport.authenticate('google', { failureRedirect: '/login' }),
+  authController.googleCallback
+);
+<% } %>
+
+export default router;

package/templates/common/src/tests/e2e/e2e.users.test.js.ejs

@@ -0,0 +1,120 @@
+const request = require('supertest');
+
+const SERVER_URL = process.env.TEST_URL || `http://127.0.0.1:${process.env.PORT || 3001}`;
+
+describe('E2E User Tests', () => {
+  // Global setup and teardown hooks can be added here
+  // typically for database seeding or external authentication checks prior to E2E.
+  let userId;
+  const uniqueEmail = `test_${Date.now()}@example.com`;
+
+<%_ if (communication === 'GraphQL') { -%>
+  it('should create a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        createUser(name: "Test User", email: "${uniqueEmail}") {
+          id
+          name
+          email
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    userId = response.body.data.createUser.id;
+    expect(userId).toBeDefined();
+  });
+
+  it('should update a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        updateUser(id: "${userId}", name: "Updated User") {
+          id
+          name
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.updateUser.name).toBe("Updated User");
+  });
+
+  it('should delete a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        deleteUser(id: "${userId}")
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.deleteUser).toBe(true);
+  });
+<%_ } else if (communication === 'Kafka') { -%>
+  it('should trigger Kafka event for user creation', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect([201, 202]).toContain(response.statusCode);
+    userId = response.body.id || response.body._id;
+    expect(userId).toBeDefined();
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user update', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user deletion', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+<%_ } else { -%>
+  it('should create a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect(response.statusCode).toBe(201);
+    userId = response.body.id || response.body._id;
+  });
+
+  it('should update a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('should delete a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect(response.statusCode).toBe(200);
+  });
+<%_ } -%>
+});

package/templates/common/src/tests/e2e/e2e.users.test.ts.ejs

@@ -0,0 +1,120 @@
+import request from 'supertest';
+
+const SERVER_URL = process.env.TEST_URL || `http://127.0.0.1:${process.env.PORT || 3001}`;
+
+describe('E2E User Tests', () => {
+  // Global setup and teardown hooks can be added here
+  // typically for database seeding or external authentication checks prior to E2E.
+  let userId: string;
+  const uniqueEmail = `test_${Date.now()}@example.com`;
+
+<%_ if (communication === 'GraphQL') { -%>
+  it('should create a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        createUser(name: "Test User", email: "${uniqueEmail}") {
+          id
+          name
+          email
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    userId = response.body.data.createUser.id;
+    expect(userId).toBeDefined();
+  });
+
+  it('should update a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        updateUser(id: "${userId}", name: "Updated User") {
+          id
+          name
+        }
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.updateUser.name).toBe("Updated User");
+  });
+
+  it('should delete a user via GraphQL', async () => {
+    const query = `
+      mutation {
+        deleteUser(id: "${userId}")
+      }
+    `;
+    const response = await request(SERVER_URL)
+      .post('/graphql')
+      .send({ query });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.data.deleteUser).toBe(true);
+  });
+<%_ } else if (communication === 'Kafka') { -%>
+  it('should trigger Kafka event for user creation', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect([201, 202]).toContain(response.statusCode);
+    userId = response.body.id || response.body._id;
+    expect(userId).toBeDefined();
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user update', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+
+  it('should trigger Kafka event for user deletion', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect([200, 202, 204]).toContain(response.statusCode);
+
+    // Wait for Kafka to process...
+    await new Promise(resolve => setTimeout(resolve, 500));
+  });
+<%_ } else { -%>
+  it('should create a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .post('/api/users')
+      .send({ name: 'Test User', email: uniqueEmail });
+
+    expect(response.statusCode).toBe(201);
+    userId = response.body.id || response.body._id;
+  });
+
+  it('should update a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .patch(`/api/users/${userId}`)
+      .send({ name: 'Updated User' });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('should delete a user successfully via REST', async () => {
+    const response = await request(SERVER_URL)
+      .delete(`/api/users/${userId}`);
+
+    expect(response.statusCode).toBe(200);
+  });
+<%_ } -%>
+});