farheen-psql-app 1.0.0

package/.env

@@ -0,0 +1,8 @@
+PORT=3000
+DB_USER=postgres
+DB_PASSWORD=farheen
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=farheen_db
+
+JWT_SECRET_KEY=mysupersecretkey

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "farheen-psql-app",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node src/server.js",
+    "db:setup": "node script/setupdb.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "cors": "^2.8.6",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3",
+    "node-pg-migrate": "^8.0.4",
+    "pg": "^8.21.0"
+  }
+}

package/src/app.js

@@ -0,0 +1,14 @@
+import express from "express";
+const app = express();
+import indexRoutes from "../src/routes/index.js";
+
+app.use(cors());
+app.use(express.json());
+
+app.use("/api", indexRoutes);
+
+app.use("/", () => {
+    console.log("Health check of the app");
+})
+
+export default app;

package/src/config/db.js

@@ -0,0 +1,15 @@
+import pg from "pg";
+import dotenv from "dotenv";
+
+dotenv.config();
+import { Pool } from "pg";
+
+const pool = new Pool({
+    user: process.env.DB_USER,
+    host: process.env.DB_HOST,
+    database: process.env.DB_NAME,
+    password: process.env.DB_PASSWORD,
+    port: process.env.DB_PORT
+})
+
+export default pool;

package/src/controllers/permissionController.js

@@ -0,0 +1,54 @@
+import { createPermission, deletePermission, getAllPermissions } from "../services/permissionService.js";
+
+export const createPermissionHandler = (req, res) => {
+
+    try {
+
+        const result = await createPermission(req.body);
+
+        return res.status(201).json({
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        return res.status(500).json({
+            success: false,
+            message: error.message
+        });
+    }
+}
+
+export const getAllPermissionsHandler = (req, res) => {
+    try {
+        const result = await getAllPermissions();
+
+        return res.status(200).json({
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        return res.status(500).json({
+            success: false,
+            message: error.message
+        });
+    }
+}
+
+export const deletePermissionHandler = (req, res) => {
+    try {
+        const result = await deletePermission(req.params.id);
+
+        return res.status(200).json({
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        return res.status(500).json({
+            success: false,
+            message: error.message
+        });
+    }
+}

package/src/controllers/roleController.js

@@ -0,0 +1,11 @@
+import { createRoleService, getAllRolesService } from "../services/roleService.js";
+
+export const createRoleHandler = (req, res) => {
+    const result = await createRoleService(req.body);
+    res.status(201).json(result);
+}
+
+export const getAllRoles = (req, res) => {
+    const result = await getAllRolesService();
+    res.status(200).json(result);
+}

package/src/controllers/user.js

@@ -0,0 +1,76 @@
+import * as userService from '../services/userService.js';
+
+export const getAllUsers = async (req, res) => {
+  try {
+    const users = await userService.getAllUsers();
+    res.status(200).json(users);
+  } catch (error) {
+    console.error('Error fetching users:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const getUserById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const user = await userService.getUserById(id);
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    res.status(200).json(user);
+  } catch (error) {
+    console.error('Error fetching user:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const createUser = async (req, res) => {
+  try {
+    const { name, email, age } = 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);
+  } catch (error) {
+    console.error('Error creating user:', error);
+    // Handle specific service errors
+    if (error.message === 'Age cannot be negative') {
+      return res.status(400).json({ error: error.message });
+    }
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+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 });
+    if (!updatedUser) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    res.status(200).json(updatedUser);
+  } catch (error) {
+    console.error('Error updating user:', error);
+    if (error.message === 'Age cannot be negative') {
+      return res.status(400).json({ error: error.message });
+    }
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};
+
+export const deleteUser = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const deletedUser = await userService.deleteUser(id);
+    if (!deletedUser) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+    res.status(200).json({ message: 'User deleted successfully', user: deletedUser });
+  } catch (error) {
+    console.error('Error deleting user:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+};

package/src/database/schemas/permissionSchema.js

@@ -0,0 +1,12 @@
+const permissionTable = `
+CREATE TABLE IF NOT EXISTS permissions (
+    id SERIAL PRIMARY KEY,
+    module VARCHAR(100) NOT NULL,
+    action VARCHAR(100) NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(module, action)
+);
+`;
+
+export default permissionTable;

package/src/database/schemas/rolePermissionSchema.js

@@ -0,0 +1,21 @@
+const rolePermissionTable = `
+CREATE TABLE IF NOT EXISTS role_permissions (
+    id SERIAL PRIMARY KEY,
+
+    role_id INTEGER NOT NULL,
+
+    permission_id INTEGER NOT NULL,
+
+    FOREIGN KEY(role_id)
+        REFERENCES roles(id)
+        ON DELETE CASCADE,
+
+    FOREIGN KEY(permission_id)
+        REFERENCES permissions(id)
+        ON DELETE CASCADE,
+
+    UNIQUE(role_id, permission_id)
+);
+`;
+
+export default rolePermissionTable;

package/src/database/schemas/roleSchema.js

@@ -0,0 +1,12 @@
+const roleTable = `
+CREATE TABLE IF NOT EXISTS roles (
+    id SERIAL PRIMARY KEY,
+    role_name VARCHAR(100) UNIQUE NOT NULL,
+    description TEXT,
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+`;
+
+export default roleTable;

package/src/database/schemas/userSchema.js

@@ -0,0 +1,26 @@
+const userTable = `
+CREATE TABLE IF NOT EXISTS users (
+    id SERIAL PRIMARY KEY,
+
+    first_name VARCHAR(100) NOT NULL,
+
+    last_name VARCHAR(100),
+
+    email VARCHAR(255) UNIQUE NOT NULL,
+
+    password TEXT NOT NULL,
+
+    role_id INTEGER,
+
+    is_active BOOLEAN DEFAULT TRUE,
+
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+
+    FOREIGN KEY(role_id)
+        REFERENCES roles(id)
+);
+`;
+
+export default userTable;

package/src/database/setupdb.js

@@ -0,0 +1,63 @@
+import pg from "pg";
+import dotenv from "dotenv";
+import { Client } from "pg";
+import roleTable from "./schemas/roleSchema";
+import permissionTable from "./schemas/permissionSchema";
+import rolePermissionTable from "./schemas/rolePermissionSchema";
+import userTable from "./schemas/userSchema";
+import pool from "../config/db.js";
+
+dotenv.config();
+
+const tables = [
+    roleTable,
+    permissionTable,
+    rolePermissionTable,
+    userTable
+];
+
+export const setupdb = async () => {
+    const adminclient = new Client({
+        user: process.env.DB_USER,
+        host: process.env.DB_HOST,
+        database: 'postgres',
+        password: process.env.DB_PASSWORD,
+        port: process.env.DB_PORT
+    })
+
+    try {
+        await adminclient.connect();
+        console.log("Connected to admin database");
+
+        const dbName = process.env.DB_NAME;
+        const connectDbResult = await adminclient.query(
+            "SELECT 1 FROM pg_database WHERE datname = $1",
+            [dbName]
+        );
+
+        if (connectDbResult.rowCount === 0) {
+            console.log(`Databse '${dbName}' does not exit. Creating....`);
+            await adminclient.query(`CREATE DATABASE "${dbName}"`);
+            console.log(`Databse '${dbName}' created successfully`);
+        } else {
+            console.log(`Database '${dbName}' already exist.`);
+        }
+
+        try {
+            for (const table of tables) {
+                await pool.query(table);
+            }
+
+            console.log("✅ All tables created");
+
+        } catch (error) {
+            console.error("❌ Setup Error:", error);
+        }
+    } catch (error) {
+        console.error("Error creating/checking database", error);
+    } finally {
+        await adminclient.end();
+    }
+}
+
+// setupdb();

package/src/middleware/authentication.js

@@ -0,0 +1,5 @@
+export const authorization = (module, action) => {
+    async (req, res, next) => {
+        const user = await U
+    }
+}

package/src/middleware/authorization.js

@@ -0,0 +1,17 @@
+import { verifyToken } from "../utils/jwt.js";
+
+export const authentication = async (req, res, next) => {
+    try {
+        const token = req.headers.authorization.split(" ")[1];
+
+        if (!token) {
+            return res.status(403).json({ error: 'Unauthorized: No token provided' });
+        }
+
+        const decoded = verifyToken(token);
+        req.user = decoded;
+        next();
+    } catch (error) {
+        return res.status(401).json({ error: 'Unauthorized: Invalid token' });
+    }
+}

package/src/models/permission.js

@@ -0,0 +1,48 @@
+export const createPermissionQuery = `
+INSERT INTO permissions
+(
+    permission_name,
+    description,
+    created_at
+)
+VALUES
+(
+    $1,
+    $2,
+    NOW()
+)
+RETURNING *;
+`;
+
+export const getPermissionByIdQuery = `
+SELECT *
+FROM permissions
+WHERE id = $1;
+`;
+
+export const getPermissionByNameQuery = `
+SELECT *
+FROM permissions
+WHERE permission_name = $1;
+`;
+
+export const getAllPermissionsQuery = `
+SELECT *
+FROM permissions
+ORDER BY id;
+`;
+
+export const updatePermissionQuery = `
+UPDATE permissions
+SET
+    permission_name = $1,
+    description = $2
+WHERE id = $3
+RETURNING *;
+`;
+
+export const deletePermissionQuery = `
+DELETE FROM permissions
+WHERE id = $1
+RETURNING *;
+`;

package/src/models/role.js

@@ -0,0 +1,48 @@
+export const createRoleQuery = `
+INSERT INTO roles
+(
+    role_name,
+    description,
+    created_at
+)
+VALUES
+(
+    $1,
+    $2,
+    NOW()
+)
+RETURNING *;
+`;
+
+export const getRoleByIdQuery = `
+SELECT *
+FROM roles
+WHERE id = $1;
+`;
+
+export const getRoleByNameQuery = `
+SELECT *
+FROM roles
+WHERE role_name = $1;
+`;
+
+export const getAllRolesQuery = `
+SELECT *
+FROM roles
+ORDER BY id;
+`;
+
+export const updateRoleQuery = `
+UPDATE roles
+SET
+    role_name = $1,
+    description = $2
+WHERE id = $3
+RETURNING *;
+`;
+
+export const deleteRoleQuery = `
+DELETE FROM roles
+WHERE id = $1
+RETURNING *;
+`;

package/src/models/rolePermission.js

@@ -0,0 +1,29 @@
+export const assignPermissionToRoleQuery = `
+INSERT INTO role_permissions
+(
+    role_id,
+    permission_id
+)
+VALUES
+(
+    $1,
+    $2
+)
+RETURNING *;
+`;
+
+export const removePermissionFromRoleQuery = `
+DELETE FROM role_permissions
+WHERE role_id = $1
+AND permission_id = $2;
+`;
+
+export const getRolePermissionsQuery = `
+SELECT
+    p.id,
+    p.permission_name
+FROM role_permissions rp
+INNER JOIN permissions p
+ON rp.permission_id = p.id
+WHERE rp.role_id = $1;
+`;

package/src/models/user.js

@@ -0,0 +1,72 @@
+export const createUserQuery = `
+INSERT INTO users
+(
+    first_name,
+    last_name,
+    email,
+    password,
+    role_id,
+    is_active,
+    created_at,
+    updated_at
+)
+VALUES
+(
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    NOW(),
+    NOW()
+)
+RETURNING *;
+`;
+
+export const getUserByIdQuery = `
+SELECT
+    u.*,
+    r.role_name
+FROM users u
+LEFT JOIN roles r
+ON u.role_id = r.id
+WHERE u.id = $1;
+`;
+
+export const getUserByEmailQuery = `
+SELECT *
+FROM users
+WHERE email = $1;
+`;
+
+export const getAllUsersQuery = `
+SELECT
+    u.id,
+    u.first_name,
+    u.last_name,
+    u.email,
+    u.is_active,
+    r.role_name
+FROM users u
+LEFT JOIN roles r
+ON u.role_id = r.id;
+`;
+
+export const updateUserQuery = `
+UPDATE users
+SET
+    first_name = $1,
+    last_name = $2,
+    email = $3,
+    role_id = $4,
+    updated_at = NOW()
+WHERE id = $5
+RETURNING *;
+`;
+
+export const deleteUserQuery = `
+DELETE FROM users
+WHERE id = $1
+RETURNING *;
+`;

package/src/repositories/permissionRepo.js

@@ -0,0 +1,47 @@
+
+
+import pool from "../config/db.js";
+import { createPermissionQuery, deletePermissionQuery, 
+    getAllPermissionsQuery, getPermissionByIdQuery } from "../models/permission.js";
+
+export const createPermission = (data) => {
+
+    const {
+        module,
+        action,
+        description
+    } = data;
+
+    const result = await pool.query(createPermissionQuery, [module, action, description]);
+    return result.rows[0];
+}
+
+export const getAllPermissions = () => {
+
+    const result =
+        await pool.query(getAllPermissionsQuery);
+
+    return result.rows;
+}
+
+export const getPermissionById = (id) => {
+
+    const result =
+        await pool.query(
+            getPermissionByIdQuery,
+            [id]
+        );
+
+    return result.rows[0];
+}
+
+export const deletePermission = (id) => {
+
+    const result =
+        await pool.query(
+            deletePermissionQuery,
+            [id]
+        );
+
+    return result.rows[0];
+}

package/src/repositories/roleRepository.js

@@ -0,0 +1,12 @@
+import pool from "../config/db.js";
+import { createRoleQuery, getAllRolesQuery } from "../models/role.js";
+
+export const createRole = (data) => {
+    const result = await pool.query(createRoleQuery, [data.role_name, data.description]);
+    return result.rows[0];
+}
+
+export const getAllRoles = () => {
+    const result = await pool.query(getAllRolesQuery);
+    return result.rows;
+}

package/src/repositories/user.js

@@ -0,0 +1,37 @@
+import pool from "../config/db.js";
+
+export const create = async (userData) => {
+    const { name, email, password, role } = userData;
+    const result = await pool.query(
+        `INSERT INTO users (name, email, password, role) VALUES ($1, $2, $3, $4) RETURNING *`,
+        [name, email, password, role]
+    )
+    return result.rows[0];
+}
+
+export const getAll = async () => {
+    const result = await pool.query(`SELECT * FROM user ORDER BY created_at DESC`);
+    return result.rows;
+}
+
+export const getById = async (id) => {
+    const result = await pool.query(`SELECT * FROM users WHERE id = $1`, [id]);
+    return result.rows[0];
+}
+
+export const getByEmail = async (email) => {
+    const result = await pool.query(`SELECT * FROM users WHERE email = $1`, [email]);
+    return result.rows[0];
+}
+
+export const update = async (id, userData) => {
+    const { name, email, role } = userData;
+    const result = await pool.query(`UPDATE users SET name = $1, email = $2, role = $3, updated_at = CURRENT_TIMESTAMPS WHERE id = $4 RETURNING *`,
+        [name, email, role, id]);
+    return result.rows[0];
+}
+
+export const remove = async (id) => {
+    const result = await pool.query(`DELETE FROM users WHERE id = $1 RETURNING *`, [id]);
+    return result.rows[0];
+}

package/src/routes/index.js

@@ -0,0 +1,4 @@
+import express from "express";
+const router = express.Router();
+
+export default router;

package/src/routes/user.js

@@ -0,0 +1,7 @@
+import express from "express";
+const router = express.Router();
+
+router.post("/", );
+router.get("/", );
+
+export default router;

package/src/server.js

@@ -0,0 +1,27 @@
+import express from "express";
+import dotenv from "dotenv";
+import pool from "./config/db.js";
+import app from "./app";
+import { setupdb } from "./database/setupdb.js";
+
+const port = process.env.PORT;
+
+dotenv.config();
+
+const startServer = async () => {
+    try {
+        const client = await pool.connect();
+        console.log("Connected to PostgreSQL database successfully");
+
+        await setupdb();
+
+        app.listen(port, () => {
+            console.log(`Server is running on port '${port}'`);
+        })
+    } catch (error) {
+        console.error("Error connecting to the database", error);
+        process.exit(1);
+    }
+}
+
+startServer();

package/src/services/permissionService.js

@@ -0,0 +1,21 @@
+import permissionRepository
+    from "../repositories/permissionRepository.js";
+
+
+export const createPermission = async (data) => {
+
+    return await permissionRepository
+        .createPermission(data);
+}
+
+export const getAllPermissions = async () => {
+
+    return await permissionRepository
+        .getAllPermissions();
+}
+
+export const deletePermission = async (id) => {
+
+    return await permissionRepository
+        .deletePermission(id);
+}

package/src/services/roleService.js

@@ -0,0 +1,10 @@
+import { getAllRolesQuery } from "../models/role";
+import { createRole } from "../repositories/roleRepository.js";
+
+export const createRoleService = (data) => {
+    return await createRole(data);
+}
+
+export const getAllRolesService = () => {
+    return await getAllRolesQuery();
+}

package/src/services/user.js

@@ -0,0 +1,28 @@
+import * as userRepository from '../repositories/userRepository.js';
+
+export const getAllUsers = async () => {
+  return await userRepository.findAll();
+};
+
+export const getUserById = async (id) => {
+  return await userRepository.findById(id);
+};
+
+export const createUser = async (userData) => {
+  // Example of business logic in service
+  if (userData.age && userData.age < 0) {
+    throw new Error('Age cannot be negative');
+  }
+  return await userRepository.create(userData);
+};
+
+export const updateUser = async (id, userData) => {
+  if (userData.age && userData.age < 0) {
+    throw new Error('Age cannot be negative');
+  }
+  return await userRepository.update(id, userData);
+};
+
+export const deleteUser = async (id) => {
+  return await userRepository.remove(id);
+};

package/src/utils/jwt.js

@@ -0,0 +1,11 @@
+import jwt from "jsonwebtoken";
+
+export const accessToken = (user) => {
+    return jwt.sign({ id: user.id, email: user.email, role: user.role },
+        process.env.JWT_SECRET_key,
+        { expiresIn: '1d' });
+}
+
+export const verifyToken = (token) => {
+    return jwt.verify(token, process.env.JWT_SECRET_key);
+}