nodejs-quickstart-structure 1.18.1 → 1.19.1

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

@@ -1,84 +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()).toBeDefined();
-        expect(await User.findAll()).toBeDefined();
-        <% } 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();
-        <% } %>
-    });
-});
+<% 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

@@ -1,61 +1,87 @@
-<% if (database === 'None') { -%>
-export interface User {
-  id: string;
-  name: string;
-  email: 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;
-  }
-}
-<% } 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;
-}
-
-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,
-  }
-);
-
-export default User;
-<% } -%>
+<% if (database === 'None') { -%>
+export interface User {
+  id: string;
+  name: string;
+  email: 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;
+}
+
+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,
+  }
+);
+
+export default User;
+<% } -%>

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

@@ -1,25 +1,30 @@
-import mongoose, { Schema, Document } from 'mongoose';
-
-export interface IUser extends Document {
-    name: string;
-    email: string;
-    createdAt: Date;
-}
-
-const UserSchema: Schema = new Schema({
-    name: {
-        type: String,
-        required: true
-    },
-    email: {
-        type: String,
-        required: true,
-        unique: true
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now
-    }
-});
-
-export default mongoose.model<IUser>('User', UserSchema);
+import mongoose, { Schema, Document } from 'mongoose';
+
+export interface IUser extends Document {
+    name: string;
+    email: string;
+    createdAt: Date;
+    deletedAt?: Date | null;
+}
+
+const UserSchema: Schema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    },
+    deletedAt: {
+        type: Date,
+        default: null
+    }
+});
+
+export default mongoose.model<IUser>('User', UserSchema);

package/templates/common/database/ts/mongoose.spec.ts.ejs

@@ -1,42 +1,42 @@
-jest.mock('mongoose', () => ({
-    connect: jest.fn().mockResolvedValue(true),
-}));
-
-const logger = {
-    info: jest.fn(),
-    error: jest.fn(),
-};
-
-jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => logger);
-
-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<% } %>').default;
-        const mongoose = require('mongoose');
-        await connectDB();
-        expect(mongoose.connect).toHaveBeenCalledWith(
-            expect.stringContaining('mongodb://')
-        );
-    });
-
-    it('should handle connection failure and retry', async () => {
-        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
-        const mongoose = require('mongoose');
-        (mongoose.connect as jest.Mock)
-            .mockRejectedValueOnce(new Error('Connection failed'))
-            .mockResolvedValueOnce(true);
-
-        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => { (cb as any)(); return {} as any; });
-        
-        await connectDB();
-        
-        expect(logger.error).toHaveBeenCalled();
-        expect(mongoose.connect).toHaveBeenCalledTimes(2);
-        timeoutSpy.mockRestore();
-    });
-});
+jest.mock('mongoose', () => ({
+    connect: jest.fn().mockResolvedValue(true),
+}));
+
+const logger = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+
+jest.mock('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>', () => logger);
+
+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<% } %>').default;
+        const mongoose = require('mongoose');
+        await connectDB();
+        expect(mongoose.connect).toHaveBeenCalledWith(
+            expect.stringContaining('mongodb://')
+        );
+    });
+
+    it('should handle connection failure and retry', async () => {
+        const connectDB = require('<% if (architecture === "MVC") { %>@/config/database<% } else { %>@/infrastructure/database/database<% } %>').default;
+        const mongoose = require('mongoose');
+        (mongoose.connect as jest.Mock)
+            .mockRejectedValueOnce(new Error('Connection failed'))
+            .mockResolvedValueOnce(true);
+
+        const timeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => { (cb as any)(); return {} as any; });
+        
+        await connectDB();
+        
+        expect(logger.error).toHaveBeenCalled();
+        expect(mongoose.connect).toHaveBeenCalledTimes(2);
+        timeoutSpy.mockRestore();
+    });
+});

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

@@ -1,28 +1,28 @@
-import mongoose from 'mongoose';
-<% if (architecture === 'MVC') { %>
-import logger from '@/utils/logger';
-<% } else { %>
-import logger from '@/infrastructure/log/logger';
-<% } %>
-const connectDB = async (): Promise<void> => {
-    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);
-            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));
-        }
-    }
-};
-
-export default connectDB;
+import mongoose from 'mongoose';
+<% if (architecture === 'MVC') { %>
+import logger from '@/utils/logger';
+<% } else { %>
+import logger from '@/infrastructure/log/logger';
+<% } %>
+const connectDB = async (): Promise<void> => {
+    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);
+            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));
+        }
+    }
+};
+
+export default connectDB;