nodejs-quickstart-structure 2.0.0 → 2.1.0

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);
+    });
 <%_ } -%>
 });

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

@@ -3,16 +3,37 @@ 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;
+<%_ if (auth.includes('JWT')) { _%>
+  let authToken: string;
+<%_ } _%>
   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 });
+    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}") {
+        createUser(name: "Test User", email: "${uniqueEmail}"<%_ if (auth.includes('JWT')) { _%>, password: "${testPassword}"<%_ } _%>) {
           id
           name
           email
@@ -24,9 +45,48 @@ describe('E2E User Tests', () => {
       .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 (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;
+  });
+<%_ } -%>
+
+<%_ 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 });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.accessToken || response.body.token).toBeDefined();
+    authToken = response.body.accessToken || response.body.token;
+  });
+<%_ } _%>
+
+<%_ 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: any) => u.id === userId);
+    expect(user).toBeDefined();
+  });
 
   it('should update a user via GraphQL', async () => {
     const query = `
@@ -39,6 +99,10 @@ describe('E2E User Tests', () => {
     `;
     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);
@@ -53,68 +117,45 @@ describe('E2E User Tests', () => {
     `;
     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 if (communication === 'Kafka') { -%>
-  it('should trigger Kafka event for user creation', async () => {
+<%_ } else { -%>
+  it('should fetch users successfully', 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));
+      .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 trigger Kafka event for user update', async () => {
+  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);
-
-    // Wait for Kafka to process...
-    await new Promise(resolve => setTimeout(resolve, 500));
   });
 
-  it('should trigger Kafka event for user deletion', async () => {
+  it('should delete a user successfully', async () => {
     const response = await request(SERVER_URL)
-      .delete(`/api/users/${userId}`);
+      .delete(`/api/users/${userId}`)
+      <%_ if (auth.includes('JWT')) { _%>
+      .set('Authorization', `Bearer ${authToken}`)
+      <%_ } _%>;
 
     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/swagger.yml.ejs

@@ -7,12 +7,20 @@ servers:
   - url: http://localhost:3000
     description: Local Server
 components:
+<%_ if (auth.includes('JWT')) { -%>
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT
+<%_ } -%>
   schemas:
     User:
       type: object
       required:
         - name
         - email
+        <% if (auth.includes('JWT')) { %>- password<% } %>
       properties:
         id:
           type: integer
@@ -23,6 +31,12 @@ components:
         email:
           type: string
           description: The email of the user
+        <% if (auth.includes('JWT')) { %>
+        password:
+          type: string
+          writeOnly: true
+          description: The password of the user
+        <% } %>
       example:
         id: 1
         name: John Doe
@@ -30,7 +44,103 @@ components:
 tags:
   - name: Users
     description: The users managing API
+  <%_ if (auth.includes('JWT')) { -%>
+  - name: Auth
+    description: Authentication API
+  <%_ } -%>
 paths:
+<%_ if (auth.includes('JWT')) { -%>
+  /api/auth/login:
+    post:
+      summary: Login and receive a JWT token
+      tags:
+        - Auth
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - email
+                - password
+              properties:
+                email:
+                  type: string
+                password:
+                  type: string
+      responses:
+        '200':
+          description: Login successful
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  token:
+                    type: string
+                  accessToken:
+                    type: string
+                  refreshToken:
+                    type: string
+        '401':
+          description: Invalid credentials
+  /api/auth/refresh:
+    post:
+      summary: Refresh access token using a refresh token
+      tags:
+        - Auth
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - refreshToken
+              properties:
+                refreshToken:
+                  type: string
+      responses:
+        '200':
+          description: Token refreshed successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  accessToken:
+                    type: string
+                  refreshToken:
+                    type: string
+        '401':
+          description: Invalid refresh token
+  /api/auth/logout:
+    post:
+      summary: Logout and revoke refresh token
+      tags:
+        - Auth
+      security:
+        - bearerAuth: []
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                refreshToken:
+                  type: string
+      responses:
+        '200':
+          description: Logged out successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+<%_ } -%>
   /api/users:
     get:
       summary: Returns the list of all the users
@@ -45,6 +155,10 @@ paths:
                 type: array
                 items:
                   $ref: '#/components/schemas/User'
+      <%_ if (auth.includes('JWT')) { -%>
+      security:
+        - bearerAuth: []
+      <%_ } -%>
     post:
       summary: Create a new user
       tags:
@@ -65,6 +179,32 @@ paths:
         '500':
           description: Some server error
   /api/users/{id}:
+    get:
+      summary: Get a user by ID
+      tags:
+        - Users
+      parameters:
+        - in: path
+          name: id
+          schema:
+            type: string
+          required: true
+          description: The user id
+      responses:
+        '200':
+          description: The user details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+        '404':
+          description: User not found
+        '500':
+          description: Some server error
+      <%_ if (auth.includes('JWT')) { -%>
+      security:
+        - bearerAuth: []
+      <%_ } -%>
     patch:
       summary: Update an existing user
       tags:
@@ -98,6 +238,10 @@ paths:
           description: User not found
         '500':
           description: Some server error
+      <%_ if (auth.includes('JWT')) { -%>
+      security:
+        - bearerAuth: []
+      <%_ } -%>
     delete:
       summary: Delete an existing user
       tags:
@@ -116,3 +260,7 @@ paths:
           description: User not found
         '500':
           description: Some server error
+      <%_ if (auth.includes('JWT')) { -%>
+      security:
+        - bearerAuth: []
+      <%_ } -%>

package/templates/common/tsconfig.eslint.json

@@ -0,0 +1,15 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "noEmit": true,
+        "allowJs": true
+    },
+    "include": [
+        "src/**/*",
+        "tests/**/*",
+        "migrations/**/*.js",
+        "*.js",
+        "*.mjs",
+        "scripts/**/*.js"
+    ]
+}

package/templates/common/tsconfig.json

@@ -10,7 +10,8 @@
         "forceConsistentCasingInFileNames": true,
         "baseUrl": ".",
         "paths": {
-            "@/*": ["src/*"]
+            "@/*": ["src/*"],
+            "@tests/*": ["tests/*"]
         }
     },
     "include": [