nodejs-structure-cli 1.0.0

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

@@ -0,0 +1,91 @@
+<% 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,
+    },
+<%_ if (auth && auth !== 'None') { _%>
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+<%_ } _%>
+<%_ if (includeMulter) { _%>
+    imageUrl: {
+      type: DataTypes.STRING,
+      allowNull: 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

@@ -0,0 +1,35 @@
+const mongoose = require('mongoose');
+
+const UserSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+<%_ if (auth && auth !== 'None') { _%>
+    password: {
+        type: String,
+        required: true
+    },
+<%_ } _%>
+<%_ if (includeMulter) { _%>
+    imageUrl: {
+        type: String,
+        default: null
+    },
+<%_ } _%>
+    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

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

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

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/database.ts.ejs

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

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

@@ -0,0 +1,100 @@
+<% 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()).toContain(user);
+        expect(await User.findAll()).toContain(user);
+        
+        // findByPk
+        const found = await User.findByPk(user.id);
+        expect(found).toEqual(user);
+        expect(await User.findByPk('invalid')).toBeUndefined();
+        
+        // update
+        const updated = await User.update(user.id, { name: 'Updated' });
+        expect(updated.name).toBe('Updated');
+        expect(await User.update('invalid', {})).toBeUndefined();
+        
+        // destroy
+        const deleted = await User.destroy(user.id);
+        expect(deleted).toBe(true);
+        expect(await User.destroy('invalid')).toBe(false);
+        expect(await User.find()).not.toContain(user);
+        <% } 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

@@ -0,0 +1,102 @@
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  <% if (auth && auth !== 'None') { %>password?: string;<% } %>
+  <% if (includeMulter) { %>imageUrl?: 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'> & { id?: string | number | null }) {
+    const { id: _, ...rest } = data;
+    const newUser: User = { id: String(this.mockData.length + 1), ...rest };
+    this.mockData.push(newUser);
+    return newUser;
+  }
+
+  static async findByPk(id: string | number) {
+    return this.mockData.find((u) => u.id === String(id));
+  }
+
+  static async update(id: string | number, data: Partial<User>) {
+    const user = await this.findByPk(id);
+    if (user) {
+      Object.assign(user, data);
+    }
+    return user;
+  }
+
+  static async destroy(id: string | number) {
+    const index = this.mockData.findIndex((u) => u.id === String(id));
+    if (index !== -1) {
+      this.mockData.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+}
+<% } else { -%>
+import { DataTypes, Model } from 'sequelize';
+<% if (architecture === 'MVC') { %>import sequelize from '@/config/database';<% } else { %>import sequelize from '@/infrastructure/database/database';<% } %>
+
+class User extends Model {
+  public id!: number;
+  public name!: string;
+  public email!: string;
+  <% if (auth && auth !== 'None') { %>public password!: string;<% } %>
+  <% if (includeMulter) { %>public imageUrl!: string;<% } %>
+}
+
+User.init(
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    email: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+    <% if (auth && auth !== 'None') { %>
+    password: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    <% } %>
+    <% if (includeMulter) { %>
+    imageUrl: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    <% } %>
+    deletedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+    },
+  },
+  {
+    sequelize,
+    tableName: 'users',
+    underscored: true,
+    paranoid: true,
+  }
+);
+
+export default User;
+<% } -%>

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

@@ -0,0 +1,34 @@
+import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+    name: string;
+    email: string;
+    <% if (auth && auth !== 'None') { %>password?: string;<% } %>
+    <% if (includeMulter) { %>imageUrl?: string;<% } %>
+    createdAt: Date;
+    deletedAt?: Date | null;
+}
+
+const UserSchema: Schema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    <% if (auth && auth !== 'None') { %>password: { type: String },<% } %>
+    <% if (includeMulter) { %>imageUrl: { type: String },<% } %>
+    createdAt: {
+        type: Date,
+        default: Date.now
+    },
+    deletedAt: {
+        type: Date,
+        default: null
+    }
+});
+
+export default mongoose.model<IUser>('User', UserSchema);