nodejs-quickstart-structure 1.12.0 → 1.14.0

package/templates/common/caching/ts/memoryCache.spec.ts.ejs

@@ -0,0 +1,102 @@
+jest.mock('node-cache', () => {
+    return jest.fn().mockImplementation(() => ({
+        get: jest.fn(),
+        set: jest.fn(),
+        del: jest.fn(),
+    }));
+});
+
+jest.mock('<%- loggerPath %>', () => ({
+    info: jest.fn(),
+    error: jest.fn(),
+}));
+
+describe('Memory Cache Client', () => {
+    let MemoryCacheService: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        MemoryCacheService = require('<% if (architecture === "MVC") { %>@/config/memoryCache<% } else { %>@/infrastructure/caching/memoryCache<% } %>').default;
+    });
+
+    it('should get data from memory cache', async () => {
+        const mockData = { test: 'data' };
+        MemoryCacheService.cache.get.mockReturnValue(JSON.stringify(mockData));
+        
+        const data = await MemoryCacheService.get('test-key');
+        expect(data).toEqual(mockData);
+        expect(MemoryCacheService.cache.get).toHaveBeenCalledWith('test-key');
+    });
+
+    it('should return null when key is not found', async () => {
+        MemoryCacheService.cache.get.mockReturnValue(undefined);
+        const data = await MemoryCacheService.get('non-existent');
+        expect(data).toBeNull();
+    });
+
+    it('should return data as is if not a string', async () => {
+        const mockData = { test: 'data' };
+        MemoryCacheService.cache.get.mockReturnValue(mockData);
+        const data = await MemoryCacheService.get('binary-key');
+        expect(data).toEqual(mockData);
+    });
+
+    it('should handle errors in get', async () => {
+        MemoryCacheService.cache.get.mockImplementation(() => { throw new Error('Cache Error'); });
+        const data = await MemoryCacheService.get('error-key');
+        expect(data).toBeNull();
+    });
+
+    it('should set data to memory cache without TTL', async () => {
+        const mockData = { test: 'data' };
+        await MemoryCacheService.set('test-key', mockData);
+        expect(MemoryCacheService.cache.set).toHaveBeenCalledWith('test-key', JSON.stringify(mockData));
+    });
+
+    it('should handle errors in set', async () => {
+        MemoryCacheService.cache.set.mockImplementation(() => { throw new Error('Cache Error'); });
+        await MemoryCacheService.set('test-key', 'value');
+        // Should not throw
+    });
+
+    it('should handle errors in del', async () => {
+        MemoryCacheService.cache.del.mockImplementation(() => { throw new Error('Cache Error'); });
+        await MemoryCacheService.del('test-key');
+        // Should not throw
+    });
+
+    it('should use getOrSet and call fetcher if not cached', async () => {
+        MemoryCacheService.get = jest.fn().mockResolvedValue(null);
+        MemoryCacheService.set = jest.fn();
+        const fetcher = jest.fn().mockResolvedValue({ new: 'data' });
+
+        const result = await MemoryCacheService.getOrSet('new-key', fetcher);
+        
+        expect(result).toEqual({ new: 'data' });
+        expect(fetcher).toHaveBeenCalled();
+        expect(MemoryCacheService.set).toHaveBeenCalledWith('new-key', { new: 'data' }, 3600);
+    });
+
+    it('should return cached data in getOrSet', async () => {
+        const cachedData = { cached: 'data' };
+        MemoryCacheService.get = jest.fn().mockResolvedValue(cachedData);
+        const fetcher = jest.fn();
+
+        const result = await MemoryCacheService.getOrSet('cached-key', fetcher);
+        
+        expect(result).toEqual(cachedData);
+        expect(fetcher).not.toHaveBeenCalled();
+    });
+
+    it('should handle falsy data from fetcher in getOrSet', async () => {
+        MemoryCacheService.get = jest.fn().mockResolvedValue(null);
+        MemoryCacheService.set = jest.fn();
+        const fetcher = jest.fn().mockResolvedValue(null);
+
+        const result = await MemoryCacheService.getOrSet('empty-key', fetcher);
+        
+        expect(result).toBeNull();
+        expect(MemoryCacheService.set).not.toHaveBeenCalled();
+    });
+});

package/templates/common/caching/ts/redisClient.spec.ts.ejs

@@ -0,0 +1,157 @@
+jest.mock('ioredis', () => {
+  const mRedis = jest.fn(() => ({
+    on: jest.fn(),
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn(),
+    quit: jest.fn().mockResolvedValue('OK'),
+  }));
+  return mRedis;
+});
+
+jest.mock('dotenv', () => ({
+    config: jest.fn()
+}));
+
+const mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<%- loggerPath %>', () => mockLogger);
+
+describe('Redis Client', () => {
+    let RedisService: any;
+    let logger: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        
+        // Clean environment
+        const envVars = ['REDIS_HOST', 'REDIS_PORT', 'REDIS_PASSWORD'];
+        envVars.forEach(v => delete process.env[v]);
+        
+        logger = require('<%- loggerPath %>');
+        RedisService = require('<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>').default;
+    });
+
+    it('should initialize with default values when env vars are missing', () => {
+        delete process.env.REDIS_HOST;
+        delete process.env.REDIS_PORT;
+        delete process.env.REDIS_PASSWORD;
+        
+        jest.resetModules();
+        const NewRedisService = require('<% if (architecture === "MVC") { %>@/config/redisClient<% } else { %>@/infrastructure/caching/redisClient<% } %>').default;
+        expect(NewRedisService).toBeDefined();
+    });
+
+    it('should handle redis events', () => {
+        // Find the event handlers
+        const handlers: { [key: string]: (...args: any[]) => any } = {};
+        (RedisService.client.on as jest.Mock).mock.calls.forEach(([event, handler]) => {
+            handlers[event] = handler;
+        });
+
+        if (handlers['connect']) {
+            handlers['connect']();
+            expect(logger.info).toHaveBeenCalledWith('Redis connected');
+        }
+
+        if (handlers['error']) {
+            handlers['error'](new Error('Test Error'));
+            expect(logger.error).toHaveBeenCalledWith('Redis error:', expect.any(Error));
+        }
+    });
+
+    it('should get data from redis', async () => {
+        const mockData = { test: 'data' };
+        RedisService.client.get.mockResolvedValue(JSON.stringify(mockData));
+        
+        const data = await RedisService.get('test-key');
+        expect(data).toEqual(mockData);
+        expect(RedisService.client.get).toHaveBeenCalledWith('test-key');
+    });
+
+    it('should return null when key not found in redis', async () => {
+        RedisService.client.get.mockResolvedValue(null);
+        const data = await RedisService.get('non-existent');
+        expect(data).toBeNull();
+    });
+
+    it('should handle errors in get', async () => {
+        RedisService.client.get.mockRejectedValue(new Error('Redis Error'));
+        const result = await RedisService.get('test-key');
+        expect(result).toBeNull();
+        expect(logger.error).toHaveBeenCalled();
+    });
+
+    it('should set data to redis without TTL', async () => {
+        const mockData = { test: 'data' };
+        await RedisService.set('test-key', mockData);
+        expect(RedisService.client.set).toHaveBeenCalledWith('test-key', JSON.stringify(mockData));
+    });
+
+    it('should set data to redis with TTL', async () => {
+        const mockData = { test: 'data' };
+        await RedisService.set('test-key', mockData, 3600);
+        expect(RedisService.client.set).toHaveBeenCalledWith('test-key', JSON.stringify(mockData), 'EX', 3600);
+    });
+
+    it('should handle errors in set', async () => {
+        RedisService.client.set.mockRejectedValue(new Error('Redis Error'));
+        await RedisService.set('test-key', 'value');
+        expect(logger.error).toHaveBeenCalled();
+    });
+
+    it('should delete data from redis', async () => {
+        await RedisService.del('test-key');
+        expect(RedisService.client.del).toHaveBeenCalledWith('test-key');
+    });
+
+    it('should handle errors in del', async () => {
+        RedisService.client.del.mockRejectedValue(new Error('Redis Error'));
+        await RedisService.del('test-key');
+        expect(logger.error).toHaveBeenCalled();
+    });
+
+    it('should use getOrSet and call fetcher if not cached', async () => {
+        RedisService.get = jest.fn().mockResolvedValue(null);
+        RedisService.set = jest.fn();
+        const fetcher = jest.fn().mockResolvedValue({ new: 'data' });
+
+        const result = await RedisService.getOrSet('new-key', fetcher);
+        
+        expect(result).toEqual({ new: 'data' });
+        expect(fetcher).toHaveBeenCalled();
+        expect(RedisService.set).toHaveBeenCalledWith('new-key', { new: 'data' }, 3600);
+    });
+
+    it('should use getOrSet and return cached data', async () => {
+        const cachedData = { cached: 'data' };
+        RedisService.get = jest.fn().mockResolvedValue(cachedData);
+        const fetcher = jest.fn();
+
+        const result = await RedisService.getOrSet('cached-key', fetcher);
+        
+        expect(result).toEqual(cachedData);
+        expect(fetcher).not.toHaveBeenCalled();
+    });
+
+    it('should handle falsy data from fetcher in getOrSet', async () => {
+        RedisService.get = jest.fn().mockResolvedValue(null);
+        RedisService.set = jest.fn();
+        const fetcher = jest.fn().mockResolvedValue(null);
+
+        const result = await RedisService.getOrSet('empty-key', fetcher);
+        
+        expect(result).toBeNull();
+        expect(RedisService.set).not.toHaveBeenCalled();
+    });
+
+    it('should quit the redis client', async () => {
+        const result = await RedisService.quit();
+        expect(result).toBe('OK');
+        expect(RedisService.client.quit).toHaveBeenCalled();
+    });
+});

package/templates/common/caching/ts/redisClient.ts.ejs

@@ -71,6 +71,10 @@ class RedisService {
         if (data) await this.set(key, data, ttl);
         return data;
     }
+
+    public async quit(): Promise<'OK'> {
+        return await this.client.quit();
+    }
 }
 
 export default RedisService.getInstance();

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

@@ -0,0 +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);
+    });
+});

package/templates/common/database/js/models/User.js.ejs

@@ -1,3 +1,24 @@
+<% if (database === 'None') { -%>
+class UserModel {
+  static mockData = [];
+
+  static async find() {
+    return this.mockData;
+  }
+
+  static async findAll() {
+    return this.mockData;
+  }
+
+  static async create(data) {
+    const newUser = { id: String(this.mockData.length + 1), ...data };
+    this.mockData.push(newUser);
+    return newUser;
+  }
+}
+
+module.exports = UserModel;
+<% } else { -%>
 const { DataTypes, Model } = require('sequelize');
 <% if (architecture === 'MVC') { %>const sequelize = require('../config/database');<% } else { %>const sequelize = require('../database');<% } %>
 
@@ -28,3 +49,4 @@ User.init(
 );
 
 module.exports = User;
+<% } -%>

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

@@ -0,0 +1,84 @@
+<% if (database === 'MongoDB') { _%>
+const mongoose = require('mongoose');
+
+jest.mock('mongoose', () => {
+    const mSchema = jest.fn();
+    const mModel = {
+        find: jest.fn(),
+        create: jest.fn(),
+    };
+    return {
+        Schema: mSchema,
+        model: jest.fn().mockReturnValue(mModel),
+    };
+});
+<% } else if (database === 'None') { _%>
+// No external dependencies to mock for None DB
+<% } else { _%>
+const { Model } = require('sequelize');
+
+jest.mock('sequelize', () => {
+    const mDataTypes = {
+        INTEGER: 'INTEGER',
+        STRING: 'STRING',
+    };
+    const mModel = class {
+        static init = jest.fn();
+        static findAll = jest.fn();
+        static create = jest.fn();
+    };
+    return { DataTypes: mDataTypes, Model: mModel };
+});
+
+<% if (architecture === 'MVC') { _%>
+jest.mock('@/config/database', () => ({}));
+<% } else { _%>
+jest.mock('@/infrastructure/database/database', () => ({}));
+<% } _%>
+<% } _%>
+
+describe('User Model', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should be defined and initialized', () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>');
+        expect(User).toBeDefined();
+        <% if (database === 'MongoDB') { %>
+        expect(mongoose.model).toHaveBeenCalled();
+        <% } else if (database === 'None') { %>
+        // Test mockData is initialized
+        expect(User.mockData).toEqual([]);
+        <% } else { %>
+        // Sequelize init is called on the class
+        expect(Model.init).toHaveBeenCalled();
+        <% } %>
+    });
+
+    it('should handle model operations', async () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>');
+        const data = { name: 'Test', email: 'test@example.com' };
+
+        <% if (database === 'MongoDB') { %>
+        User.create.mockResolvedValue({ id: '1', ...data });
+        User.find.mockResolvedValue([{ id: '1', ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        <% } else if (database === 'None') { %>
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        expect(await User.findAll()).toBeDefined();
+        <% } else { %>
+        User.create.mockResolvedValue({ id: 1, ...data });
+        User.findAll.mockResolvedValue([{ id: 1, ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.findAll()).toBeDefined();
+        <% } %>
+    });
+});

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

@@ -0,0 +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();
+    });
+});

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

@@ -0,0 +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);
+    });
+});

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

@@ -0,0 +1,84 @@
+<% if (database === 'MongoDB') { _%>
+import mongoose from 'mongoose';
+
+jest.mock('mongoose', () => {
+    const mSchema = jest.fn();
+    const mModel = {
+        find: jest.fn(),
+        create: jest.fn(),
+    };
+    return {
+        Schema: mSchema,
+        model: jest.fn().mockReturnValue(mModel),
+    };
+});
+<% } else if (database === 'None') { _%>
+// No external dependencies to mock for None DB
+<% } else { _%>
+import { Model } from 'sequelize';
+
+jest.mock('sequelize', () => {
+    const mDataTypes = {
+        INTEGER: 'INTEGER',
+        STRING: 'STRING',
+    };
+    const mModel = class {
+        static init = jest.fn();
+        static findAll = jest.fn();
+        static create = jest.fn();
+    };
+    return { DataTypes: mDataTypes, Model: mModel };
+});
+
+<% if (architecture === 'MVC') { _%>
+jest.mock('@/config/database', () => ({}));
+<% } else { _%>
+jest.mock('@/infrastructure/database/database', () => ({}));
+<% } _%>
+<% } _%>
+
+describe('User Model', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should be defined and initialized', () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>').default;
+        expect(User).toBeDefined();
+        <% if (database === 'MongoDB') { %>
+        expect(mongoose.model).toHaveBeenCalled();
+        <% } else if (database === 'None') { %>
+        // Test mockData is initialized
+        expect(User.mockData).toEqual([]);
+        <% } else { %>
+        // Sequelize init is called on the class
+        expect(Model.init).toHaveBeenCalled();
+        <% } %>
+    });
+
+    it('should handle model operations', async () => {
+        const User = require('<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>').default;
+        const data = { name: 'Test', email: 'test@example.com' };
+
+        <% if (database === 'MongoDB') { %>
+        (User.create as jest.Mock).mockResolvedValue({ id: '1', ...data });
+        (User.find as jest.Mock).mockResolvedValue([{ id: '1', ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        <% } else if (database === 'None') { %>
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.find()).toBeDefined();
+        expect(await User.findAll()).toBeDefined();
+        <% } else { %>
+        (User.create as jest.Mock).mockResolvedValue({ id: 1, ...data });
+        (User.findAll as jest.Mock).mockResolvedValue([{ id: 1, ...data }]);
+        
+        const user = await User.create(data);
+        expect(user.name).toBe(data.name);
+        expect(await User.findAll()).toBeDefined();
+        <% } %>
+    });
+});

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

@@ -1,3 +1,28 @@
+<% if (database === 'None') { -%>
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+export default class UserModel {
+  static mockData: User[] = [];
+
+  static async find() {
+    return this.mockData;
+  }
+
+  static async findAll() {
+    return this.mockData;
+  }
+
+  static async create(data: Omit<User, 'id'>) {
+    const newUser = { id: String(this.mockData.length + 1), ...data };
+    this.mockData.push(newUser);
+    return newUser as User;
+  }
+}
+<% } else { -%>
 import { DataTypes, Model } from 'sequelize';
 <% if (architecture === 'MVC') { %>import sequelize from '@/config/database';<% } else { %>import sequelize from '@/infrastructure/database/database';<% } %>
 
@@ -32,3 +57,4 @@ User.init(
 );
 
 export default User;
+<% } -%>