nodejs-quickstart-structure 1.19.0 → 2.0.0

package/templates/common/database/js/database.spec.js.ejs

@@ -1,56 +1,56 @@
-jest.mock('sequelize', () => {
-    const mSequelize = jest.fn(() => ({
-        authenticate: jest.fn().mockResolvedValue(true),
-        define: jest.fn(),
-    }));
-    return { Sequelize: mSequelize };
-});
-
-jest.mock('dotenv', () => ({
-    config: jest.fn()
-}));
-
-describe('Database Configuration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.resetModules();
-        
-        // Clean environment
-        const envVars = ['DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT'];
-        envVars.forEach(v => delete process.env[v]);
-    });
-
-    it('should initialize Sequelize with environment variables', () => {
-        const { Sequelize: SequelizeMock } = require('sequelize');
-        process.env.DB_NAME = 'testdb';
-        process.env.DB_USER = 'testuser';
-        process.env.DB_PASSWORD = 'testpassword';
-        process.env.DB_HOST = 'localhost';
-        process.env.DB_PORT = '5432';
-        
-        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        
-        expect(SequelizeMock).toHaveBeenCalledWith(
-            'testdb',
-            'testuser',
-            'testpassword',
-            expect.objectContaining({
-                host: 'localhost',
-                port: 5432
-            })
-        );
-    });
-
-    it('should initialize Sequelize with default values when env vars are missing', () => {
-        const { Sequelize: SequelizeMock } = require('sequelize');
-        delete process.env.DB_NAME;
-        delete process.env.DB_USER;
-        delete process.env.DB_PASSWORD;
-        delete process.env.DB_HOST;
-        delete process.env.DB_PORT;
-
-        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        
-        expect(SequelizeMock).toHaveBeenCalledTimes(1);
-    });
-});
+jest.mock('sequelize', () => {
+    const mSequelize = jest.fn(() => ({
+        authenticate: jest.fn().mockResolvedValue(true),
+        define: jest.fn(),
+    }));
+    return { Sequelize: mSequelize };
+});
+
+jest.mock('dotenv', () => ({
+    config: jest.fn()
+}));
+
+describe('Database Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        
+        // Clean environment
+        const envVars = ['DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT'];
+        envVars.forEach(v => delete process.env[v]);
+    });
+
+    it('should initialize Sequelize with environment variables', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        process.env.DB_NAME = 'testdb';
+        process.env.DB_USER = 'testuser';
+        process.env.DB_PASSWORD = 'testpassword';
+        process.env.DB_HOST = 'localhost';
+        process.env.DB_PORT = '5432';
+        
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenCalledWith(
+            'testdb',
+            'testuser',
+            'testpassword',
+            expect.objectContaining({
+                host: 'localhost',
+                port: 5432
+            })
+        );
+    });
+
+    it('should initialize Sequelize with default values when env vars are missing', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        delete process.env.DB_NAME;
+        delete process.env.DB_USER;
+        delete process.env.DB_PASSWORD;
+        delete process.env.DB_HOST;
+        delete process.env.DB_PORT;
+
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/common/database/js/mongoose.js.ejs

@@ -1,33 +1,33 @@
-const mongoose = require('mongoose');
-
-let logger;
-<% if (architecture === 'MVC') { %>
-logger = require('../utils/logger');
-<% } else { %>
-logger = require('../log/logger');
-<% } %>
-const connectDB = async () => {
-    const dbHost = process.env.DB_HOST || 'localhost';
-    const dbPort = process.env.DB_PORT || '27017';
-    const dbName = process.env.DB_NAME || '<%= dbName %>';
-    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
-    
-    let retries = 5;
-    while (retries) {
-        try {
-            await mongoose.connect(mongoURI, {
-                useNewUrlParser: true,
-                useUnifiedTopology: true
-            });
-            logger.info('MongoDB Connected...');
-            break;
-        } catch (err) {
-            logger.error('MongoDB connection failed:', err);
-            retries -= 1;
-            logger.info(`Retries left: ${retries}. Waiting 5s...`);
-            await new Promise(res => setTimeout(res, 5000));
-        }
-    }
-};
-
-module.exports = connectDB; // Export function to call in index.js
+const mongoose = require('mongoose');
+
+let logger;
+<% if (architecture === 'MVC') { %>
+logger = require('../utils/logger');
+<% } else { %>
+logger = require('../log/logger');
+<% } %>
+const connectDB = async () => {
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const dbPort = process.env.DB_PORT || '27017';
+    const dbName = process.env.DB_NAME || '<%= dbName %>';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
+    
+    let retries = 5;
+    while (retries) {
+        try {
+            await mongoose.connect(mongoURI, {
+                useNewUrlParser: true,
+                useUnifiedTopology: true
+            });
+            logger.info('MongoDB Connected...');
+            break;
+        } catch (err) {
+            logger.error('MongoDB connection failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+module.exports = connectDB; // Export function to call in index.js

package/templates/common/database/js/mongoose.spec.js.ejs

@@ -1,43 +1,43 @@
-jest.mock('mongoose', () => ({
-    connect: jest.fn().mockResolvedValue(true),
-}));
-
-const mockLogger = {
-    info: jest.fn(),
-    error: jest.fn(),
-};
-
-jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => mockLogger);
-
-describe('Mongoose Configuration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.resetModules();
-    });
-
-    it('should call mongoose.connect with correct parameters', async () => {
-        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        const mongoose = require('mongoose');
-        await connectDB();
-        expect(mongoose.connect).toHaveBeenCalledWith(
-            expect.stringContaining('mongodb://'),
-            expect.any(Object)
-        );
-    });
-
-    it('should handle connection failure and retry', async () => {
-        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        const mongoose = require('mongoose');
-        mongoose.connect
-            .mockRejectedValueOnce(new Error('Connection failed'))
-            .mockResolvedValueOnce(true);
-
-        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb());
-        
-        await connectDB();
-        
-        expect(mockLogger.error).toHaveBeenCalled();
-        expect(mongoose.connect).toHaveBeenCalledTimes(2);
-        timeoutSpy.mockRestore();
-    });
-});
+jest.mock('mongoose', () => ({
+    connect: jest.fn().mockResolvedValue(true),
+}));
+
+const mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => mockLogger);
+
+describe('Mongoose Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+    });
+
+    it('should call mongoose.connect with correct parameters', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        const mongoose = require('mongoose');
+        await connectDB();
+        expect(mongoose.connect).toHaveBeenCalledWith(
+            expect.stringContaining('mongodb://'),
+            expect.any(Object)
+        );
+    });
+
+    it('should handle connection failure and retry', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        const mongoose = require('mongoose');
+        mongoose.connect
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(true);
+
+        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb());
+        
+        await connectDB();
+        
+        expect(mockLogger.error).toHaveBeenCalled();
+        expect(mongoose.connect).toHaveBeenCalledTimes(2);
+        timeoutSpy.mockRestore();
+    });
+});

package/templates/common/database/ts/database.spec.ts.ejs

@@ -1,56 +1,56 @@
-jest.mock('sequelize', () => {
-    const mSequelize = jest.fn(() => ({
-        authenticate: jest.fn().mockResolvedValue(true),
-        define: jest.fn(),
-    }));
-    return { Sequelize: mSequelize };
-});
-
-jest.mock('dotenv', () => ({
-    config: jest.fn()
-}));
-
-describe('Database Configuration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.resetModules();
-        
-        // Clean environment
-        const envVars = ['DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT'];
-        envVars.forEach(v => delete process.env[v]);
-    });
-
-    it('should initialize Sequelize with environment variables', () => {
-        const { Sequelize: SequelizeMock } = require('sequelize');
-        process.env.DB_NAME = 'testdb';
-        process.env.DB_USER = 'testuser';
-        process.env.DB_PASSWORD = 'testpassword';
-        process.env.DB_HOST = 'localhost';
-        process.env.DB_PORT = '5432';
-
-        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        
-        expect(SequelizeMock).toHaveBeenLastCalledWith(
-            'testdb',
-            'testuser',
-            'testpassword',
-            expect.objectContaining({
-                host: 'localhost',
-                port: 5432
-            })
-        );
-    });
-
-    it('should initialize Sequelize with default values when env vars are missing', () => {
-        const { Sequelize: SequelizeMock } = require('sequelize');
-        delete process.env.DB_NAME;
-        delete process.env.DB_USER;
-        delete process.env.DB_PASSWORD;
-        delete process.env.DB_HOST;
-        delete process.env.DB_PORT;
-
-        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
-        
-        expect(SequelizeMock).toHaveBeenCalledTimes(1);
-    });
-});
+jest.mock('sequelize', () => {
+    const mSequelize = jest.fn(() => ({
+        authenticate: jest.fn().mockResolvedValue(true),
+        define: jest.fn(),
+    }));
+    return { Sequelize: mSequelize };
+});
+
+jest.mock('dotenv', () => ({
+    config: jest.fn()
+}));
+
+describe('Database Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        
+        // Clean environment
+        const envVars = ['DB_NAME', 'DB_USER', 'DB_PASSWORD', 'DB_HOST', 'DB_PORT'];
+        envVars.forEach(v => delete process.env[v]);
+    });
+
+    it('should initialize Sequelize with environment variables', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        process.env.DB_NAME = 'testdb';
+        process.env.DB_USER = 'testuser';
+        process.env.DB_PASSWORD = 'testpassword';
+        process.env.DB_HOST = 'localhost';
+        process.env.DB_PORT = '5432';
+
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenLastCalledWith(
+            'testdb',
+            'testuser',
+            'testpassword',
+            expect.objectContaining({
+                host: 'localhost',
+                port: 5432
+            })
+        );
+    });
+
+    it('should initialize Sequelize with default values when env vars are missing', () => {
+        const { Sequelize: SequelizeMock } = require('sequelize');
+        delete process.env.DB_NAME;
+        delete process.env.DB_USER;
+        delete process.env.DB_PASSWORD;
+        delete process.env.DB_HOST;
+        delete process.env.DB_PORT;
+
+        require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>');
+        
+        expect(SequelizeMock).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,21 +1,21 @@
-import { Sequelize } from 'sequelize';
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-<% if (database === 'MySQL') { %>const dialect = 'mysql';<% } -%>
-<% if (database === 'PostgreSQL') { %>const dialect = 'postgres';<% } -%>
-
-const sequelize = new Sequelize(
-  process.env.DB_NAME || '<%= dbName %>',
-  process.env.DB_USER || '<% if (database === 'MySQL') { %>root<% } else { %>postgres<% } %>',
-  process.env.DB_PASSWORD || '<% if (database === 'MySQL') { %>root<% } else { %>root<% } %>',
-  {
-    host: process.env.DB_HOST || '127.0.0.1',
-    dialect: dialect,
-    logging: false,
-    port: parseInt(process.env.DB_PORT || '<% if (database === 'MySQL') { %>3306<% } else { %>5432<% } %>')
-  }
-);
-
-export default sequelize;
+import { Sequelize } from 'sequelize';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+<% if (database === 'MySQL') { %>const dialect = 'mysql';<% } -%>
+<% if (database === 'PostgreSQL') { %>const dialect = 'postgres';<% } -%>
+
+const sequelize = new Sequelize(
+  process.env.DB_NAME || '<%= dbName %>',
+  process.env.DB_USER || '<% if (database === 'MySQL') { %>root<% } else { %>postgres<% } %>',
+  process.env.DB_PASSWORD || '<% if (database === 'MySQL') { %>root<% } else { %>root<% } %>',
+  {
+    host: process.env.DB_HOST || '127.0.0.1',
+    dialect: dialect,
+    logging: false,
+    port: parseInt(process.env.DB_PORT || '<% if (database === 'MySQL') { %>3306<% } else { %>5432<% } %>')
+  }
+);
+
+export default sequelize;

package/templates/common/database/ts/mongoose.spec.ts.ejs

@@ -1,42 +1,42 @@
-jest.mock('mongoose', () => ({
-    connect: jest.fn().mockResolvedValue(true),
-}));
-
-const logger = {
-    info: jest.fn(),
-    error: jest.fn(),
-};
-
-jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => logger);
-
-describe('Mongoose Configuration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.resetModules();
-    });
-
-    it('should call mongoose.connect with correct parameters', async () => {
-        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
-        const mongoose = require('mongoose');
-        await connectDB();
-        expect(mongoose.connect).toHaveBeenCalledWith(
-            expect.stringContaining('mongodb://')
-        );
-    });
-
-    it('should handle connection failure and retry', async () => {
-        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
-        const mongoose = require('mongoose');
-        (mongoose.connect as jest.Mock)
-            .mockRejectedValueOnce(new Error('Connection failed'))
-            .mockResolvedValueOnce(true);
-
-        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => { (cb as any)(); return {} as any; });
-        
-        await connectDB();
-        
-        expect(logger.error).toHaveBeenCalled();
-        expect(mongoose.connect).toHaveBeenCalledTimes(2);
-        timeoutSpy.mockRestore();
-    });
-});
+jest.mock('mongoose', () => ({
+    connect: jest.fn().mockResolvedValue(true),
+}));
+
+const logger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => logger);
+
+describe('Mongoose Configuration', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+    });
+
+    it('should call mongoose.connect with correct parameters', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
+        const mongoose = require('mongoose');
+        await connectDB();
+        expect(mongoose.connect).toHaveBeenCalledWith(
+            expect.stringContaining('mongodb://')
+        );
+    });
+
+    it('should handle connection failure and retry', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
+        const mongoose = require('mongoose');
+        (mongoose.connect as jest.Mock)
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(true);
+
+        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => { (cb as any)(); return {} as any; });
+        
+        await connectDB();
+        
+        expect(logger.error).toHaveBeenCalled();
+        expect(mongoose.connect).toHaveBeenCalledTimes(2);
+        timeoutSpy.mockRestore();
+    });
+});

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

@@ -1,28 +1,28 @@
-import mongoose from 'mongoose';
-<% if (architecture === 'MVC') { %>
-import logger from '@/utils/logger';
-<% } else { %>
-import logger from '@/infrastructure/log/logger';
-<% } %>
-const connectDB = async (): Promise<void> => {
-    const dbHost = process.env.DB_HOST || 'localhost';
-    const dbPort = process.env.DB_PORT || '27017';
-    const dbName = process.env.DB_NAME || '<%= dbName %>';
-    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
-    
-    let retries = 5;
-    while (retries) {
-        try {
-            await mongoose.connect(mongoURI);
-            logger.info('MongoDB Connected...');
-            break;
-        } catch (err) {
-            logger.error('MongoDB connection failed:', err);
-            retries -= 1;
-            logger.info(`Retries left: ${retries}. Waiting 5s...`);
-            await new Promise(res => setTimeout(res, 5000));
-        }
-    }
-};
-
-export default connectDB;
+import mongoose from 'mongoose';
+<% if (architecture === 'MVC') { %>
+import logger from '@/utils/logger';
+<% } else { %>
+import logger from '@/infrastructure/log/logger';
+<% } %>
+const connectDB = async (): Promise<void> => {
+    const dbHost = process.env.DB_HOST || 'localhost';
+    const dbPort = process.env.DB_PORT || '27017';
+    const dbName = process.env.DB_NAME || '<%= dbName %>';
+    const mongoURI = process.env.MONGO_URI || `mongodb://${dbHost}:${dbPort}/${dbName}`;
+    
+    let retries = 5;
+    while (retries) {
+        try {
+            await mongoose.connect(mongoURI);
+            logger.info('MongoDB Connected...');
+            break;
+        } catch (err) {
+            logger.error('MongoDB connection failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+export default connectDB;