nodejs-quickstart-structure 1.18.1 → 1.19.1

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);

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

@@ -1,84 +1,94 @@
-<% 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();
-        <% } %>
-    });
-});
+<% 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();
+        
+        const found = await User.findByPk(user.id);
+        expect(found.id).toBe(user.id);
+        
+        const updated = await User.update(user.id, { name: 'New Name' });
+        expect(updated.name).toBe('New Name');
+        
+        const deleted = await User.destroy(user.id);
+        expect(deleted).toBe(true);
+        expect(await User.findByPk(user.id)).toBeUndefined();
+        <% } 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.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;