nodejs-quickstart-structure 1.18.1 → 1.19.1

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

@@ -1,60 +1,60 @@
-const NodeCache = require('node-cache');
-const logger = require('<%- loggerPath %>');
-
-class MemoryCacheService {
-    constructor() {
-        // Default TTL of 0 (unlimited), check period of 120s
-        this.cache = new NodeCache({ stdTTL: 0, checkperiod: 120 });
-        logger.info('Memory Cache initialized');
-    }
-
-    static getInstance() {
-        if (!MemoryCacheService.instance) {
-            MemoryCacheService.instance = new MemoryCacheService();
-        }
-        return MemoryCacheService.instance;
-    }
-
-    async get(key) {
-        try {
-            const data = this.cache.get(key);
-            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;
-        }
-    }
-
-    async set(key, value, ttl) {
-        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);
-        }
-    }
-
-    async del(key) {
-        try {
-            this.cache.del(key);
-        } catch (error) {
-            logger.error(`Memory Cache 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;
-    }
-}
-
-module.exports = MemoryCacheService.getInstance();
+const NodeCache = require('node-cache');
+const logger = require('<%- loggerPath %>');
+
+class MemoryCacheService {
+    constructor() {
+        // Default TTL of 0 (unlimited), check period of 120s
+        this.cache = new NodeCache({ stdTTL: 0, checkperiod: 120 });
+        logger.info('Memory Cache initialized');
+    }
+
+    static getInstance() {
+        if (!MemoryCacheService.instance) {
+            MemoryCacheService.instance = new MemoryCacheService();
+        }
+        return MemoryCacheService.instance;
+    }
+
+    async get(key) {
+        try {
+            const data = this.cache.get(key);
+            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;
+        }
+    }
+
+    async set(key, value, ttl) {
+        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);
+        }
+    }
+
+    async del(key) {
+        try {
+            this.cache.del(key);
+        } catch (error) {
+            logger.error(`Memory Cache 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;
+    }
+}
+
+module.exports = MemoryCacheService.getInstance();

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

@@ -1,101 +1,101 @@
-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;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.resetModules();
-        memoryCacheService = require('<% if (architecture === "MVC") { %>@/config/memoryCache<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
-    });
-
-    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');
-    });
-
-    it('should handle errors in del', async () => {
-        memoryCacheService.cache.del.mockImplementation(() => { throw new Error('Cache Error'); });
-        await memoryCacheService.del('test-key');
-    });
-
-    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();
-        // Result should be cached
-        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();
-    });
-});
+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;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetModules();
+        memoryCacheService = require('<% if (architecture === "MVC") { %>@/config/memoryCache<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+    });
+
+    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');
+    });
+
+    it('should handle errors in del', async () => {
+        memoryCacheService.cache.del.mockImplementation(() => { throw new Error('Cache Error'); });
+        await memoryCacheService.del('test-key');
+    });
+
+    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();
+        // Result should be cached
+        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/js/redisClient.js.ejs

@@ -1,75 +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();
+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();