nodejs-structure-cli 1.0.0

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

@@ -0,0 +1,75 @@
+const Redis = require('ioredis');
+require('dotenv').config();
+const logger = require('<%- loggerPath %>');
+
+class RedisService {
+    constructor() {
+        this.client = new Redis({
+            host: process.env.REDIS_HOST || 'localhost',
+            port: Number(process.env.REDIS_PORT) || 6379,
+            password: process.env.REDIS_PASSWORD || undefined,
+            retryStrategy: (times) => Math.min(times * 50, 2000),
+        });
+
+        this.client.on('connect', () => {
+            logger.info('Redis connected');
+        });
+
+        this.client.on('error', (err) => {
+            logger.error('Redis error:', err);
+        });
+    }
+
+    static getInstance() {
+        if (!RedisService.instance) {
+            RedisService.instance = new RedisService();
+        }
+        return RedisService.instance;
+    }
+
+    async get(key) {
+        try {
+            const data = await this.client.get(key);
+            return data ? JSON.parse(data) : null;
+        } catch (error) {
+            logger.error(`Redis get error for key ${key}:`, error);
+            return null;
+        }
+    }
+
+    async set(key, value, ttl) {
+        try {
+            const data = JSON.stringify(value);
+            if (ttl) {
+                await this.client.set(key, data, 'EX', ttl);
+            } else {
+                await this.client.set(key, data);
+            }
+        } catch (error) {
+            logger.error(`Redis set error for key ${key}:`, error);
+        }
+    }
+
+    async del(key) {
+        try {
+            await this.client.del(key);
+        } catch (error) {
+            logger.error(`Redis del error for key ${key}:`, error);
+        }
+    }
+
+    async getOrSet(key, fetcher, ttl = 3600) {
+        const cached = await this.get(key);
+        if (cached) return cached;
+
+        const data = await fetcher();
+        if (data) await this.set(key, data, ttl);
+        return data;
+    }
+
+    async quit() {
+        return await this.client.quit();
+    }
+}
+
+module.exports = RedisService.getInstance();

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

@@ -0,0 +1,147 @@
+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 Service', () => {
+    let RedisService;
+    let logger;
+
+    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('<%= redisClientPath %>');
+    });
+
+    it('should handle redis events', () => {
+        // Find the event handlers
+        const handlers = {};
+        RedisService.client.on.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/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/memoryCache.ts.ejs

@@ -0,0 +1,73 @@
+import NodeCache from 'node-cache';
+import logger from '<%- loggerPath %>';
+
+class MemoryCacheService {
+    private cache: NodeCache;
+    private static instance: MemoryCacheService;
+
+    private constructor() {
+        // Default TTL of 0 (unlimited), check period of 120s
+        this.cache = new NodeCache({ stdTTL: 0, checkperiod: 120 });
+        logger.info('Memory Cache initialized');
+    }
+
+    public static getInstance(): MemoryCacheService {
+        if (!MemoryCacheService.instance) {
+            MemoryCacheService.instance = new MemoryCacheService();
+        }
+        return MemoryCacheService.instance;
+    }
+
+    public async get<T>(key: string): Promise<T | null> {
+        try {
+            const data = this.cache.get<T>(key);
+            // Simulating un-parsed data similar to Redis for consistency
+            if (data === undefined) return null;
+            return typeof data === 'string' ? JSON.parse(data) : data;
+        } catch (error) {
+            logger.error(`Memory Cache get error for key ${key}:`, error);
+            return null;
+        }
+    }
+
+    public async set(key: string, value: unknown, ttl?: number): Promise<void> {
+        try {
+            const data = JSON.stringify(value);
+            if (ttl) {
+                this.cache.set(key, data, ttl);
+            } else {
+                this.cache.set(key, data);
+            }
+        } catch (error) {
+            logger.error(`Memory Cache set error for key ${key}:`, error);
+        }
+    }
+
+    public async del(key: string): Promise<void> {
+        try {
+            this.cache.del(key);
+        } catch (error) {
+            logger.error(`Memory Cache del error for key ${key}:`, error);
+        }
+    }
+
+    public async flush(): Promise<void> {
+        try {
+            this.cache.flushAll();
+            logger.info('Memory Cache flushed');
+        } catch (error) {
+            logger.error('Memory Cache flush error:', error);
+        }
+    }
+
+    public async getOrSet<T>(key: string, fetcher: () => Promise<T>, ttl: number = 3600): Promise<T> {
+        const cached = await this.get<T>(key);
+        if (cached) return cached;
+
+        const data = await fetcher();
+        if (data) await this.set(key, data, ttl);
+        return data;
+    }
+}
+
+export default MemoryCacheService.getInstance();

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

@@ -0,0 +1,89 @@
+import Redis from 'ioredis';
+import dotenv from 'dotenv';
+import logger from '<%- loggerPath %>';
+
+dotenv.config();
+
+class RedisService {
+    private client: Redis;
+    private static instance: RedisService;
+
+    private constructor() {
+        this.client = new Redis({
+            host: process.env.REDIS_HOST || 'localhost',
+            port: Number(process.env.REDIS_PORT) || 6379,
+            password: process.env.REDIS_PASSWORD || undefined,
+            retryStrategy: (times) => Math.min(times * 50, 2000),
+        });
+
+        this.client.on('connect', () => {
+            logger.info('Redis connected');
+        });
+
+        this.client.on('error', (err) => {
+            logger.error('Redis error:', err);
+        });
+    }
+
+    public static getInstance(): RedisService {
+        if (!RedisService.instance) {
+            RedisService.instance = new RedisService();
+        }
+        return RedisService.instance;
+    }
+
+    public async get<T>(key: string): Promise<T | null> {
+        try {
+            const data = await this.client.get(key);
+            return data ? JSON.parse(data) : null;
+        } catch (error) {
+            logger.error(`Redis get error for key ${key}:`, error);
+            return null;
+        }
+    }
+
+    public async set(key: string, value: unknown, ttl?: number): Promise<void> {
+        try {
+            const data = JSON.stringify(value);
+            if (ttl) {
+                await this.client.set(key, data, 'EX', ttl);
+            } else {
+                await this.client.set(key, data);
+            }
+        } catch (error) {
+            logger.error(`Redis set error for key ${key}:`, error);
+        }
+    }
+
+    public async del(key: string): Promise<void> {
+        try {
+            await this.client.del(key);
+        } catch (error) {
+            logger.error(`Redis del error for key ${key}:`, error);
+        }
+    }
+
+    public async flush(): Promise<void> {
+        try {
+            await this.client.flushall();
+            logger.info('Redis flushed');
+        } catch (error) {
+            logger.error('Redis flush error:', error);
+        }
+    }
+
+    public async getOrSet<T>(key: string, fetcher: () => Promise<T>, ttl: number = 3600): Promise<T> {
+        const cached = await this.get<T>(key);
+        if (cached) return cached;
+
+        const data = await fetcher();
+        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.js.ejs

@@ -0,0 +1,19 @@
+const { Sequelize } = require('sequelize');
+require('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<% } %>')
+  }
+);
+
+module.exports = sequelize;