nodejs-quickstart-structure 1.13.0 → 1.15.1

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

@@ -17,7 +17,7 @@ export class KafkaService {
         await this.consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
 
         await this.consumer.run({
-            eachMessage: async ({ topic, partition, message }: EachMessagePayload) => {
+            eachMessage: async ({ message }: EachMessagePayload) => {
                 logger.info({
                     value: message.value?.toString(),
                 });

package/templates/common/package.json.ejs

@@ -94,9 +94,6 @@
     "jest": "^29.7.0",
     "supertest": "6.3.3"<% } %>
   },
-  "overrides": {
-    "minimatch": "^10.2.1"
-  },
   "lint-staged": {
     "*.{js,ts}": [
       "eslint --fix",

package/templates/common/prompts/add-feature.md.ejs

@@ -0,0 +1,26 @@
+# Add New Feature
+
+I want to add a new feature to the existing application. 
+Please follow the strict standards defined in the project context.
+
+## Feature Description
+[INSERT EXPLANATION OF WHAT YOU WANT TO ADD HERE]
+
+## Implementation Guidelines
+
+Please provide the code implementation following these steps:
+
+1. **Plan first**: Outline the files you need to create/modify and the logic they'll contain.
+<% if (architecture === 'Clean Architecture') { -%>
+2. **Domain/Entity**: Define the core entity structure or interfaces if applicable.
+3. **Use Case**: Implement the business logic handling the feature.
+4. **Adapter (Controller & Route)**: Create the necessary endpoints and validate input.
+5. **Infrastructure (Repository)**: Implement database queries or external service calls.
+<% } else { -%>
+2. **Model**: Define the database schema/model if applicable.
+3. **Controller**: Implement the business logic and request handling.
+4. **Route**: Create the API endpoints and wire them to the controller.
+<% } -%>
+6. **Testing**: Write comprehensive Jest unit tests covering the "Happy Path" and "Edge Cases/Errors" (AAA pattern). Remember, our coverage requirement is > 70%!
+
+Please provide the plan first so I can review it before we write the code.

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

@@ -0,0 +1,43 @@
+# Project Context
+
+Hello AI! I am working on a Node.js project. Here is the context to help you understand the architecture, domain, and standards.
+
+## Domain Overview
+**Project Name**: <%= projectName %>
+You are an expert working on **<%= projectName %>**.
+**Project Goal**: [Replace this with your business logic, e.g., E-commerce API]
+*(Keep this goal in mind when writing business logic, proposing data schemas, or considering edge cases like security and performance.)*
+
+## Tech Stack
+- **Language**: <%= language %>
+- **Architecture**: <%= architecture %>
+- **Database**: <%= database %>
+- **Communication Protocol**: <%= communication %>
+<% if (caching !== 'None') { -%>
+- **Caching**: <%= caching %>
+<% } -%>
+
+## High-Level Architecture
+<% if (architecture === 'Clean Architecture') { -%>
+We use Clean Architecture. The project separates concerns into:
+- `src/domain`: Core entities and rules. No external dependencies.
+- `src/usecases`: Application business logic.
+- `src/interfaces`: Adapters (Controllers, Routes) that mediate between the outside world and use cases.
+- `src/infrastructure`: External tools (Database, Web Server, Config, Caching).
+<% } else { -%>
+We use the MVC (Model-View-Controller) pattern.
+- `src/models`: Database schemas/models.
+- `src/controllers`: Handling incoming requests and implementing business logic.
+- `src/routes`: API endpoints mapped to controllers.
+<% } -%>
+
+## Core Standards
+1. **Testing**: We enforce > 70% 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**:
+<% if (language === 'TypeScript') { -%>
+   - We use `@/` path aliases for internal imports.
+<% } -%>
+   - Files are mostly `camelCase`.
+
+Please acknowledge you understand this context by saying "Context loaded successfully! How can I help you build the <%= projectName %>?"

package/templates/common/prompts/troubleshoot.md.ejs

@@ -0,0 +1,28 @@
+# Troubleshoot Error
+
+I am encountering an error in the <%= projectName %> application. Please help me diagnose and fix it based on our architectural standards.
+
+## The Error Log / Issue Description
+\`\`\`
+[PASTE YOUR ERROR LOG OR DESCRIBE THE ISSUE HERE]
+\`\`\`
+
+## Context Variables
+- **Architecture**: <%= architecture %>
+- **Language**: <%= language %>
+
+## Guidelines for Fixing
+
+When analyzing this error, please keep these project standards in mind:
+
+1. **Centralized Error Handling**: 
+   - Ensure the error uses the standard custom error classes from `src/errors/` (e.g., `ApiError`, `NotFoundError`, `BadRequestError`).
+   - If an error occurs in a controller, it should be passed to the global error middleware via `throw` (for async handlers, or `next(error)` in MVC).
+2. **Standard Status Codes**:
+   - Verify that appropriate status codes from `httpCodes` are being used correctly, rather than generic 500s unless unexpected.
+3. **Dependencies**:
+   - Check if this is a connection issue (e.g., Database, Kafka, Redis) and see if our standard configuration or health checks provide hints.
+4. **Fix Suggestion**:
+   - Explain *why* the error happened.
+   - Provide a targeted code fix matching our coding style (<%= language %>, <%= architecture %>).
+   - Only modify what is strictly necessary to solve the issue.

package/templates/common/shutdown/js/gracefulShutdown.spec.js.ejs

@@ -0,0 +1,160 @@
+<%_ 
+let loggerPath = '@/utils/logger';
+let dbPath = '@/config/database';
+let redisPath = '@/config/redisClient';
+let kafkaPath = '@/services/kafkaService';
+
+if (architecture === 'Clean Architecture') {
+    loggerPath = '@/infrastructure/log/logger';
+    dbPath = '@/infrastructure/database/database';
+    redisPath = '@/infrastructure/caching/redisClient';
+    kafkaPath = '@/infrastructure/messaging/kafkaClient';
+}
+_%>
+const setupGracefulShutdown = require('@/utils/gracefulShutdown');
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        connection: {
+            close: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<%- dbPath %>', () => {
+    return {
+        close: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+<%_ if (caching === 'Redis') { -%>
+jest.mock('<%- redisPath %>', () => {
+    return {
+        quit: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('<%- kafkaPath %>', () => {
+    return {
+        disconnectKafka: jest.fn().mockResolvedValue(true)
+    };
+});
+<%_ } -%>
+
+const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
+
+describe('Graceful Shutdown', () => {
+    let mockServer;
+    let mockExit;
+    let processListeners;
+
+    beforeEach(() => {
+        jest.useFakeTimers({ legacyFakeTimers: true });
+        jest.clearAllMocks();
+        processListeners = {};
+
+        mockServer = {
+            close: jest.fn().mockImplementation((cb) => {
+                if (cb) Promise.resolve().then(() => cb());
+                return mockServer;
+            })
+        };
+
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+        jest.spyOn(process, 'on').mockImplementation((event, handler) => {
+            processListeners[event] = handler;
+            return process;
+        });
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+
+    it('should register SIGTERM and SIGINT events', () => {
+        setupGracefulShutdown(mockServer);
+        expect(processListeners['SIGTERM']).toBeDefined();
+        expect(processListeners['SIGINT']).toBeDefined();
+    });
+
+    it('should cleanly shutdown all connections and exit 0', async () => {
+        setupGracefulShutdown(mockServer);
+        
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockServer.close).toHaveBeenCalled();
+
+        <%_ if (database === 'MongoDB') { -%>
+        const mongoose = require('mongoose');
+        expect(mongoose.connection.close).toHaveBeenCalledWith(false);
+        <%_ } else if (database !== 'None') { -%>
+        const sequelize = require('<%- dbPath %>');
+        expect(sequelize.close).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (caching === 'Redis') { -%>
+        const redisService = require('<%- redisPath %>');
+        expect(redisService.quit).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (communication === 'Kafka') { -%>
+        const { disconnectKafka } = require('<%- kafkaPath %>');
+        expect(disconnectKafka).toHaveBeenCalled();
+        <%_ } -%>
+
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should exit 0 on SIGINT', async () => {
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGINT']();
+        await flushPromises();
+        await flushPromises();
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+<%_ if (communication === 'Kafka' || database !== 'None' || caching === 'Redis') { _%>
+    it('should handle errors during shutdown and exit 1', async () => {
+        <%_ if (communication === 'Kafka') { _%>
+        const { disconnectKafka } = require('<%- kafkaPath %>');
+        disconnectKafka.mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database === 'MongoDB') { _%>
+        const mongoose = require('mongoose');
+        mongoose.connection.close = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database !== 'None') { _%>
+        const sequelize = require('<%- dbPath %>');
+        sequelize.close = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (caching === 'Redis') { _%>
+        const redisService = require('<%- redisPath %>');
+        redisService.quit = jest.fn().mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } _%>
+
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should forcefully shutdown if cleanup takes too long', async () => {
+        setupGracefulShutdown(mockServer);
+        processListeners['SIGTERM']();
+        
+        jest.advanceTimersByTime(15000);
+        
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+<%_ } _%>
+});

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

@@ -0,0 +1,158 @@
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import { Server } from 'http';
+<%_ 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<% } %>';
+<%_ } -%>
+
+<%_ if (database === 'MongoDB') { -%>
+jest.mock('mongoose', () => {
+    return {
+        __esModule: true,
+        default: {
+            connection: {
+                close: jest.fn().mockResolvedValue(true)
+            }
+        }
+    };
+});
+<%_ } else if (database !== 'None') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>', () => {
+    return {
+        __esModule: true,
+        default: {
+            close: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } -%>
+
+<%_ if (caching === 'Redis') { -%>
+jest.mock('<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>', () => {
+    return {
+        __esModule: true,
+        default: {
+            quit: jest.fn().mockResolvedValue(true)
+        }
+    };
+});
+<%_ } -%>
+
+const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
+
+describe('Graceful Shutdown', () => {
+    let mockServer: Partial<Server>;
+    let mockExit: jest.SpyInstance;
+    let processListeners: Record<string, (...args: any[]) => void>;
+    <%_ if (communication === 'Kafka') { -%>
+    let mockKafkaService: { disconnect: jest.Mock };
+    <%_ } -%>
+
+    beforeEach(() => {
+        jest.useFakeTimers({ legacyFakeTimers: true });
+        jest.clearAllMocks();
+        processListeners = {};
+
+        mockServer = {
+            close: jest.fn().mockImplementation((cb?: (err?: Error) => void) => {
+                if (cb) Promise.resolve().then(() => cb());
+                return mockServer;
+            })
+        };
+
+        mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+        jest.spyOn(process, 'on').mockImplementation(((event: string, handler: (...args: any[]) => void) => {
+            processListeners[event] = handler;
+            return process;
+        }) as any);
+
+        <%_ if (communication === 'Kafka') { -%>
+        mockKafkaService = { disconnect: jest.fn().mockResolvedValue(true) };
+        <%_ } -%>
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+
+    it('should register SIGTERM and SIGINT events', () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        expect(processListeners['SIGTERM']).toBeDefined();
+        expect(processListeners['SIGINT']).toBeDefined();
+    });
+
+    it('should cleanly shutdown all connections and exit 0 on SIGTERM', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        
+        processListeners['SIGTERM']();
+        
+        // Flush microtask queue multiple times for nested async operations
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockServer.close).toHaveBeenCalled();
+
+        <%_ if (database === 'MongoDB') { -%>
+        expect(mongoose.connection.close).toHaveBeenCalledWith(false);
+        <%_ } else if (database !== 'None') { -%>
+        expect(sequelize.close).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (caching === 'Redis') { -%>
+        expect(redisService.quit).toHaveBeenCalled();
+        <%_ } -%>
+
+        <%_ if (communication === 'Kafka') { -%>
+        expect(mockKafkaService.disconnect).toHaveBeenCalled();
+        <%_ } -%>
+
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should exit 0 on SIGINT', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGINT']();
+        await flushPromises();
+        await flushPromises();
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+<%_ if (communication === 'Kafka' || database !== 'None' || caching === 'Redis') { _%>
+    it('should handle errors during shutdown and exit 1', async () => {
+        <%_ if (communication === 'Kafka') { _%>
+        mockKafkaService.disconnect.mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database === 'MongoDB') { _%>
+        (mongoose.connection.close as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (database !== 'None') { _%>
+        (sequelize.close as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } else if (caching === 'Redis') { _%>
+        (redisService.quit as jest.Mock).mockRejectedValueOnce(new Error('Shutdown Error'));
+        <%_ } _%>
+
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGTERM']();
+        
+        await flushPromises();
+        await flushPromises();
+        await flushPromises();
+
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should forcefully shutdown if cleanup takes too long', async () => {
+        setupGracefulShutdown(mockServer as Server<% if (communication === 'Kafka') { %>, mockKafkaService<% } %>);
+        processListeners['SIGTERM']();
+        
+        jest.advanceTimersByTime(15000);
+        
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+<%_ } _%>
+
+});

package/templates/common/src/utils/errorMiddleware.spec.js.ejs

@@ -0,0 +1,79 @@
+const { errorMiddleware } = require('<% if (architecture === "MVC") { %>@/utils/errorMiddleware<% } else { %>@/infrastructure/webserver/middleware/errorMiddleware<% } %>');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const logger = require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+describe('Error Middleware', () => {
+    let mockRequest;
+    let mockResponse;
+    let nextFunction;
+    const originalEnv = process.env.NODE_ENV;
+
+    beforeEach(() => {
+        mockRequest = {
+            originalUrl: '/test',
+            method: 'GET',
+            ip: '127.0.0.1'
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        nextFunction = jest.fn();
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should handle standard Error by wrapping it in a 500 ApiError', () => {
+        const error = new Error('Standard Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        expect(logger.error).toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    });
+
+    it('should handle custom ApiError directly', () => {
+        const customError = new ApiError(HTTP_STATUS.BAD_REQUEST, 'Bad Request Data', true);
+        errorMiddleware(customError, mockRequest, mockResponse, nextFunction);
+
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.BAD_REQUEST);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.BAD_REQUEST,
+            message: 'Bad Request Data'
+        }));
+    });
+
+    it('should include stack trace in development environment', () => {
+        process.env.NODE_ENV = 'development';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            stack: expect.any(String)
+        }));
+    });
+
+    it('should omit stack trace in production environment', () => {
+        process.env.NODE_ENV = 'production';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest, mockResponse, nextFunction);
+
+        const jsonArg = mockResponse.json.mock.calls[0][0];
+        expect(jsonArg.stack).toBeUndefined();
+    });
+
+    it('should handle error without stack trace', () => {
+        const { ApiError } = require('@/errors/ApiError');
+        const customError = new ApiError(500, 'No Stack', false);
+        delete customError.stack;
+        errorMiddleware(customError, mockRequest, mockResponse, nextFunction);
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('No Stack'));
+        expect(logger.error).toHaveBeenCalledWith('No stack trace');
+    });
+});

package/templates/common/src/utils/errorMiddleware.spec.ts.ejs

@@ -0,0 +1,94 @@
+import { errorMiddleware } from '<% if (architecture === "MVC" || language === "TypeScript") { %>@/utils/errorMiddleware<% } else { %>@/infrastructure/webserver/middleware/errorMiddleware<% } %>';
+import { Request, Response } from 'express';
+import { ApiError } from '@/errors/ApiError';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import logger from '<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>';
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+
+describe('Error Middleware', () => {
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let nextFunction: jest.Mock;
+    const originalEnv = process.env.NODE_ENV;
+
+    beforeEach(() => {
+        mockRequest = {
+            originalUrl: '/test',
+            method: 'GET',
+            ip: '127.0.0.1'
+        };
+        mockResponse = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn()
+        };
+        nextFunction = jest.fn();
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should handle standard Error by wrapping it in a 500 ApiError', () => {
+        const error = new Error('Standard Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            message: 'Standard Error'
+        }));
+    });
+
+    it('should default to Internal Server Error message if none provided on Error', () => {
+        const error = new Error();
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.INTERNAL_SERVER_ERROR);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Internal Server Error'
+        }));
+    });
+
+    it('should handle custom ApiError directly', () => {
+        const customError = new ApiError(HTTP_STATUS.BAD_REQUEST, 'Bad Request Data', true);
+        errorMiddleware(customError, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).not.toHaveBeenCalled();
+        expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.BAD_REQUEST);
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            statusCode: HTTP_STATUS.BAD_REQUEST,
+            message: 'Bad Request Data'
+        }));
+    });
+
+    it('should include stack trace in development environment', () => {
+        process.env.NODE_ENV = 'development';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+            stack: expect.any(String)
+        }));
+    });
+
+    it('should omit stack trace in production environment', () => {
+        process.env.NODE_ENV = 'production';
+        const error = new Error('Test Error');
+        errorMiddleware(error, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        const jsonArg = (mockResponse.json as jest.Mock).mock.calls[0][0];
+        expect(jsonArg.stack).toBeUndefined();
+    });
+
+    it('should handle error without stack trace', () => {
+        const customError = new ApiError(HTTP_STATUS.INTERNAL_SERVER_ERROR, 'No Stack', false);
+        delete customError.stack;
+        errorMiddleware(customError, mockRequest as Request, mockResponse as Response, nextFunction);
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('No Stack'));
+        expect(logger.error).toHaveBeenCalledWith('No stack trace');
+    });
+});

package/templates/common/tsconfig.json

@@ -18,6 +18,6 @@
     ],
     "exclude": [
         "node_modules",
-        "**/*.test.ts"
+        "dist"
     ]
 }