nodejs-quickstart-structure 1.18.0 → 1.19.0

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

package/templates/common/swagger.yml.ejs

@@ -1,66 +1,118 @@
-openapi: 3.0.0
-info:
-  title: <%= projectName %> API
-  version: 1.0.0
-  description: API documentation for <%= projectName %>
-servers:
-  - url: http://localhost:3000
-    description: Local Server
-components:
-  schemas:
-    User:
-      type: object
-      required:
-        - name
-        - email
-      properties:
-        id:
-          type: integer
-          description: The auto-generated id of the user
-        name:
-          type: string
-          description: The name of the user
-        email:
-          type: string
-          description: The email of the user
-      example:
-        id: 1
-        name: John Doe
-        email: john@example.com
-tags:
-  - name: Users
-    description: The users managing API
-paths:
-  /api/users:
-    get:
-      summary: Returns the list of all the users
-      tags:
-        - Users
-      responses:
-        '200':
-          description: The list of the users
-          content:
-            application/json:
-              schema:
-                type: array
-                items:
-                  $ref: '#/components/schemas/User'
-    post:
-      summary: Create a new user
-      tags:
-        - Users
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/User'
-      responses:
-        '201':
-          description: The created user.
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/User'
-        '500':
-          description: Some server error
+openapi: 3.0.0
+info:
+  title: <%= projectName %> API
+  version: 1.0.0
+  description: API documentation for <%= projectName %>
+servers:
+  - url: http://localhost:3000
+    description: Local Server
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - name
+        - email
+      properties:
+        id:
+          type: integer
+          description: The auto-generated id of the user
+        name:
+          type: string
+          description: The name of the user
+        email:
+          type: string
+          description: The email of the user
+      example:
+        id: 1
+        name: John Doe
+        email: john@example.com
+tags:
+  - name: Users
+    description: The users managing API
+paths:
+  /api/users:
+    get:
+      summary: Returns the list of all the users
+      tags:
+        - Users
+      responses:
+        '200':
+          description: The list of the users
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/User'
+    post:
+      summary: Create a new user
+      tags:
+        - Users
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/User'
+      responses:
+        '201':
+          description: The created user.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+        '500':
+          description: Some server error
+  /api/users/{id}:
+    patch:
+      summary: Update an existing user
+      tags:
+        - Users
+      parameters:
+        - in: path
+          name: id
+          schema:
+            type: string
+          required: true
+          description: The user id
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                name:
+                  type: string
+                email:
+                  type: string
+      responses:
+        '200':
+          description: The updated user
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+        '404':
+          description: User not found
+        '500':
+          description: Some server error
+    delete:
+      summary: Delete an existing user
+      tags:
+        - Users
+      parameters:
+        - in: path
+          name: id
+          schema:
+            type: string
+          required: true
+          description: The user id
+      responses:
+        '200':
+          description: User deleted successfully
+        '404':
+          description: User not found
+        '500':
+          description: Some server error

package/templates/db/mysql/V1__Initial_Setup.sql.ejs

@@ -1,9 +1,10 @@
-CREATE TABLE users (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    name VARCHAR(255) NOT NULL,
-    email VARCHAR(255) NOT NULL UNIQUE,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-);
-
-INSERT INTO users (name, email) VALUES ('Admin User', 'admin@example.com');
+CREATE TABLE users (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    email VARCHAR(255) NOT NULL UNIQUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP NULL
+);
+
+INSERT INTO users (name, email) VALUES ('Admin User', 'admin@example.com');