nodejs-quickstart-structure 1.18.1 → 1.19.0

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