farheen-psql 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "farheen-psql",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "main": "server.js",
   "scripts": {
@@ -28,4 +28,4 @@
   "devDependencies": {
     "nodemon": "^3.1.14"
   }
-}
+}

package/src/constants/modules.js

@@ -1,4 +1,7 @@
 export const MODULES = {
   USERS: 'USERS',
+  ROLES: 'ROLES',
+  PERMISSIONS: 'PERMISSIONS',
   POSTS: 'POSTS', // Example for future
+  COMMENTS: 'COMMENTS',
 };

package/src/controllers/commentController.js

@@ -0,0 +1,61 @@
+import * as commentService from '../services/commentService.js';
+
+export const createComment = async (req, res) => {
+  try {
+    const { content, post_id, parent_id } = req.body;
+    const user_id = req.user.id;
+
+    if (!content || !post_id) {
+      return res.status(400).json({ error: 'Content and post_id are required' });
+    }
+
+    const commentData = {
+      content,
+      user_id,
+      post_id,
+      parent_id: parent_id || null
+    };
+
+    const newComment = await commentService.createComment(commentData);
+    res.status(201).json({ message: 'Comment created successfully', comment: newComment });
+  } catch (error) {
+    console.error('Error creating comment:', error);
+    if (error.message === 'Parent comment not found' || error.message === 'Parent comment does not belong to the specified post') {
+      return res.status(400).json({ error: error.message });
+    }
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const updateComment = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { content } = req.body;
+    
+    const updatedComment = await commentService.updateComment(id, { content });
+    if (!updatedComment) {
+      return res.status(404).json({ error: 'Comment not found' });
+    }
+    
+    res.status(200).json({ message: 'Comment updated successfully', comment: updatedComment });
+  } catch (error) {
+    console.error('Error updating comment:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const deleteComment = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    const deletedComment = await commentService.deleteComment(id);
+    if (!deletedComment) {
+      return res.status(404).json({ error: 'Comment not found' });
+    }
+    
+    res.status(200).json({ message: 'Comment deleted successfully', comment: deletedComment });
+  } catch (error) {
+    console.error('Error deleting comment:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};

package/src/controllers/permissionController.js

@@ -26,11 +26,11 @@ export const getPermissionById = async (req, res) => {
 
 export const createPermission = async (req, res) => {
   try {
-    const { module, action } = req.body;
-    if (!module || !action) {
-      return res.status(400).json({ error: 'module and action are required' });
+    const { name, module, action } = req.body;
+    if (!name || !module || !action) {
+      return res.status(400).json({ error: 'name, module and action are required' });
     }
-    const newPermission = await permissionService.createPermission({ module, action });
+    const newPermission = await permissionService.createPermission({ name, module, action });
     res.status(201).json(newPermission);
   } catch (error) {
     console.error('Error creating permission:', error);
@@ -41,9 +41,9 @@ export const createPermission = async (req, res) => {
 export const updatePermission = async (req, res) => {
   try {
     const { id } = req.params;
-    const { module, action } = req.body;
+    const { name, module, action } = req.body;
     
-    const updatedPermission = await permissionService.updatePermission(id, { module, action });
+    const updatedPermission = await permissionService.updatePermission(id, { name, module, action });
     if (!updatedPermission) {
       return res.status(404).json({ error: 'Permission not found' });
     }

package/src/controllers/postController.js

@@ -0,0 +1,80 @@
+import * as postService from '../services/postService.js';
+
+export const createPost = async (req, res) => {
+  try {
+    const { content } = req.body;
+    // Assume user is authenticated and req.user exists from authMiddleware
+    const user_id = req.user.id;
+
+    if (!content) {
+      return res.status(400).json({ error: 'Content is required' });
+    }
+
+    const newPost = await postService.createPost({ content, user_id });
+    res.status(201).json({ message: 'Post created successfully', post: newPost });
+  } catch (error) {
+    console.error('Error creating post:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const getAllPosts = async (req, res) => {
+  try {
+    const posts = await postService.getAllPosts();
+    res.status(200).json(posts);
+  } catch (error) {
+    console.error('Error fetching posts:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const getPostById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const post = await postService.getPostById(id);
+    
+    if (!post) {
+      return res.status(404).json({ error: 'Post not found' });
+    }
+    
+    res.status(200).json(post);
+  } catch (error) {
+    console.error('Error fetching post:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const updatePost = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { content } = req.body;
+    
+    // In a real app, you should check if req.user.id matches post.user_id before updating!
+    const updatedPost = await postService.updatePost(id, { content });
+    if (!updatedPost) {
+      return res.status(404).json({ error: 'Post not found' });
+    }
+    
+    res.status(200).json({ message: 'Post updated successfully', post: updatedPost });
+  } catch (error) {
+    console.error('Error updating post:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const deletePost = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    // Check if the user is the author or an admin
+    const deletedPost = await postService.deletePost(id);
+    if (!deletedPost) {
+      return res.status(404).json({ error: 'Post not found' });
+    }
+    
+    res.status(200).json({ message: 'Post deleted successfully', post: deletedPost });
+  } catch (error) {
+    console.error('Error deleting post:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};

package/src/controllers/userController.js

@@ -26,12 +26,12 @@ export const getUserById = async (req, res) => {
 
 export const createUser = async (req, res) => {
   try {
-    const { name, email, age } = req.body;
+    const { name, email, age, role_id } = req.body;
     if (!name || !email) {
       return res.status(400).json({ error: 'Name and email are required' });
     }
-    const newUser = await userService.createUser({ name, email, age });
-    res.status(201).json(newUser);
+    const newUser = await userService.createUser({ name, email, age, role_id });
+    res.status(201).json({ message: 'User created successfully', user: newUser });
   } catch (error) {
     console.error('Error creating user:', error);
     // Handle specific service errors
@@ -45,13 +45,13 @@ export const createUser = async (req, res) => {
 export const updateUser = async (req, res) => {
   try {
     const { id } = req.params;
-    const { name, email, age } = req.body;
-    
-    const updatedUser = await userService.updateUser(id, { name, email, age });
+    const { name, email, age, role_id } = req.body;
+
+    const updatedUser = await userService.updateUser(id, { name, email, age, role_id });
     if (!updatedUser) {
       return res.status(404).json({ error: 'User not found' });
     }
-    res.status(200).json(updatedUser);
+    res.status(200).json({ message: 'User updated successfully', user: updatedUser });
   } catch (error) {
     console.error('Error updating user:', error);
     if (error.message === 'Age cannot be negative') {

package/src/models/Comment.js

@@ -0,0 +1,28 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/db.js';
+
+const Comment = sequelize.define('Comment', {
+  content: {
+    type: DataTypes.TEXT,
+    allowNull: false,
+  },
+  user_id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  post_id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+  parent_id: {
+    type: DataTypes.INTEGER,
+    allowNull: true, // Null for top-level comments, populated for replies
+  }
+}, {
+  tableName: 'comments',
+  timestamps: true,
+  createdAt: 'created_at',
+  updatedAt: 'updated_at',
+});
+
+export default Comment;

package/src/models/Permission.js

@@ -3,25 +3,30 @@ import sequelize from '../config/db.js';
 
 // This is exactly like mongoose.Schema({ ... })
 const Permission = sequelize.define('Permission', {
+  name: {
+    type: DataTypes.STRING(100),
+    allowNull: false,
+  },
   module: {
     type: DataTypes.STRING(50),
     allowNull: false,
   },
   action: {
-    type: DataTypes.STRING(50),
+    type: DataTypes.ARRAY(DataTypes.STRING),
     allowNull: false,
+    defaultValue: []
   }
 }, {
   tableName: 'permissions',
   timestamps: true,
   createdAt: 'created_at',
   updatedAt: false,
-  indexes: [
-    {
-      unique: true,
-      fields: ['module', 'action']
-    }
-  ]
+  // indexes: [
+  //   {
+  //     unique: true,
+  //     fields: ['module', 'action']
+  //   }
+  // ]
 });
 
 export default Permission;

package/src/models/Post.js

@@ -0,0 +1,20 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/db.js';
+
+const Post = sequelize.define('Post', {
+  content: {
+    type: DataTypes.TEXT,
+    allowNull: false,
+  },
+  user_id: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  }
+}, {
+  tableName: 'posts',
+  timestamps: true,
+  createdAt: 'created_at',
+  updatedAt: 'updated_at',
+});
+
+export default Post;

package/src/models/index.js

@@ -1,6 +1,8 @@
 import User from './User.js';
 import Role from './Role.js';
 import Permission from './Permission.js';
+import Post from './Post.js';
+import Comment from './Comment.js';
 
 // ---------------------------------------------------------
 // RELATIONSHIPS
@@ -25,5 +27,21 @@ Permission.belongsToMany(Role, {
   timestamps: false 
 });
 
+// User and Post
+User.hasMany(Post, { foreignKey: 'user_id' });
+Post.belongsTo(User, { foreignKey: 'user_id' });
+
+// User and Comment
+User.hasMany(Comment, { foreignKey: 'user_id' });
+Comment.belongsTo(User, { foreignKey: 'user_id' });
+
+// Post and Comment
+Post.hasMany(Comment, { foreignKey: 'post_id' });
+Comment.belongsTo(Post, { foreignKey: 'post_id' });
+
+// Comment Replies (Self-referencing)
+Comment.hasMany(Comment, { as: 'Replies', foreignKey: 'parent_id' });
+Comment.belongsTo(Comment, { as: 'Parent', foreignKey: 'parent_id' });
+
 // Export all models so they can be imported together from this file
-export { User, Role, Permission };
+export { User, Role, Permission, Post, Comment };

package/src/repositories/commentRepository.js

@@ -0,0 +1,22 @@
+import { Comment } from '../models/index.js';
+
+export const create = async (commentData) => {
+  return await Comment.create(commentData);
+};
+
+export const findById = async (id) => {
+  return await Comment.findByPk(id);
+};
+
+export const update = async (id, commentData) => {
+  const comment = await Comment.findByPk(id);
+  if (!comment) return null;
+  return await comment.update(commentData);
+};
+
+export const remove = async (id) => {
+  const comment = await Comment.findByPk(id);
+  if (!comment) return null;
+  await comment.destroy();
+  return comment;
+};

package/src/repositories/postRepository.js

@@ -0,0 +1,54 @@
+import { Post, Comment, User } from '../models/index.js';
+
+export const create = async (postData) => {
+  return await Post.create(postData);
+};
+
+export const findAll = async () => {
+  return await Post.findAll({
+    order: [['created_at', 'DESC']],
+    include: [
+      {
+        model: User,
+        attributes: ['id', 'name', 'email'] // Don't send passwords!
+      }
+    ]
+  });
+};
+
+export const findByIdWithComments = async (id) => {
+  return await Post.findByPk(id, {
+    include: [
+      {
+        model: User,
+        attributes: ['id', 'name', 'email']
+      },
+      {
+        model: Comment,
+        attributes: ['id', 'content', 'parent_id'],
+        // Include the author of the comment
+        include: [
+          {
+            model: User,
+            attributes: ['id', 'name', 'email']
+          }
+        ],
+        // Order comments by creation time
+        order: [['created_at', 'ASC']]
+      }
+    ]
+  });
+};
+
+export const update = async (id, postData) => {
+  const post = await Post.findByPk(id);
+  if (!post) return null;
+  return await post.update(postData);
+};
+
+export const remove = async (id) => {
+  const post = await Post.findByPk(id);
+  if (!post) return null;
+  await post.destroy();
+  return post;
+};

package/src/repositories/userRepository.js

@@ -1,7 +1,7 @@
 import { User } from '../models/index.js';
 
 export const findAll = async () => {
-  return await User.findAll({ 
+  return await User.findAll({
     order: [['created_at', 'DESC']],
     attributes: { exclude: ['password'] }
   });
@@ -19,7 +19,7 @@ export const findByEmail = async (email) => {
 
 export const create = async (userData) => {
   const user = await User.create(userData);
-  const userObj = user.toJSON();
+  const userObj = user;
   delete userObj.password;
   return userObj;
 };
@@ -27,9 +27,9 @@ export const create = async (userData) => {
 export const update = async (id, userData) => {
   const user = await User.findByPk(id);
   if (!user) return null;
-  
+
   await user.update(userData);
-  
+
   const userObj = user.toJSON();
   delete userObj.password;
   return userObj;
@@ -38,9 +38,9 @@ export const update = async (id, userData) => {
 export const remove = async (id) => {
   const user = await User.findByPk(id);
   if (!user) return null;
-  
+
   await user.destroy();
-  
+
   const userObj = user.toJSON();
   delete userObj.password;
   return userObj;

package/src/routes/commentRoutes.js

@@ -0,0 +1,14 @@
+import express from 'express';
+import * as commentController from '../controllers/commentController.js';
+import { authMiddleware } from '../middlewares/authMiddleware.js';
+
+const router = express.Router();
+
+// Apply authMiddleware to all comment routes
+router.use(authMiddleware);
+
+router.post('/', commentController.createComment);
+router.put('/:id', commentController.updateComment);
+router.delete('/:id', commentController.deleteComment);
+
+export default router;

package/src/routes/postRoutes.js

@@ -0,0 +1,25 @@
+import express from 'express';
+import * as postController from '../controllers/postController.js';
+import { authMiddleware } from '../middlewares/authMiddleware.js';
+import { authorizeMiddleware } from '../middlewares/authorizeMiddleware.js';
+import { MODULES } from '../constants/modules.js';
+import { ACTIONS } from '../constants/actions.js';
+
+const router = express.Router();
+
+// Apply authMiddleware to all post routes
+router.use(authMiddleware);
+
+// If you want to require specific permissions to view/create posts, use authorizeMiddleware.
+// For now, we will allow any authenticated user to create a post and read posts.
+// If you uncomment these, you will need to assign POSTS permissions to the users/roles.
+// router.post('/', authorizeMiddleware(MODULES.POSTS, ACTIONS.CREATE), postController.createPost);
+// router.get('/', authorizeMiddleware(MODULES.POSTS, ACTIONS.READ), postController.getAllPosts);
+
+router.post('/', postController.createPost);
+router.get('/', postController.getAllPosts);
+router.get('/:id', postController.getPostById);
+router.put('/:id', postController.updatePost);
+router.delete('/:id', postController.deletePost);
+
+export default router;

package/src/routes/routes.js

@@ -3,6 +3,8 @@ import authRoutes from './authRoutes.js';
 import userRoutes from './userRoutes.js';
 import roleRoutes from './roleRoutes.js';
 import permissionRoutes from './permissionRoutes.js';
+import postRoutes from './postRoutes.js';
+import commentRoutes from './commentRoutes.js';
 
 const router = express.Router();
 
@@ -10,5 +12,7 @@ router.use('/auth', authRoutes);
 router.use('/user', userRoutes);
 router.use('/roles', roleRoutes);
 router.use('/permissions', permissionRoutes);
+router.use('/posts', postRoutes);
+router.use('/comments', commentRoutes);
 
 export default router;

package/src/services/authService.js

@@ -51,7 +51,16 @@ export const login = async (email, password) => {
   const permissions = await roleRepository.getRolePermissions(user.role_id);
   
   // Format permissions into an array of string identifiers (e.g. ['USERS:READ'])
-  const permissionStrings = permissions.map(p => `${p.module}:${p.action}`);
+  const permissionStrings = [];
+  permissions.forEach(p => {
+    if (Array.isArray(p.action)) {
+      p.action.forEach(act => {
+        permissionStrings.push(`${p.module}:${act}`);
+      });
+    } else if (p.action) {
+      permissionStrings.push(`${p.module}:${p.action}`);
+    }
+  });
 
   const token = jwt.sign(
     { 

package/src/services/commentService.js

@@ -0,0 +1,24 @@
+import * as commentRepository from '../repositories/commentRepository.js';
+
+export const createComment = async (commentData) => {
+  // If this is a reply, we could verify the parent comment exists and belongs to the same post
+  if (commentData.parent_id) {
+    const parentComment = await commentRepository.findById(commentData.parent_id);
+    if (!parentComment) {
+      throw new Error('Parent comment not found');
+    }
+    if (parentComment.post_id !== commentData.post_id) {
+      throw new Error('Parent comment does not belong to the specified post');
+    }
+  }
+
+  return await commentRepository.create(commentData);
+};
+
+export const updateComment = async (id, commentData) => {
+  return await commentRepository.update(id, commentData);
+};
+
+export const deleteComment = async (id) => {
+  return await commentRepository.remove(id);
+};

package/src/services/postService.js

@@ -0,0 +1,64 @@
+import * as postRepository from '../repositories/postRepository.js';
+
+export const createPost = async (postData) => {
+  return await postRepository.create(postData);
+};
+
+export const getAllPosts = async () => {
+  return await postRepository.findAll();
+};
+
+export const getPostById = async (id) => {
+  const post = await postRepository.findByIdWithComments(id);
+  
+  if (!post) return null;
+
+  // Convert Sequelize model to plain JSON object so we can manipulate it easily
+  const postJson = post.toJSON();
+
+  // The comments are currently a flat array attached to the post.
+  // We need to build a nested tree structure out of it.
+  postJson.Comments = buildCommentTree(postJson.Comments || []);
+
+  return postJson;
+};
+
+export const updatePost = async (id, postData) => {
+  return await postRepository.update(id, postData);
+};
+
+export const deletePost = async (id) => {
+  return await postRepository.remove(id);
+};
+
+// Helper function to turn flat comments array into a nested tree structure
+function buildCommentTree(comments) {
+  const commentMap = {};
+  const rootComments = [];
+
+  // First pass: put all comments in a map by their ID
+  comments.forEach(comment => {
+    // Initialize Replies array
+    comment.Replies = [];
+    commentMap[comment.id] = comment;
+  });
+
+  // Second pass: attach comments to their parent or push to root array
+  comments.forEach(comment => {
+    if (comment.parent_id) {
+      // It's a reply! Attach to parent.
+      // Make sure the parent actually exists in the map (it should, unless deleted/orphaned)
+      if (commentMap[comment.parent_id]) {
+        commentMap[comment.parent_id].Replies.push(comment);
+      } else {
+        // Parent doesn't exist, maybe deleted? Treat as top level or ignore.
+        rootComments.push(comment);
+      }
+    } else {
+      // It's a top-level comment
+      rootComments.push(comment);
+    }
+  });
+
+  return rootComments;
+}