nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/common/shutdown/ts/gracefulShutdown.ts.ejs

@@ -1,55 +1,59 @@
-import { Server } from 'http';
-<%_ if (architecture === 'MVC') { -%>
-import logger from '@/utils/logger';
-<%_ } else { -%>
-import logger from '@/infrastructure/log/logger';
-<%_ } -%>
-<%_ if (database === 'MongoDB') { -%>
-import mongoose from 'mongoose';
-<%_ } else if (database !== 'None') { -%>
-import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-import redisService from '<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>';
-<%_ } -%>
-
-export const setupGracefulShutdown = (server: Server<% if (communication === 'Kafka') { %>, kafkaService: { disconnect: () => Promise<void> }<% } %>) => {
-    const gracefulShutdown = async (signal: string) => {
-        logger.info(`Received ${signal}. Shutting down gracefully...`);
-        server.close(async () => {
-            logger.info('HTTP server closed.');
-            try {
-<%_ if (database !== 'None') { -%>
-<%_ if (database === 'MongoDB') { -%>
-                await mongoose.connection.close(false);
-                logger.info('MongoDB connection closed.');
-<%_ } else { -%>
-                await sequelize.close();
-                logger.info('Database connection closed.');
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-                await redisService.quit();
-                logger.info('Redis connection closed.');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-                await kafkaService.disconnect();
-                logger.info('Kafka connection closed.');
-<%_ } -%>
-                logger.info('Graceful shutdown fully completed.');
-                process.exit(0);
-            } catch (err) {
-                logger.error('Error during shutdown:', err);
-                process.exit(1);
-            }
-        });
-
-        setTimeout(() => {
-            logger.error('Could not close connections in time, forcefully shutting down');
-            process.exit(1);
-        }, 15000);
-    };
-
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-};
+import { Server } from 'http';
+<%_ if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<%_ } else { -%>
+import logger from '@/infrastructure/log/logger';
+<%_ } -%>
+<%_ if (database === 'MongoDB') { -%>
+import mongoose from 'mongoose';
+<%_ } else if (database !== 'None') { -%>
+import sequelize from '<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>';
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+import redisService from '<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>';
+<%_ } -%>
+
+export const setupGracefulShutdown = (server: Server<% if (communication === 'Kafka') { %>, kafkaService: { disconnect: () => Promise<void> }<% } %>) => {
+    const gracefulShutdown = async (signal: string) => {
+        logger.info(`Received ${signal}. Shutting down gracefully...`);
+        server.close(async (err: Error | undefined) => {
+            if (err) {
+                logger.error('Error closing HTTP server:', err);
+                process.exit(1);
+            }
+            logger.info('HTTP server closed.');
+            try {
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+                await mongoose.connection.close(false);
+                logger.info('MongoDB connection closed.');
+<%_ } else { -%>
+                await sequelize.close();
+                logger.info('Database connection closed.');
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+                await redisService.quit();
+                logger.info('Redis connection closed.');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+                await kafkaService.disconnect();
+                logger.info('Kafka connection closed.');
+<%_ } -%>
+                logger.info('Graceful shutdown fully completed.');
+                process.exit(0);
+            } catch (err) {
+                logger.error('Error during shutdown:', err);
+                process.exit(1);
+            }
+        });
+
+        setTimeout(() => {
+            logger.error('Could not close connections in time, forcefully shutting down');
+            process.exit(1);
+        }, 15000);
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+};

package/templates/common/sonar-project.properties.ejs

@@ -1,27 +1,27 @@
-# SonarCloud/SonarQube Project Configuration
-# See https://docs.sonarqube.org/latest/analysis/analysis-parameters/
-
-sonar.projectKey=your-org-key_<%= projectName %>
-sonar.projectName=<%= projectName %>
-sonar.organization=your-org-key
-sonar.projectVersion=1.0.0
-
-# Path to the source directories
-sonar.sources=src
-# Path to the test directories
-sonar.tests=tests
-
-# Language specific settings
-sonar.javascript.environments=node
-sonar.typescript.tsconfigPath=tsconfig.json
-sonar.javascript.lcov.reportPaths=coverage/lcov.info
-
-# Exclusions
-sonar.exclusions=node_modules/**, dist/**, coverage/**, tests/**
-
-# Quality Gates
-sonar.qualitygate.wait=true
-sonar.qualitygate.timeout=300
-
-# Security Hotspots
-sonar.security.reportPaths=snyk-report.json
+# SonarCloud/SonarQube Project Configuration
+# See https://docs.sonarqube.org/latest/analysis/analysis-parameters/
+
+sonar.projectKey=your-org-key_<%= projectName %>
+sonar.projectName=<%= projectName %>
+sonar.organization=your-org-key
+sonar.projectVersion=1.0.0
+
+# Path to the source directories
+sonar.sources=src
+# Path to the test directories
+sonar.tests=tests
+
+# Language specific settings
+sonar.javascript.environments=node
+sonar.typescript.tsconfigPath=tsconfig.json
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+
+# Exclusions
+sonar.exclusions=node_modules/**, dist/**, coverage/**, tests/**
+
+# Quality Gates
+sonar.qualitygate.wait=true
+sonar.qualitygate.timeout=300
+
+# Security Hotspots
+sonar.security.reportPaths=snyk-report.json

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

@@ -1,49 +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.
-  const uniqueEmail = `test_${Date.now()}@example.com`;
-
-<%_ if (communication === 'GraphQL') { _%>
-  it('should create a user and verify flow 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);
-  });
-<%_ } 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 });
-
-    // Assuming the API returns 201 or 404 (if no REST endpoint is exposed in Kafka skeleton)
-    expect([201, 202, 404]).toContain(response.statusCode);
-    
-    // Wait for Kafka to process...
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  });
-<%_ } 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 });
-
-    // E2E Tests must have strict and deterministic assertions
-    expect(response.statusCode).toBe(201);
-  });
-<%_ } _%>
-});
+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

@@ -1,49 +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.
-  const uniqueEmail = `test_${Date.now()}@example.com`;
-
-<%_ if (communication === 'GraphQL') { _%>
-  it('should create a user and verify flow 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);
-  });
-<%_ } 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 });
-
-    // Assuming the API returns 201 or 404 (if no REST endpoint is exposed in Kafka skeleton)
-    expect([201, 202, 404]).toContain(response.statusCode);
-    
-    // Wait for Kafka to process...
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  });
-<%_ } 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 });
-
-    // E2E Tests must have strict and deterministic assertions
-    expect(response.statusCode).toBe(201);
-  });
-<%_ } _%>
-});
+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);
+  });
+<%_ } -%>
+});