nodejs-quickstart-structure 2.0.1 → 2.1.1

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/user.types.ts.ejs

@@ -10,7 +10,7 @@ export const userTypes = `#graphql
   }
 
   type Mutation {
-    createUser(name: String!, email: String!): User
+    createUser(name: String!, email: String!<%_ if (auth.some(a => a !=='None')) { _%>, password: String!<%_ } _%>): User
     updateUser(id: ID!, name: String, email: String): User
     deleteUser(id: ID!): Boolean
   }

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.spec.ts.ejs

@@ -4,12 +4,20 @@ import router from '@/interfaces/routes/userRoutes';
 
 const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
 const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
+const mockGetUserById = jest.fn().mockImplementation((req, res) => res.status(200).json({ id: '1', name: 'Test' }));
+
+<% if (auth.includes('JWT')) { -%>
+jest.mock('@/infrastructure/webserver/middleware/authMiddleware', () => ({
+  authMiddleware: (req: any, res: any, next: any) => next()
+}));
+<% } -%>
 
 jest.mock('@/interfaces/controllers/userController', () => {
   return {
     UserController: jest.fn().mockImplementation(() => ({
       getUsers: (...args: unknown[]) => mockGetUsers(...args),
-      createUser: (...args: unknown[]) => mockCreateUser(...args)
+      createUser: (...args: unknown[]) => mockCreateUser(...args),
+      getUserById: (...args: unknown[]) => mockGetUserById(...args)
     }))
   };
 });

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.ts.ejs

@@ -0,0 +1,16 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { UserController } from '@/interfaces/controllers/userController';
+<%_ if (auth.includes('JWT')) { _%>
+import { authMiddleware } from '@/infrastructure/webserver/middleware/authMiddleware';
+<%_ } _%>
+
+const router = Router();
+const userController = new UserController();
+
+router.post('/', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
+router.get('/', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
+router.get('/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req: Request, res: Response, next: NextFunction) => userController.getUserById(req, res, next));
+router.patch('/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req: Request, res: Response, next: NextFunction) => userController.updateUser(req, res, next));
+router.delete('/:id', <% if (auth.includes('JWT')) { %>authMiddleware, <% } %>(req: Request, res: Response, next: NextFunction) => userController.deleteUser(req, res, next));
+
+export default router;

package/templates/clean-architecture/ts/src/usecases/createUser.spec.ts.ejs

@@ -4,7 +4,15 @@ import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),
@@ -26,11 +34,12 @@ describe('CreateUser UseCase', () => {
     it('should create and save a new user', async () => {
         const name = 'Test User';
         const email = 'test@example.com';
+        const password = 'password123';
         const expectedResult = { id: 1, name, email };
 
         mockUserRepository.save.mockResolvedValue(expectedResult as any);
 
-        const result = await createUser.execute(name, email);
+        const result = await createUser.execute(name, email, password);
 
         expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
         const savedUser = mockUserRepository.save.mock.calls[0][0];
@@ -46,6 +55,6 @@ describe('CreateUser UseCase', () => {
         const error = new Error('Database error');
         mockUserRepository.save.mockRejectedValue(error);
 
-        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+        await expect(createUser.execute('Test', 'test@test.com', 'pwd')).rejects.toThrow(error);
     });
 });

package/templates/clean-architecture/ts/src/usecases/createUser.ts.ejs

@@ -0,0 +1,35 @@
+import { User } from '@/domain/user';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<% if (auth.includes('JWT')) { -%>
+import bcrypt from 'bcryptjs';
+<% } -%>
+<% if (caching !== 'None') { -%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+<% } -%>
+<% if (caching !== 'None') { -%>
+import logger from '@/infrastructure/log/logger';
+<% } -%>
+
+export default class CreateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(name: string, email: string, password?: string) {
+        let finalPassword = password;
+<% if (auth.includes('JWT')) { -%>
+        if (password) {
+            finalPassword = await bcrypt.hash(password, 10);
+        }
+<% } -%>
+        const user = new User(null, name, email, finalPassword);
+        const savedUser = await this.userRepository.save(user);
+<% if (caching !== 'None') { -%>
+        try {
+            await cacheService.del('users:all');
+        } catch (error) {
+            logger.warn('Failed to clear cache after user creation:', error);
+        }
+<% } -%>
+
+        return savedUser;
+    }
+}

package/templates/clean-architecture/ts/src/usecases/deleteUser.spec.ts.ejs

@@ -4,7 +4,15 @@ import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),
@@ -35,6 +43,7 @@ describe('DeleteUser UseCase', () => {
         expect(result).toEqual(expectedResult);
 <%_ if (caching !== 'None') { -%>
         expect(cacheService.del).toHaveBeenCalledWith('users:all');
+        expect(cacheService.del).toHaveBeenCalledWith(`user:${id}`);
 <%_ } %>
     });
 

package/templates/clean-architecture/ts/src/usecases/deleteUser.ts.ejs

@@ -0,0 +1,24 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { _%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+import logger from '@/infrastructure/log/logger';
+<%_ } _%>
+
+export default class DeleteUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string) {
+        const result = await this.userRepository.delete(id);
+        <%_ if (caching !== 'None') { -%>
+        if (result) {
+            try {
+                await cacheService.del('users:all');
+                await cacheService.del(`user:${id}`);
+            } catch (error) {
+                logger.warn('Failed to clear cache after user deletion:', error);
+            }
+        }<%_ } -%>
+        
+        return result;
+    }
+}

package/templates/clean-architecture/ts/src/usecases/getAllUsers.spec.ts.ejs

@@ -4,7 +4,15 @@ import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),

package/templates/clean-architecture/ts/src/usecases/getAllUsers.ts.ejs

@@ -0,0 +1,21 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { _%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+<%_ } _%>
+
+export default class GetAllUsers {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute() {
+        <%_ if (caching !== 'None') { -%>
+        const cachedUsers = await cacheService.get('users:all');
+        if (cachedUsers) return cachedUsers;
+        <%_ } -%>
+        const users = await this.userRepository.getUsers();
+        <%_ if (caching !== 'None') { -%>
+        await cacheService.set('users:all', users, 3600); // Cache for 1 hour
+        <%_ } -%>
+
+        return users;
+    }
+}

package/templates/clean-architecture/ts/src/usecases/getUserById.spec.ts.ejs

@@ -0,0 +1,55 @@
+import GetUserById from '@/usecases/getUserById';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
+
+<% if (caching === 'Redis') { -%>
+jest.mock('@/infrastructure/caching/redisClient', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/infrastructure/caching/memoryCache', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<% } -%>
+
+describe('GetUserById Use Case', () => {
+    let getUserById: GetUserById;
+    let userRepository: jest.Mocked<UserRepository>;
+
+    beforeEach(() => {
+        userRepository = new UserRepository() as jest.Mocked<UserRepository>;
+        getUserById = new GetUserById(userRepository);
+    });
+
+    it('should return a user if found', async () => {
+        const mockUser = { id: '1', name: 'John Doe', email: 'john@example.com' };
+        userRepository.findById.mockResolvedValue(mockUser);
+
+        const result = await getUserById.execute('1');
+
+        expect(result).toEqual(mockUser);
+        expect(userRepository.findById).toHaveBeenCalledWith('1');
+    });
+
+    it('should return null if user is not found', async () => {
+        userRepository.findById.mockResolvedValue(null);
+
+        const result = await getUserById.execute('999');
+
+        expect(result).toBeNull();
+        expect(userRepository.findById).toHaveBeenCalledWith('999');
+    });
+});

package/templates/clean-architecture/ts/src/usecases/getUserById.ts.ejs

@@ -0,0 +1,23 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { _%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+<%_ } _%>
+
+export default class GetUserById {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: string | number) {
+        <%_ if (caching !== 'None') { -%>
+        const cacheKey = `user:${id}`;
+        const cachedUser = await cacheService.get(cacheKey);
+        if (cachedUser) return cachedUser;
+        <%_ } -%>
+        const user = await this.userRepository.findById(id);
+        <%_ if (caching !== 'None') { -%>
+        if (user) {
+            await cacheService.set(`user:${id}`, user, 3600); // Cache for 1 hour
+        }<%_ } -%>
+
+        return user;
+    }
+}

package/templates/clean-architecture/ts/src/usecases/updateUser.spec.ts.ejs

@@ -4,7 +4,15 @@ import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
 <%_ } -%>
 
-jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/infrastructure/repositories/UserRepository', () => ({
+    UserRepository: jest.fn().mockImplementation(() => ({
+        save: jest.fn(),
+        findById: jest.fn(),
+        getUsers: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn()
+    }))
+}));
 <%_ if (caching !== 'None') { -%>
 jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
     get: jest.fn(),
@@ -36,6 +44,7 @@ describe('UpdateUser UseCase', () => {
         expect(result).toEqual(expectedUser);
 <%_ if (caching !== 'None') { -%>
         expect(cacheService.del).toHaveBeenCalledWith('users:all');
+        expect(cacheService.del).toHaveBeenCalledWith(`user:${id}`);
 <%_ } %>
     });
 

package/templates/clean-architecture/ts/src/usecases/updateUser.ts.ejs

@@ -0,0 +1,25 @@
+import { User } from '@/domain/user';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching !== 'None') { _%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+import logger from '@/infrastructure/log/logger';
+<%_ } _%>
+
+export default class UpdateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string, data: Partial<User>) {
+        const user = await this.userRepository.update(id, data);
+        <%_ if (caching !== 'None') { -%>
+        if (user) {
+            try {
+                await cacheService.del('users:all');
+                await cacheService.del(`user:${id}`);
+            } catch (error) {
+                logger.warn('Failed to clear cache after user update:', error);
+            }
+        }<%_ } -%>
+        
+        return user;
+    }
+}

package/templates/clean-architecture/ts/src/utils/errorMessages.ts

@@ -5,6 +5,7 @@ export const ERROR_MESSAGES = {
     INTERNAL_SERVER_ERROR: 'Internal Server Error',
     BAD_REQUEST: 'Bad Request',
     FETCH_USERS_ERROR: 'Error fetching users',
+    FETCH_USER_ERROR: 'Error fetching user',
     CREATE_USER_ERROR: 'Error creating user',
     UPDATE_USER_ERROR: 'Error updating user',
     DELETE_USER_ERROR: 'Error deleting user',

package/templates/clean-architecture/ts/src/utils/httpCodes.ts

@@ -2,6 +2,7 @@ export const HTTP_STATUS = {
     OK: 200,
     CREATED: 201,
     BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
     NOT_FOUND: 404,
     INTERNAL_SERVER_ERROR: 500
 } as const;

package/templates/common/.cursorrules.ejs

@@ -58,3 +58,12 @@ When indexing or searching the workspace, ignore the following paths to prevent
   - `controllers`: Request handlers and business logic.
   - `routes`: Define endpoints routing to controllers.
 <% } -%>
+
+### 5. Security & Authentication
+<% if (auth.includes('JWT')) { -%>
+- **Protected Routes**: When adding new routes, consider if they need `authMiddleware`.
+- **User Identity**: Extract user info from `req.user` (populated by middleware).
+- **Sensitive Data**: Never return passwords in API responses (ensure `.toJSON()` or DTOs handle this).
+<% } -%>
+- **Input Validation**: Always validate user input using schemas or controller-level checks.
+- **Sanitization**: Ensure inputs are sanitized before being used in DB queries (though our ORMs like Sequelize/Mongoose handle much of this).

package/templates/common/.env.example.ejs

@@ -1,8 +1,8 @@
 # Application
 PORT=3000
 NODE_ENV=development
-
 <%_ if (database !== 'None') { -%>
+
 # Database
 <%_ if (database === 'MySQL') { -%>
 DB_HOST=localhost
@@ -10,32 +10,39 @@ DB_PORT=3306
 DB_USER=root
 DB_PASSWORD=root
 DB_NAME=<%= dbName %>
-<%_ } -%>
+<% } -%>
 <%_ if (database === 'PostgreSQL') { -%>
 DB_HOST=localhost
 DB_PORT=5432
 DB_USER=postgres
 DB_PASSWORD=root
 DB_NAME=<%= dbName %>
-<%_ } -%>
+<% } -%>
 <%_ if (database === 'MongoDB') { -%>
 DB_HOST=localhost
 DB_PORT=27017
 DB_NAME=<%= dbName %>
-<%_ } -%>
-<%_ } -%>
-
-
+<% } -%>
+<% } -%>
 <%_ if (communication === 'Kafka') { -%>
+
 # Communication
 KAFKA_BROKER=localhost:9093
 KAFKA_CLIENT_ID=<%= projectName %>
 KAFKA_GROUP_ID=<%= projectName %>-group
-<%_ } -%>
-
+<% } -%>
 <%_ if (caching === 'Redis') { -%>
+
 # Caching
 REDIS_HOST=localhost
 REDIS_PORT=6379
 REDIS_PASSWORD=
-<%_ } -%>
+<% } -%>
+<%_ if (auth.includes('JWT')) { -%>
+
+# Authentication
+JWT_SECRET=your_jwt_secret_key_here_change_it
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_change_it
+JWT_EXPIRES_IN=15m
+JWT_REFRESH_EXPIRES_IN=7d
+<% } -%>

package/templates/common/README.md.ejs

@@ -29,6 +29,7 @@ This project follows a strict **7-Step Production-Ready Process** to ensure qual
 
 -   **Architecture**: <%= architecture %> (<% if (architecture === 'Clean Architecture') { %>Domain, UseCases, Infrastructure<% } else { %>MVC Pattern<% } %>).
 -   **Database**: <%= database %> <% if (database !== 'None') { %>(via <%= database === 'MongoDB' ? 'Mongoose' : 'Sequelize' %>)<% } %>.
+<% if (auth.includes('JWT')) { %>-   **Authentication**: JWT-based Auth (Sign Up, Login, Protected Routes).<% } %>
 -   **Security**: Helmet, CORS, Rate Limiting, HPP, Snyk SCA.
 -   **Quality**: 80%+ Test Coverage, Eslint, Prettier, Husky.
 -   **DevOps**: Multi-stage Docker, CI/CD ready (GitHub/GitLab/Jenkins/Bitbucket/CircleCI).
@@ -95,6 +96,21 @@ Microservices communication handled via **Kafka**.
 API is exposed via **GraphQL**.
 The Apollo Sandbox UI for API exploration and documentation is available natively, fully embedded for offline development:
 - **URL**: `http://localhost:3000/graphql` (Dynamic based on PORT)
+
+<%_ if (auth.includes('JWT')) { _%>
+### 🔐 Authorization
+To access protected resolvers (Query: `getAllUsers`, Mutations: `updateUser`, `deleteUser`), you must provide a valid JWT token in the headers.
+
+**How to authenticate:**
+1. Use the REST login endpoint: `POST /api/auth/login` (with your email and password).
+2. Copy the `accessToken` from the response.
+3. In the Apollo Sandbox "HTTP Headers" tab (bottom section), add:
+```json
+{
+  "Authorization": "Bearer YOUR_ACCESS_TOKEN_HERE"
+}
+```<%_ } _%>
+
 If you are opening `http://localhost:3000/graphql` in your browser, you can directly run the following in the Apollo Sandbox UI:
 
 **Query to get all users:**
@@ -111,7 +127,7 @@ query GetAllUsers {
 **Mutation to create a user:**
 ```graphql
 mutation CreateUser {
-  createUser(name: "John Doe", email: "john@example.com") {
+  createUser(name: "John Doe", email: "john@example.com"<%_ if (auth.includes('JWT')) { _%>, password: "yourpassword123"<%_ } _%>) {
     id
     name
     email
@@ -119,7 +135,7 @@ mutation CreateUser {
 }
 ```
 
-**Mutation to update a user:**
+**Mutation to update a user (Protected):**
 ```graphql
 mutation UpdateUser {
   updateUser(id: "1", name: "John Updated") {
@@ -130,7 +146,7 @@ mutation UpdateUser {
 }
 ```
 
-**Mutation to delete a user:**
+**Mutation to delete a user (Protected):**
 ```graphql
 mutation DeleteUser {
   deleteUser(id: "1")
@@ -143,32 +159,61 @@ A Swagger UI for API documentation is available at:
 
 ### 🛣️ User Endpoints:
 - `GET /api/users`: List all users.
+- `GET /api/users/:id`: Get a user by ID.
 - `POST /api/users`: Create a new user.
 - `PATCH /api/users/:id`: Partially update a user.
 - `DELETE /api/users/:id`: Delete a user (Soft Delete).
-<%_ } -%>
-
+<%_ if (auth.includes('JWT')) { %>
+### 🔐 Auth Endpoints:
+- `POST /api/auth/login`: Exchange credentials for a short-lived `accessToken` and a long-lived `refreshToken`.
+- `POST /api/auth/refresh`: Submit a `refreshToken` to receive a new pair of tokens. (Includes theft-detection logic).
+- `POST /api/auth/logout`: Revoke (blacklist) the active `accessToken` and delete the `refreshToken`.
+- `POST /api/users`: Acts as Sign Up when password is provided.
+  *Note: To access protected user endpoints (GET/PATCH/DELETE), include `Authorization: Bearer <your_accessToken>` in the headers.*
+<% } -%>
+<% } -%>
 <% if (communication === 'Kafka') { -%>
 ## 📡 Testing Kafka Asynchronous Flow
 This project demonstrates a production-ready Kafka flow:
-1. **Producer**: When a user is created via the API, a `USER_CREATED` event is sent to `user-topic`.
-2. **Consumer**: `WelcomeEmailConsumer` listens to `user-topic` and simulates sending an email.
+1. **Producer**: When a user is created, updated, or deleted via the API, a corresponding event (`USER_CREATED`, `USER_UPDATED`, `USER_DELETED`) is sent to `user-topic`.
+2. **Consumer**: `WelcomeEmailConsumer` listens to `user-topic` and simulates processing (e.g., sending an email on creation).
 
 ### How to verify:
 1. Ensure infrastructure is running: `docker-compose up -d<% if (database !== 'None') { %> db<% } %><% if (caching === 'Redis') { %> redis<% } %><% if (communication === 'Kafka') { %> kafka<% } %>`
 2. Start the app: `npm run dev`
-3. Trigger an event by creating a user (via Postman or curl):
-   ```bash
-   curl -X POST http://localhost:3000/api/users \
-     -H "Content-Type: application/json" \
-     -d '{"name": "Kafka Tester", "email": "kafka@example.com"}'
-   ```
+3. Trigger internal events:
+ 
+**Create User (Sign Up - Public):**
+```bash
+curl -X POST http://localhost:3000/api/users \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Kafka Tester", "email": "kafka@example.com"<%_ if (auth.includes('JWT')) { _%>, "password": "password123"<%_ } _%>}'
+```
+
+<%_ if (auth.includes('JWT')) { _%>
+**Update User (Protected - Requires Auth):**
+1. Login to get token: `POST /api/auth/login`
+2. Update user with token:
+```bash
+curl -X PATCH http://localhost:3000/api/users/1 \
+  -H "Authorization: Bearer <YOUR_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Updated Name"}'
+```
+<%_ } else { _%>
+**Update User:**
+```bash
+curl -X PATCH http://localhost:3000/api/users/1 \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Updated Name"}'
+```
+<%_ } _%>
 4. Observe the logs:
-   ```text
-   [Kafka] Producer: Sent USER_CREATED event for 'kafka@example.com'
-   [Kafka] Consumer: Received USER_CREATED. 
-   [Kafka] Consumer: 📧 Sending welcome email to 'kafka@example.com'... Done!
-   ```
+```text
+[Kafka] Producer: Sent USER_CREATED event for 'kafka@example.com'
+[Kafka] Consumer: Received USER_CREATED. 
+[Kafka] Consumer: 📧 Sending welcome email to 'kafka@example.com'... Done!
+```
 
 ### 🛠️ Kafka Troubleshooting
 If the connection or events are failing: