nodejs-quickstart-structure 1.18.1 → 1.19.0

package/templates/common/caching/clean/js/UpdateUser.js.ejs

@@ -0,0 +1,27 @@
+<%_ if (caching === 'Redis') { -%>
+const cacheService = require('../infrastructure/caching/redisClient');
+<%_ } else if (caching === 'Memory Cache') { -%>
+const cacheService = require('../infrastructure/caching/memoryCache');
+<%_ } -%>
+const logger = require('../infrastructure/log/logger');
+
+class UpdateUser {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute(id, data) {
+        const updatedUser = await this.userRepository.update(id, data);
+
+        try {
+            await cacheService.del('users:all');
+            logger.info('Invalidated users:all cache');
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }
+
+        return updatedUser;
+    }
+}
+
+module.exports = UpdateUser;

package/templates/common/caching/clean/ts/deleteUser.ts.ejs

@@ -0,0 +1,24 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching === 'Redis') { -%>
+import cacheService from '@/infrastructure/caching/redisClient';
+<%_ } else if (caching === 'Memory Cache') { -%>
+import cacheService from '@/infrastructure/caching/memoryCache';
+<%_ } -%>
+import logger from '@/infrastructure/log/logger';
+
+export default class DeleteUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string) {
+        const result = await this.userRepository.delete(id);
+
+        try {
+            await cacheService.del('users:all');
+            logger.info('Invalidated users:all cache');
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }
+
+        return result;
+    }
+}

package/templates/common/caching/clean/ts/updateUser.ts.ejs

@@ -0,0 +1,25 @@
+import { User } from '@/domain/user';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+<%_ if (caching === 'Redis') { -%>
+import cacheService from '@/infrastructure/caching/redisClient';
+<%_ } else if (caching === 'Memory Cache') { -%>
+import cacheService from '@/infrastructure/caching/memoryCache';
+<%_ } -%>
+import logger from '@/infrastructure/log/logger';
+
+export default class UpdateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: number | string, data: { name?: string, email?: string }) {
+        const updatedUser = await this.userRepository.update(id, data);
+
+        try {
+            await cacheService.del('users:all');
+            logger.info('Invalidated users:all cache');
+        } catch (error) {
+            logger.error('Cache error (del):', error);
+        }
+
+        return updatedUser;
+    }
+}

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

@@ -1,64 +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 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();
+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.ts.ejs

@@ -1,80 +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 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();
+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/models/User.js.ejs

@@ -1,53 +1,79 @@
-<% if (database === 'None') { -%>
-class UserModel {
-  static mockData = [];
-
-  static async find() {
-    return this.mockData;
-  }
-
-  static async findAll() {
-    return this.mockData;
-  }
-
-  static async create(data) {
-    const { id, ...rest } = data;
-    const newUser = { id: String(this.mockData.length + 1), ...rest };
-    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');<% } %>
-
-class User extends Model {}
-
-User.init(
-  {
-    id: {
-      type: DataTypes.INTEGER,
-      autoIncrement: true,
-      primaryKey: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    email: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      unique: true,
-    },
-  },
-  {
-    sequelize,
-    tableName: 'users',
-    underscored: true,
-  }
-);
-
-module.exports = User;
-<% } -%>
+<% if (database === 'None') { -%>
+class UserModel {
+  static mockData = [];
+
+  static async find() {
+    return this.mockData;
+  }
+
+  static async findAll() {
+    return this.mockData;
+  }
+
+  static async create(data) {
+    const { id, ...rest } = data;
+    const newUser = { id: String(this.mockData.length + 1), ...rest };
+    this.mockData.push(newUser);
+    return newUser;
+  }
+
+  static async findByPk(id) {
+    return this.mockData.find((u) => u.id === String(id));
+  }
+
+  static async update(id, data) {
+    const user = await this.findByPk(id);
+    if (user) {
+      Object.assign(user, data);
+    }
+    return user;
+  }
+
+  static async destroy(id) {
+    const index = this.mockData.findIndex((u) => u.id === String(id));
+    if (index !== -1) {
+      this.mockData.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+}
+
+module.exports = UserModel;
+<% } else { -%>
+const { DataTypes, Model } = require('sequelize');
+<% if (architecture === 'MVC') { %>const sequelize = require('../config/database');<% } else { %>const sequelize = require('../database');<% } %>
+
+class User extends Model {}
+
+User.init(
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    email: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+    deletedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+    },
+  },
+  {
+    sequelize,
+    tableName: 'users',
+    underscored: true,
+    paranoid: true,
+  }
+);
+
+module.exports = User;
+<% } -%>

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

@@ -1,19 +1,23 @@
-const mongoose = require('mongoose');
-
-const UserSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required: true
-    },
-    email: {
-        type: String,
-        required: true,
-        unique: true
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now
-    }
-});
-
-module.exports = mongoose.model('User', UserSchema);
+const mongoose = require('mongoose');
+
+const UserSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    },
+    deletedAt: {
+        type: Date,
+        default: null
+    }
+});
+
+module.exports = mongoose.model('User', UserSchema);