nodejs-quickstart-structure 2.0.1 → 2.1.0

package/templates/common/database/ts/models/User.ts.ejs

@@ -3,6 +3,9 @@ export interface User {
   id: string;
   name: string;
   email: string;
+<% if (auth.includes('JWT')) { -%>
+  password?: string;
+<% } -%>
 }
 
 export default class UserModel {
@@ -12,6 +15,12 @@ export default class UserModel {
     return this.mockData;
   }
 
+  static async findOne(query: Partial<User>) {
+    return this.mockData.find((u) => {
+      return Object.entries(query).every(([key, value]) => (u as unknown as Record<string, unknown>)[key] === value);
+    });
+  }
+
   static async findAll() {
     return this.mockData;
   }
@@ -52,6 +61,7 @@ class User extends Model {
   public id!: number;
   public name!: string;
   public email!: string;
+  <% if (auth.includes('JWT')) { %>public password!: string;<% } %>
 }
 
 User.init(
@@ -70,6 +80,12 @@ User.init(
       allowNull: false,
       unique: true,
     },
+    <% if (auth.includes('JWT')) { %>
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    <% } %>
     deletedAt: {
       type: DataTypes.DATE,
       allowNull: true,
@@ -83,5 +99,6 @@ User.init(
   }
 );
 
+
 export default User;
 <% } -%>

package/templates/common/database/ts/models/User.ts.mongoose.ejs

@@ -3,6 +3,7 @@ import mongoose, { Schema, Document } from 'mongoose';
 export interface IUser extends Document {
     name: string;
     email: string;
+    <% if (auth.includes('JWT')) { %>password: string;<% } %>
     createdAt: Date;
     deletedAt?: Date | null;
 }
@@ -17,6 +18,12 @@ const UserSchema: Schema = new Schema({
         required: true,
         unique: true
     },
+    <% if (auth.includes('JWT')) { %>
+    password: {
+        type: String,
+        required: true
+    },
+    <% } %>
     createdAt: {
         type: Date,
         default: Date.now
@@ -27,4 +34,5 @@ const UserSchema: Schema = new Schema({
     }
 });
 
+
 export default mongoose.model<IUser>('User', UserSchema);

package/templates/common/docker-compose.yml.ejs

@@ -39,6 +39,12 @@ services:
       - DB_PORT=27017
 <%_ } -%>
 <%_ } -%>
+<%_ if (auth.includes('JWT')) { -%>
+      - JWT_SECRET=your_jwt_secret_key_here_change_it
+      - JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_change_it
+      - JWT_EXPIRES_IN=1d
+      - JWT_REFRESH_EXPIRES_IN=7d
+<%_ } -%>
 <%_ } else { -%>
     environment:
       - PORT=3000
@@ -64,6 +70,12 @@ services:
       - DB_PORT=27017
 <%_ } -%>
 <%_ } -%>
+<%_ if (auth.includes('JWT')) { -%>
+      - JWT_SECRET=your_jwt_secret_key_here_change_it
+      - JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_change_it
+      - JWT_EXPIRES_IN=1d
+      - JWT_REFRESH_EXPIRES_IN=7d
+<%_ } -%>
 <%_ } -%>
 <%_ if (database !== 'None') { -%>
   db:

package/templates/common/ecosystem.config.js.ejs

@@ -24,16 +24,22 @@ module.exports = {
       DB_USER: "root",
       DB_PASSWORD: "root",
       DB_NAME: "<%= dbName %>",
-      DB_PORT: 3306
+      DB_PORT: 3306,
 <%_ } else if (database === 'PostgreSQL') { -%>
       DB_USER: "postgres",
       DB_PASSWORD: "root",
       DB_NAME: "<%= dbName %>",
-      DB_PORT: 5432
+      DB_PORT: 5432,
 <%_ } else if (database === 'MongoDB') { -%>
       DB_NAME: "<%= dbName %>",
-      DB_PORT: 27017
+      DB_PORT: 27017,
 <%_ } -%>
+<%_ } -%>
+<%_ if (auth.includes('JWT')) { -%>
+      JWT_SECRET: "your_jwt_secret_here",
+      JWT_REFRESH_SECRET: "your_jwt_refresh_secret_here",
+      JWT_EXPIRES_IN: "1h",
+      JWT_REFRESH_EXPIRES_IN: "7d",
 <%_ } -%>
     }
   }]

package/templates/common/eslint.config.mjs.ejs

@@ -19,6 +19,9 @@ export default tseslint.config(
       },
     },
     languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.json', './tsconfig.eslint.json'],
+      },
       globals: {
         ...globals.node,
         ...globals.jest,

package/templates/common/jest.config.js.ejs

@@ -11,15 +11,17 @@ module.exports = {
   coveragePathIgnorePatterns: [
     "/node_modules/",
     "/dist/",
-    "src/index",
-    "src/app",
-    "src/config/env",
-    "src/infrastructure/config/env",
-    "src/config/swagger",
-    "src/infrastructure/webserver/swagger",
-    "src/infrastructure/webserver/server",
-    "src/utils/logger",
-    "src/infrastructure/log/logger"
+    "src/index.(js|ts)",
+    "src/app.(js|ts)",
+    "src/config",
+    "src/infrastructure/config",
+    "src/routes",
+    "src/infrastructure/routes",
+    "src/interfaces/routes",
+    "src/graphql",
+    "src/interfaces/graphql",
+    "src/utils",
+    "src/models"
   ],
   coverageThreshold: {
     global: {

package/templates/common/kafka/js/messaging/baseConsumer.js.ejs

@@ -22,7 +22,7 @@ class BaseConsumer {
     }
   }
 
-  async handle(data) {
+  async handle(_data) {
     throw new Error("Method 'handle()' must be implemented");
   }
 }

package/templates/common/kafka/js/services/kafkaService.js.ejs

@@ -34,7 +34,7 @@ const connectKafka = async (retries = 10) => {
                     await consumer.run({
                         eachMessage: async (payload) => welcomeConsumer.onMessage(payload),
                     });
-                } catch (error) {
+                } catch {
                     // Fallback or no consumers found
                     await consumer.subscribe({ topic: 'user-topic', fromBeginning: true });
                     await consumer.run({

package/templates/common/migrations/init.js.ejs

@@ -1,5 +1,5 @@
 module.exports = {
-  async up(db, client) {
+  async up(db, _client) {
     const adminEmail = 'admin@example.com';
     const existingAdmin = await db.collection('users').findOne({ email: adminEmail });
 
@@ -7,16 +7,17 @@ module.exports = {
       await db.collection('users').insertOne({
         name: 'Admin User',
         email: adminEmail,
+        <% if (auth.includes('JWT')) { %>password: '$2a$10$X.fO9PeyF0Lq0lF8uV6G9u4Vb4e5T0rF8l/JzM6S7X9u4Vb4e5T0r', // password: password123<% } %>
         createdAt: new Date(),
         updatedAt: new Date()
       });
-      console.log('Admin User seeded successfully');
+      console.log('Admin User seeded successfully'); // eslint-disable-line no-console
     } else {
-      console.log('Admin User already exists, skipping seed');
+      console.log('Admin User already exists, skipping seed'); // eslint-disable-line no-console
     }
   },
 
-  async down(db, client) {
+  async down(_db, _client) {
     // Optional: Undo the seed. Usually for seeds we might want to keep data, but strictly speaking 'down' should reverse 'up'.
     // await db.collection('users').deleteOne({ email: 'admin@example.com' });
   }

package/templates/common/package.json.ejs

@@ -53,8 +53,12 @@
 <% if (viewEngine === 'EJS') { %>    "ejs": "^3.1.10",
 <% } -%>
 <% if (viewEngine === 'Pug') { %>    "pug": "^3.0.2",
+<% } -%>
+<% if (auth.includes('JWT')) { %>    "jsonwebtoken": "^9.0.2",
+    "bcryptjs": "^2.4.3",
 <% } -%>
     "cors": "^2.8.5",
+
     "helmet": "^7.1.0",
     "hpp": "^0.2.3",
     "express-rate-limit": "^7.1.5",
@@ -85,7 +89,10 @@
 <% } -%>
     "@types/morgan": "^1.9.9",
     "rimraf": "^6.0.1"<% if ((viewEngine && viewEngine !== 'None') || communication === 'REST APIs' || communication === 'Kafka') { %>,
-    "cpx2": "^8.0.0"<% } %><% } %>,
+    "cpx2": "^8.0.0"<% } %><% if (auth.includes('JWT')) { %>,
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/bcryptjs": "^2.4.6"<% } %><% } %>,
+
     "eslint": "^10.1.0",
     "@eslint/js": "^9.20.0",
     "globals": "^15.14.0",

package/templates/common/prompts/project-context.md.ejs

@@ -16,6 +16,9 @@ You are an expert working on **<%= projectName %>**.
 <% if (caching !== 'None') { -%>
 - **Caching**: <%= caching %>
 <% } -%>
+<% if (auth.includes('JWT')) { -%>
+- **Authentication**: JWT (Access & Refresh Tokens)
+<% } -%>
 
 ## High-Level Architecture
 <% if (architecture === 'Clean Architecture') { -%>
@@ -34,7 +37,11 @@ We use the MVC (Model-View-Controller) pattern.
 ## Core Standards
 1. **Testing**: We enforce > 80% coverage. Tests use Jest and the AAA (Arrange, Act, Assert) pattern.
 2. **Error Handling**: We use centralized custom errors (e.g., `ApiError`) and global error middleware. Status codes come from standard constants, not hardcoded numbers.
-3. **Paths & Naming**:
+3. **Security**: 
+   <% if (auth.includes('JWT')) { %>- Use `authMiddleware` for protected routes.<% } %>
+   - Validate and sanitize all inputs to prevent injection and XSS.
+   - Never expose sensitive data (passwords, inner keys) in API responses.
+4. **Paths & Naming**:
 <% if (language === 'TypeScript') { -%>
    - We use `@/` path aliases for internal imports.
 <% } -%>

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

@@ -3,118 +3,160 @@ 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`;
+    let userId;
+<%_ if (auth.includes('JWT')) { _%>
+    let authToken;
+<%_ } _%>
+    const uniqueEmail = `test_${Date.now()}@example.com`;
+<%_ if (auth.includes('JWT')) { _%>
+    const testPassword = 'password123';
+<%_ } _%>
+
+<%_ if (auth.includes('JWT')) { _%>
+    it('should fail to fetch users without token (Protected)', async () => {
+<%_ if (communication === 'GraphQL') { _%>
+        const query = `{ getAllUsers { id name } }`;
+        const response = await request(SERVER_URL).post('/graphql').send({ query });
+        // In GraphQL errors are usually in the body with 200/400 status
+        if (response.statusCode === 200 && response.body.errors) {
+          expect(response.body.errors[0].message.toLowerCase()).toContain('unauthorized');
+        } else {
+          expect([401, 400]).toContain(response.statusCode);
+        }
+<%_ } else { _%>
+        const response = await request(SERVER_URL).get('/api/users');
+        expect(response.statusCode).toBe(401);
+<%_ } _%>
+    });
+<%_ } _%>
 
 <%_ 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));
-  });
+    it('should create a user via GraphQL', async () => {
+        const query = `
+            mutation {
+                createUser(name: "Test User", email: "${uniqueEmail}"<%_ if (auth.includes('JWT')) { _%>, password: "${testPassword}"<%_ } _%>) {
+                    id
+                    name
+                    email
+                }
+            }
+        `;
+        const response = await request(SERVER_URL)
+            .post('/graphql')
+            .send({ query });
+
+        expect(response.statusCode).toBe(200);
+        expect(response.body.errors).toBeUndefined();
+        userId = response.body.data.createUser.id;
+        expect(userId).toBeDefined();
+    });
 <%_ } 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' });
+    it('should create a user successfully (Signup)', async () => {
+        const response = await request(SERVER_URL)
+            .post('/api/users')
+            .send({ name: 'Test User', email: uniqueEmail<%_ if (auth.includes('JWT')) { _%>, password: testPassword <%_ } _%>});
+
+        expect([201, 202]).toContain(response.statusCode);
+        userId = response.body.id || response.body._id;
+    });
+<%_ } -%>
 
-    expect(response.statusCode).toBe(200);
-  });
+<%_ if (auth.includes('JWT')) { _%>
+    it('should login and obtain a JWT token', async () => {
+        const response = await request(SERVER_URL)
+            .post('/api/auth/login')
+            .send({ email: uniqueEmail, password: testPassword });
 
-  it('should delete a user successfully via REST', async () => {
-    const response = await request(SERVER_URL)
-      .delete(`/api/users/${userId}`);
+        expect(response.statusCode).toBe(200);
+        expect(response.body.accessToken || response.body.token).toBeDefined();
+        authToken = response.body.accessToken || response.body.token;
+    });
+<%_ } _%>
 
-    expect(response.statusCode).toBe(200);
-  });
+<%_ if (communication === 'GraphQL') { -%>
+    it('should fetch all users via GraphQL', async () => {
+        const query = `{ getAllUsers { id name email } }`;
+        const response = await request(SERVER_URL)
+            .post('/graphql')
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`)
+            <%_ } _%>
+            .send({ query });
+
+        expect(response.statusCode).toBe(200);
+        expect(Array.isArray(response.body.data.getAllUsers)).toBe(true);
+        const user = response.body.data.getAllUsers.find(u => u.id === userId);
+        expect(user).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')
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`)
+            <%_ } _%>
+            .set('Content-Type', 'application/json')
+            .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')
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`)
+            <%_ } _%>
+            .set('Content-Type', 'application/json')
+            .send({ query });
+
+        expect(response.statusCode).toBe(200);
+        expect(response.body.data.deleteUser).toBe(true);
+    });
+<%_ } else { -%>
+    it('should fetch users successfully', async () => {
+        const response = await request(SERVER_URL)
+            .get('/api/users')
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`);
+            <%_ } _%>
+        expect(response.statusCode).toBe(200);
+        expect(Array.isArray(response.body)).toBe(true);
+    });
+
+    it('should update a user successfully', async () => {
+        const response = await request(SERVER_URL)
+            .patch(`/api/users/${userId}`)
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`)
+            <%_ } _%>
+            .send({ name: 'Updated User' });
+
+        expect([200, 202, 204]).toContain(response.statusCode);
+    });
+
+    it('should delete a user successfully', async () => {
+        const response = await request(SERVER_URL)
+            .delete(`/api/users/${userId}`)
+            <%_ if (auth.includes('JWT')) { _%>
+            .set('Authorization', `Bearer ${authToken}`)
+            <%_ } _%>;
+
+        expect([200, 202, 204]).toContain(response.statusCode);
+    });
 <%_ } -%>
 });